453 lines
17 KiB
C++
453 lines
17 KiB
C++
#include <unistd.h>
|
|
#include <stddef.h>
|
|
#include <getopt.h>
|
|
#include <arpa/inet.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif
|
|
#include "monitor/monitor_private.h"
|
|
#include "monitor/monitor_utils.h"
|
|
#include "sds/sds.h"
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
TEST(MONITOR_UTIL, key_value_test)
|
|
{
|
|
struct stm_key_value *kv = NULL;
|
|
char key_buf[16];
|
|
char value_buf[16];
|
|
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
snprintf(key_buf, sizeof(key_buf), "key%d", i);
|
|
snprintf(value_buf, sizeof(value_buf), "value%d", i);
|
|
stm_cmd_key_value_append(&kv, key_buf, value_buf);
|
|
}
|
|
|
|
ASSERT_EQ(10, kv->tuple_num);
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
snprintf(key_buf, sizeof(key_buf), "key%d", i);
|
|
snprintf(value_buf, sizeof(value_buf), "value%d", i);
|
|
ASSERT_STREQ(key_buf, kv->tuple[i].key);
|
|
ASSERT_STREQ(value_buf, kv->tuple[i].value);
|
|
}
|
|
|
|
stm_cmd_key_value_free(kv);
|
|
}
|
|
|
|
TEST(MONITOR_UTIL, stm_strncasecmp_exactly)
|
|
{
|
|
ASSERT_EQ(0, stm_strncasecmp_exactly("abc", "abc", 3));
|
|
ASSERT_EQ(0, stm_strncasecmp_exactly("abc", "ABC", 3));
|
|
ASSERT_EQ(-1, stm_strncasecmp_exactly("abc", "ABCD", 3));
|
|
ASSERT_EQ(-1, stm_strncasecmp_exactly("abc", "ABCD", 4));
|
|
ASSERT_EQ(-1, stm_strncasecmp_exactly(NULL, "ABCD", 4));
|
|
ASSERT_EQ(-1, stm_strncasecmp_exactly("abc", NULL, 4));
|
|
ASSERT_EQ(-1, stm_strncasecmp_exactly("", NULL, 4));
|
|
ASSERT_EQ(0, stm_strncasecmp_exactly("", "", 0));
|
|
}
|
|
|
|
TEST(MONITOR_UTIL, time_range)
|
|
{
|
|
time_t time_range[2];
|
|
ASSERT_EQ(-1, stm_time_range_pton(NULL, 0, NULL));
|
|
ASSERT_EQ(-1, stm_time_range_pton(NULL, 0, time_range));
|
|
ASSERT_EQ(-1, stm_time_range_pton("last-7-days", 0, NULL));
|
|
|
|
ASSERT_EQ(-1, stm_time_range_pton("last", 0, time_range));
|
|
ASSERT_EQ(-1, stm_time_range_pton("last-", 0, time_range));
|
|
ASSERT_EQ(-1, stm_time_range_pton("last-1", 0, time_range));
|
|
ASSERT_EQ(-1, stm_time_range_pton("last-1-", 0, time_range));
|
|
ASSERT_EQ(-1, stm_time_range_pton("last-1-d", 0, time_range));
|
|
ASSERT_EQ(-1, stm_time_range_pton("last-1-da", 0, time_range));
|
|
ASSERT_EQ(-1, stm_time_range_pton("last-1-day", 0, time_range));
|
|
ASSERT_EQ(0, stm_time_range_pton("last-1-days", 0, time_range));
|
|
|
|
time_t now = 10000000;
|
|
ASSERT_EQ(0, stm_time_range_pton("last-1-seconds", now, time_range));
|
|
ASSERT_EQ(now - 1, time_range[0]);
|
|
ASSERT_EQ(now, time_range[1]);
|
|
|
|
ASSERT_EQ(0, stm_time_range_pton("last-1-minutes", now, time_range));
|
|
ASSERT_EQ(now - 60, time_range[0]);
|
|
ASSERT_EQ(now, time_range[1]);
|
|
|
|
ASSERT_EQ(0, stm_time_range_pton("last-1-hours", now, time_range));
|
|
ASSERT_EQ(now - 60 * 60, time_range[0]);
|
|
ASSERT_EQ(now, time_range[1]);
|
|
|
|
ASSERT_EQ(0, stm_time_range_pton("last-1-days", now, time_range));
|
|
ASSERT_EQ(now - 24 * 60 * 60, time_range[0]);
|
|
ASSERT_EQ(now, time_range[1]);
|
|
|
|
now = 100;
|
|
ASSERT_EQ(0, stm_time_range_pton("last-999-days", now, time_range));
|
|
ASSERT_EQ(0, time_range[0]);
|
|
ASSERT_EQ(now, time_range[1]);
|
|
|
|
now = 10000;
|
|
ASSERT_EQ(0, stm_time_range_pton("last-1-seconds", now, time_range));
|
|
ASSERT_EQ(1, stm_time_in_range(now - 1, time_range));
|
|
ASSERT_EQ(0, stm_time_in_range(now - 10, time_range));
|
|
ASSERT_EQ(0, stm_time_in_range(now + 1, time_range));
|
|
|
|
ASSERT_EQ(0, stm_time_range_pton("last-1-minutes", now, time_range));
|
|
ASSERT_EQ(1, stm_time_in_range(now - 60, time_range));
|
|
ASSERT_EQ(0, stm_time_in_range(now - 61, time_range));
|
|
ASSERT_EQ(0, stm_time_in_range(now + 1, time_range));
|
|
|
|
ASSERT_EQ(0, stm_time_range_pton("last-1-hours", now, time_range));
|
|
ASSERT_EQ(1, stm_time_in_range(now - 60 * 60, time_range));
|
|
ASSERT_EQ(0, stm_time_in_range(now - 60 * 60 - 1, time_range));
|
|
ASSERT_EQ(0, stm_time_in_range(now + 1, time_range));
|
|
}
|
|
|
|
TEST(MONITOR_UTIL, inet_pton)
|
|
{
|
|
unsigned int ipv4;
|
|
struct in6_addr ipv6;
|
|
|
|
ASSERT_EQ(0, stm_inet_pton(NULL, NULL, NULL));
|
|
ASSERT_EQ(0, stm_inet_pton("", NULL, NULL));
|
|
ASSERT_EQ(0, stm_inet_pton("1.1.1.1", NULL, &ipv6));
|
|
ASSERT_EQ(0, stm_inet_pton("1234::1", &ipv4, NULL));
|
|
|
|
ASSERT_EQ(AF_INET, stm_inet_pton("1.2.3.4", &ipv4, &ipv6));
|
|
ASSERT_EQ(0x04030201, ipv4);
|
|
|
|
ASSERT_EQ(AF_INET, stm_inet_pton("1.2.3.0", &ipv4, &ipv6));
|
|
ASSERT_EQ(0x00030201, ipv4);
|
|
|
|
struct in6_addr ipv6_2;
|
|
inet_pton(AF_INET6, "1234::1", &ipv6_2);
|
|
ASSERT_EQ(AF_INET6, stm_inet_pton("1234::1", &ipv4, &ipv6));
|
|
ASSERT_EQ(0, memcmp(&ipv6_2, &ipv6, sizeof(struct in6_addr)));
|
|
|
|
inet_pton(AF_INET6, "1234::0", &ipv6_2);
|
|
ASSERT_EQ(AF_INET6, stm_inet_pton("1234::0", &ipv4, &ipv6));
|
|
ASSERT_EQ(0, memcmp(&ipv6_2, &ipv6, sizeof(struct in6_addr)));
|
|
}
|
|
|
|
TEST(MONITOR_UTIL, ip_cidr_pton)
|
|
{
|
|
unsigned int ipv4, maskv4;
|
|
struct in6_addr ipv6, maskv6;
|
|
struct in6_addr expect_maskv6;
|
|
|
|
ASSERT_EQ(0, stm_ip_cidr_pton(NULL, NULL, NULL, NULL, NULL));
|
|
ASSERT_EQ(0, stm_ip_cidr_pton("abcdefg", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
ASSERT_EQ(0, stm_ip_cidr_pton("1.1.1.1", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
ASSERT_EQ(0, stm_ip_cidr_pton("1.1.1.1/", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
ASSERT_EQ(0, stm_ip_cidr_pton("1.1.1.1/xx", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
|
|
ASSERT_EQ(AF_INET, stm_ip_cidr_pton("1.1.1.1/8", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
ASSERT_EQ(0xFF000000, ntohl(maskv4));
|
|
ASSERT_EQ(AF_INET, stm_ip_cidr_pton("1.1.1.1/16", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
ASSERT_EQ(0xFFFF0000, ntohl(maskv4));
|
|
ASSERT_EQ(AF_INET, stm_ip_cidr_pton("1.1.1.1/24", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
ASSERT_EQ(0xFFFFFF00, ntohl(maskv4));
|
|
ASSERT_EQ(AF_INET, stm_ip_cidr_pton("1.1.1.1/32", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
ASSERT_EQ(0xFFFFFFFF, maskv4);
|
|
ASSERT_EQ(0, stm_ip_cidr_pton("1.1.1.1/33", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
|
|
/* IPV6 */
|
|
ASSERT_EQ(AF_INET6, stm_ip_cidr_pton("::1/8", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
memset(&expect_maskv6, 0, sizeof(struct in6_addr));
|
|
expect_maskv6.s6_addr[0] = 0xFF;
|
|
ASSERT_EQ(0, memcmp(&expect_maskv6, &maskv6, sizeof(struct in6_addr)));
|
|
|
|
ASSERT_EQ(AF_INET6, stm_ip_cidr_pton("::1/32", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
memset(&expect_maskv6, 0, sizeof(struct in6_addr));
|
|
expect_maskv6.s6_addr[0] = 0xFF;
|
|
expect_maskv6.s6_addr[1] = 0xFF;
|
|
expect_maskv6.s6_addr[2] = 0xFF;
|
|
expect_maskv6.s6_addr[3] = 0xFF;
|
|
ASSERT_EQ(0, memcmp(&expect_maskv6, &maskv6, sizeof(struct in6_addr)));
|
|
|
|
ASSERT_EQ(AF_INET6, stm_ip_cidr_pton("::1/128", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
memset(&expect_maskv6, 0xFF, sizeof(struct in6_addr));
|
|
ASSERT_EQ(0, memcmp(&expect_maskv6, &maskv6, sizeof(struct in6_addr)));
|
|
|
|
ASSERT_EQ(0, stm_ip_cidr_pton("1.1.1.1/129", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
}
|
|
|
|
TEST(MONITOR_UTIL, stm_ipv4_cidr_to_range)
|
|
{
|
|
uint32_t ipaddr, ipmask;
|
|
uint32_t iprange[2];
|
|
inet_pton(AF_INET, "192.168.1.1", &ipaddr);
|
|
inet_pton(AF_INET, "255.0.0.0", &ipmask);
|
|
stm_ipv4_cidr_to_range(ipaddr, ipmask, iprange);
|
|
ASSERT_EQ(iprange[0], ntohl(0xc0000000));
|
|
ASSERT_EQ(iprange[1], ntohl(0xc0FFFFFF));
|
|
|
|
inet_pton(AF_INET, "192.168.1.1", &ipaddr);
|
|
inet_pton(AF_INET, "255.255.0.0", &ipmask);
|
|
stm_ipv4_cidr_to_range(ipaddr, ipmask, iprange);
|
|
ASSERT_EQ(iprange[0], ntohl(0xc0A80000));
|
|
ASSERT_EQ(iprange[1], ntohl(0xc0A8FFFF));
|
|
|
|
inet_pton(AF_INET, "192.168.1.1", &ipaddr);
|
|
inet_pton(AF_INET, "255.128.0.0", &ipmask);
|
|
stm_ipv4_cidr_to_range(ipaddr, ipmask, iprange);
|
|
ASSERT_EQ(iprange[0], ntohl(0xc0800000));
|
|
ASSERT_EQ(iprange[1], ntohl(0xc0FFFFFF));
|
|
|
|
inet_pton(AF_INET, "192.168.1.1", &ipaddr);
|
|
inet_pton(AF_INET, "255.255.255.0", &ipmask);
|
|
stm_ipv4_cidr_to_range(ipaddr, ipmask, iprange);
|
|
ASSERT_EQ(iprange[0], ntohl(0xc0A80100));
|
|
ASSERT_EQ(iprange[1], ntohl(0xc0A801FF));
|
|
|
|
inet_pton(AF_INET, "192.168.1.1", &ipaddr);
|
|
inet_pton(AF_INET, "255.255.255.255", &ipmask);
|
|
stm_ipv4_cidr_to_range(ipaddr, ipmask, iprange);
|
|
ASSERT_EQ(iprange[0], ntohl(0xc0A80101));
|
|
ASSERT_EQ(iprange[1], ntohl(0xc0A80101));
|
|
}
|
|
|
|
TEST(MONITOR_UTIL, stm_ipv4_cidr_string_to_range)
|
|
{
|
|
uint32_t ipv4, maskv4;
|
|
struct in6_addr ipv6, maskv6;
|
|
uint32_t ipv4_range[2];
|
|
|
|
ASSERT_EQ(AF_INET, stm_ip_cidr_pton("1.1.1.0/8", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
stm_ipv4_cidr_to_range(ipv4, maskv4, ipv4_range);
|
|
ASSERT_EQ(ipv4_range[0], ntohl(0x01000000));
|
|
ASSERT_EQ(ipv4_range[1], ntohl(0x01FFFFFF));
|
|
|
|
ASSERT_EQ(AF_INET, stm_ip_cidr_pton("1.1.1.0/24", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
stm_ipv4_cidr_to_range(ipv4, maskv4, ipv4_range);
|
|
ASSERT_EQ(ipv4_range[0], ntohl(0x01010100));
|
|
ASSERT_EQ(ipv4_range[1], ntohl(0x010101FF));
|
|
|
|
ASSERT_EQ(AF_INET, stm_ip_cidr_pton("1.2.3.4/32", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
stm_ipv4_cidr_to_range(ipv4, maskv4, ipv4_range);
|
|
ASSERT_EQ(ipv4_range[0], ntohl(0x01020304));
|
|
ASSERT_EQ(ipv4_range[1], ntohl(0x01020304));
|
|
}
|
|
|
|
TEST(MONITOR_UTIL, stm_ipv6_cidr_string_to_range)
|
|
{
|
|
uint32_t ipv4, maskv4;
|
|
struct in6_addr ipv6, maskv6;
|
|
struct in6_addr ipv6_range[2];
|
|
struct in6_addr expect_addr;
|
|
|
|
ASSERT_EQ(AF_INET6, stm_ip_cidr_pton("1234::abcd/8", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
stm_ipv6_cidr_to_range(&ipv6, &maskv6, ipv6_range);
|
|
inet_pton(AF_INET6, "1200::0", &expect_addr);
|
|
ASSERT_EQ(0, memcmp(&ipv6_range[0], &expect_addr, sizeof(struct in6_addr)));
|
|
inet_pton(AF_INET6, "12ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", &expect_addr);
|
|
ASSERT_EQ(0, memcmp(&ipv6_range[1], &expect_addr, sizeof(struct in6_addr)));
|
|
|
|
ASSERT_EQ(AF_INET6, stm_ip_cidr_pton("1234::abcd/16", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
stm_ipv6_cidr_to_range(&ipv6, &maskv6, ipv6_range);
|
|
inet_pton(AF_INET6, "1234::0", &expect_addr);
|
|
ASSERT_EQ(0, memcmp(&ipv6_range[0], &expect_addr, sizeof(struct in6_addr)));
|
|
inet_pton(AF_INET6, "1234:ffff:ffff:ffff:ffff:ffff:ffff:ffff", &expect_addr);
|
|
ASSERT_EQ(0, memcmp(&ipv6_range[1], &expect_addr, sizeof(struct in6_addr)));
|
|
|
|
ASSERT_EQ(AF_INET6, stm_ip_cidr_pton("1234::abcd/128", &ipv4, &maskv4, &ipv6, &maskv6));
|
|
stm_ipv6_cidr_to_range(&ipv6, &maskv6, ipv6_range);
|
|
inet_pton(AF_INET6, "1234::abcd", &expect_addr);
|
|
ASSERT_EQ(0, memcmp(&ipv6_range[0], &expect_addr, sizeof(struct in6_addr)));
|
|
ASSERT_EQ(0, memcmp(&ipv6_range[1], &expect_addr, sizeof(struct in6_addr)));
|
|
}
|
|
|
|
TEST(MONITOR_UTIL, stm_ipv6_cidr_to_range)
|
|
{
|
|
struct in6_addr ipaddr, ipmask;
|
|
struct in6_addr iprange[2];
|
|
struct in6_addr expect_range[2];
|
|
|
|
inet_pton(AF_INET6, "1234::abcd", &ipaddr);
|
|
inet_pton(AF_INET6, "ff00::", &ipmask); // 8bit mask
|
|
stm_ipv6_cidr_to_range(&ipaddr, &ipmask, iprange);
|
|
inet_pton(AF_INET6, "1200::", &expect_range[0]);
|
|
inet_pton(AF_INET6, "12ff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", &expect_range[1]);
|
|
ASSERT_EQ(0, memcmp(&expect_range[0], &iprange[0], sizeof(struct in6_addr)));
|
|
ASSERT_EQ(0, memcmp(&expect_range[1], &iprange[1], sizeof(struct in6_addr)));
|
|
|
|
inet_pton(AF_INET6, "1234::abcd", &ipaddr);
|
|
inet_pton(AF_INET6, "ffff::", &ipmask); // 16bit mask
|
|
stm_ipv6_cidr_to_range(&ipaddr, &ipmask, iprange);
|
|
inet_pton(AF_INET6, "1234::", &expect_range[0]);
|
|
inet_pton(AF_INET6, "1234:ffff:ffff:ffff:ffff:ffff:ffff:ffff", &expect_range[1]);
|
|
ASSERT_EQ(0, memcmp(&expect_range[0], &iprange[0], sizeof(struct in6_addr)));
|
|
ASSERT_EQ(0, memcmp(&expect_range[1], &iprange[1], sizeof(struct in6_addr)));
|
|
|
|
inet_pton(AF_INET6, "1234::abcd", &ipaddr);
|
|
inet_pton(AF_INET6, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", &ipmask); // 128bit mask
|
|
stm_ipv6_cidr_to_range(&ipaddr, &ipmask, iprange);
|
|
inet_pton(AF_INET6, "1234::abcd", &expect_range[0]);
|
|
inet_pton(AF_INET6, "1234::abcd", &expect_range[1]);
|
|
ASSERT_EQ(0, memcmp(&expect_range[0], &iprange[0], sizeof(struct in6_addr)));
|
|
ASSERT_EQ(0, memcmp(&expect_range[1], &iprange[1], sizeof(struct in6_addr)));
|
|
}
|
|
|
|
TEST(MONITOR_UTIL, mem_rand)
|
|
{
|
|
char buf[10000];
|
|
srand(time(NULL));
|
|
stm_mem_fill_rand(buf, sizeof(buf), 31, 61);
|
|
for (size_t i = 0; i < sizeof(buf); i++)
|
|
{
|
|
ASSERT_GE(buf[i], 31);
|
|
ASSERT_LE(buf[i], 61);
|
|
}
|
|
}
|
|
|
|
TEST(MONITOR_UTIL, timeout)
|
|
{
|
|
struct timeval start, end;
|
|
start.tv_sec = 10000;
|
|
start.tv_usec = 0;
|
|
|
|
end = start;
|
|
ASSERT_EQ(0, stm_timeout(start, end, 1));
|
|
end.tv_sec += 1;
|
|
ASSERT_EQ(1, stm_timeout(start, end, 1));
|
|
|
|
end = start;
|
|
end.tv_usec += 999999;
|
|
ASSERT_EQ(0, stm_timeout(start, end, 1));
|
|
|
|
start.tv_sec = 10000;
|
|
start.tv_usec = 900 * 1000;
|
|
end.tv_sec = 10001;
|
|
end.tv_usec = 1;
|
|
ASSERT_EQ(0, stm_timeout(start, end, 1));
|
|
end.tv_usec += 999999;
|
|
ASSERT_EQ(1, stm_timeout(start, end, 1));
|
|
}
|
|
|
|
TEST(MONITOR_UTIL, parse_cli_arg)
|
|
{
|
|
struct monitor_cli_args expect_args[] =
|
|
{
|
|
{"-i", "--ip", 1, 0, NULL},
|
|
{"-p", "--port", 1, 0, NULL},
|
|
{"-t", "--timeout", 1, 0, NULL},
|
|
{"-e", "--exec", 1, 1, NULL},
|
|
};
|
|
|
|
int argc = 0;
|
|
const char *cli_cmd = NULL;
|
|
sds *argv = NULL;
|
|
|
|
/* TEST: short options */
|
|
cli_cmd = "./monitor_cli -i 1.1.1.1 -p 8080 -t 30 -e a b c d e f g ";
|
|
argv = sdssplitargs((char *)cli_cmd, &argc);
|
|
EXPECT_EQ(0, monitor_util_parse_cmd_args(argc, (const char **)argv, expect_args, 4));
|
|
EXPECT_STREQ("1.1.1.1", expect_args[0].value);
|
|
EXPECT_STREQ("8080", expect_args[1].value);
|
|
EXPECT_STREQ("30", expect_args[2].value);
|
|
EXPECT_STREQ("a b c d e f g", expect_args[3].value);
|
|
sdsfree(expect_args[0].value);
|
|
expect_args[0].value = NULL;
|
|
sdsfree(expect_args[1].value);
|
|
expect_args[1].value = NULL;
|
|
sdsfree(expect_args[2].value);
|
|
expect_args[2].value = NULL;
|
|
sdsfree(expect_args[3].value);
|
|
expect_args[3].value = NULL;
|
|
sdsfreesplitres(argv, argc);
|
|
|
|
/* TEST: long options */
|
|
cli_cmd = "./monitor_cli --ip 111.111.111.111 --port 80808 --timeout 300 --exec a b c d e f g ";
|
|
argv = sdssplitargs((char *)cli_cmd, &argc);
|
|
EXPECT_EQ(0, monitor_util_parse_cmd_args(argc, (const char **)argv, expect_args, 4));
|
|
EXPECT_STREQ("111.111.111.111", expect_args[0].value);
|
|
EXPECT_STREQ("80808", expect_args[1].value);
|
|
EXPECT_STREQ("300", expect_args[2].value);
|
|
EXPECT_STREQ("a b c d e f g", expect_args[3].value);
|
|
sdsfree(expect_args[0].value);
|
|
expect_args[0].value = NULL;
|
|
sdsfree(expect_args[1].value);
|
|
expect_args[1].value = NULL;
|
|
sdsfree(expect_args[2].value);
|
|
expect_args[2].value = NULL;
|
|
sdsfree(expect_args[3].value);
|
|
expect_args[3].value = NULL;
|
|
sdsfreesplitres(argv, argc);
|
|
|
|
/* TEST: short options out of order */
|
|
cli_cmd = "./monitor_cli -e a b c d e f g -t 30 -i 1.1.1.1 -p 8080 ";
|
|
argv = sdssplitargs((char *)cli_cmd, &argc);
|
|
EXPECT_EQ(0, monitor_util_parse_cmd_args(argc, (const char **)argv, expect_args, 4));
|
|
EXPECT_STREQ("1.1.1.1", expect_args[0].value);
|
|
EXPECT_STREQ("8080", expect_args[1].value);
|
|
EXPECT_STREQ("30", expect_args[2].value);
|
|
EXPECT_STREQ("a b c d e f g", expect_args[3].value);
|
|
sdsfree(expect_args[0].value);
|
|
expect_args[0].value = NULL;
|
|
sdsfree(expect_args[1].value);
|
|
expect_args[1].value = NULL;
|
|
sdsfree(expect_args[2].value);
|
|
expect_args[2].value = NULL;
|
|
sdsfree(expect_args[3].value);
|
|
expect_args[3].value = NULL;
|
|
sdsfreesplitres(argv, argc);
|
|
|
|
/* TEST: short options with quotes */
|
|
cli_cmd = "./monitor_cli -i 1.1.1.1 -p 8080 -t 30 -e \"a b c d e f g\"";
|
|
argv = sdssplitargs((char *)cli_cmd, &argc);
|
|
EXPECT_EQ(0, monitor_util_parse_cmd_args(argc, (const char **)argv, expect_args, 4));
|
|
EXPECT_STREQ("1.1.1.1", expect_args[0].value);
|
|
EXPECT_STREQ("8080", expect_args[1].value);
|
|
EXPECT_STREQ("30", expect_args[2].value);
|
|
EXPECT_STREQ("a b c d e f g", expect_args[3].value);
|
|
sdsfree(expect_args[0].value);
|
|
expect_args[0].value = NULL;
|
|
sdsfree(expect_args[1].value);
|
|
expect_args[1].value = NULL;
|
|
sdsfree(expect_args[2].value);
|
|
expect_args[2].value = NULL;
|
|
sdsfree(expect_args[3].value);
|
|
expect_args[3].value = NULL;
|
|
sdsfreesplitres(argv, argc);
|
|
}
|
|
|
|
TEST(MONITOR_UTIL, reply)
|
|
{
|
|
struct monitor_reply *reply;
|
|
|
|
reply = monitor_reply_nil();
|
|
sds reply_str = monitor_reply_to_string(reply);
|
|
EXPECT_STREQ(reply_str, "(nil)\r\n");
|
|
sdsfree(reply_str);
|
|
monitor_reply_free(reply);
|
|
|
|
reply = monitor_reply_new_string("hello, %s", "world");
|
|
reply_str = monitor_reply_to_string(reply);
|
|
EXPECT_STREQ(reply_str, "hello, world\r\n");
|
|
sdsfree(reply_str);
|
|
monitor_reply_free(reply);
|
|
|
|
reply = monitor_reply_new_integer(12345);
|
|
reply_str = monitor_reply_to_string(reply);
|
|
EXPECT_STREQ(reply_str, "(integer) 12345\r\n");
|
|
sdsfree(reply_str);
|
|
monitor_reply_free(reply);
|
|
|
|
reply = monitor_reply_new_double(123.456);
|
|
reply_str = monitor_reply_to_string(reply);
|
|
EXPECT_STREQ(reply_str, "(double) 123.456000\r\n");
|
|
sdsfree(reply_str);
|
|
monitor_reply_free(reply);
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
testing::InitGoogleTest(&argc, argv);
|
|
int ret = RUN_ALL_TESTS();
|
|
return ret;
|
|
} |