void
test_lagopus_ip_address_copy(void) {
lagopus_result_t rc;
const char *name1 = "127.0.0.1";
const char *name2 = "::1";
lagopus_ip_address_t *actual_ip1 = NULL;
lagopus_ip_address_t *actual_ip2 = NULL;
lagopus_ip_address_t *expected_ip1 = NULL;
lagopus_ip_address_t *expected_ip2 = NULL;
rc = lagopus_ip_address_create(name1, true, &actual_ip1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_STRING(name1, actual_ip1->addr_str);
rc = lagopus_ip_address_create(name2, false, &actual_ip2);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_STRING(name2, actual_ip2->addr_str);
// Normal case
{
rc = lagopus_ip_address_copy(actual_ip1, &expected_ip1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL((expected_ip1->saddr).ss_family,
(actual_ip1->saddr).ss_family);
TEST_ASSERT_EQUAL_STRING(expected_ip1->addr_str, actual_ip1->addr_str);
TEST_ASSERT_TRUE(actual_ip1->is_ipv4 == expected_ip1->is_ipv4);
rc = lagopus_ip_address_copy(actual_ip2, &expected_ip2);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL((expected_ip2->saddr).ss_family,
(actual_ip2->saddr).ss_family);
TEST_ASSERT_EQUAL_STRING(expected_ip2->addr_str, actual_ip2->addr_str);
TEST_ASSERT_TRUE(actual_ip2->is_ipv4 == expected_ip2->is_ipv4);
rc = lagopus_ip_address_copy(actual_ip2, &actual_ip1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL((expected_ip2->saddr).ss_family,
(actual_ip1->saddr).ss_family);
TEST_ASSERT_EQUAL_STRING(expected_ip2->addr_str, actual_ip1->addr_str);
TEST_ASSERT_TRUE(actual_ip1->is_ipv4 == expected_ip2->is_ipv4);
}
// Abnormal case
{
rc = lagopus_ip_address_copy(NULL, &expected_ip1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = lagopus_ip_address_copy(actual_ip1, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
}
lagopus_ip_address_destroy(actual_ip1);
lagopus_ip_address_destroy(actual_ip2);
lagopus_ip_address_destroy(expected_ip1);
lagopus_ip_address_destroy(expected_ip2);
}
void
setUp(void) {
size_t s;
lagopus_ip_address_t *addr;
struct sockaddr_in *sin;
uint8_t *p;
/* Make the root flowinfo. */
TEST_ASSERT_NULL(flowinfo);
flowinfo = new_flowinfo_vlan_vid();
TEST_ASSERT_NOT_NULL(flowinfo);
TEST_ASSERT_FLOWINFO_FLOW_NUM(flowinfo, 0, __func__);
/*
* Make the test flows.
*
* ARP matches have the prerequisite.
*/
for (s = 0; s < ARRAY_LEN(test_flow); s++) {
TEST_ASSERT_NULL(test_flow[s]);
test_flow[s] = allocate_test_flow(10 * sizeof(struct match));
TEST_ASSERT_NOT_NULL(test_flow[s]);
test_flow[s]->priority = (int)s;
FLOW_ADD_ARP_PREREQUISITE(test_flow[s]);
}
/* Make the test addresses. */
for (s = 0; s < ARRAY_LEN(test_flow); s++) {
lagopus_ip_address_create(ipv4srcstr, true, &addr);
sin = NULL;
lagopus_ip_address_sockaddr_get(addr, &sin);
lagopus_ip_address_destroy(addr);
p = (uint8_t *)&sin->sin_addr.s_addr;
p[sizeof(sin->sin_addr.s_addr) - 1] = (uint8_t)(TEST_IPV4_ADDR_LSB(s) & 0xff);
OS_MEMCPY(&ipv4src[s], &sin->sin_addr, sizeof(ipv4src[s]));
lagopus_ip_address_create(ipv4tgtstr, true, &addr);
sin = NULL;
lagopus_ip_address_sockaddr_get(addr, &sin);
lagopus_ip_address_destroy(addr);
p = (uint8_t *)&sin->sin_addr.s_addr;
p[sizeof(sin->sin_addr.s_addr) - 1] = (uint8_t)(TEST_IPV4_ADDR_LSB(s) & 0xff);
OS_MEMCPY(&ipv4tgt[s], &sin->sin_addr, sizeof(ipv4tgt[s]));
lagopus_ip_address_create(ipv4maskstr, true, &addr);
sin = NULL;
lagopus_ip_address_sockaddr_get(addr, &sin);
lagopus_ip_address_destroy(addr);
OS_MEMCPY(&ipv4mask[s], &sin->sin_addr, sizeof(ipv4mask[s]));
}
}
lagopus_result_t
channel_mgr_channel_local_addr_get(const char *channel_name,
lagopus_ip_address_t **local_addr) {
char ipaddr[INET6_ADDRSTRLEN+1];
lagopus_result_t ret;
struct channel *chan;
struct addrunion addr = {0};
ret = channel_mgr_channel_lookup_by_name(channel_name, &chan);
if (ret != LAGOPUS_RESULT_OK) {
return ret;
}
ret = channel_local_addr_get(chan, &addr);
if (ret != LAGOPUS_RESULT_OK) {
return ret;
}
if (addrunion_ipaddr_str_get(&addr, ipaddr, sizeof(ipaddr)) == NULL) {
return LAGOPUS_RESULT_ANY_FAILURES;
}
ret = lagopus_ip_address_create(ipaddr,
addrunion_af_get(&addr) == AF_INET ? true : false, local_addr);
if (ret != LAGOPUS_RESULT_OK) {
return ret;
}
return ret;
}
void
test_ip_address_public_ip_address_str(void) {
lagopus_result_t rc;
lagopus_ip_address_t *ip1 = NULL;
lagopus_ip_address_t *ip2 = NULL;
const char *name1 = "127.0.0.1";
const char *name2 = "::1";
char *actual_addr_str1 = NULL;
char *actual_addr_str2 = NULL;
const char *expected_addr_str1 = name1;
const char *expected_addr_str2 = name2;
rc = lagopus_ip_address_create(name1, true, &ip1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
rc = lagopus_ip_address_create(name2, false, &ip2);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
// Normal case of getter
{
rc = lagopus_ip_address_str_get(ip1, &actual_addr_str1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_STRING(expected_addr_str1, actual_addr_str1);
rc = lagopus_ip_address_str_get(ip2, &actual_addr_str2);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_STRING(expected_addr_str2, actual_addr_str2);
}
// Abnormal case of getter
{
rc = lagopus_ip_address_str_get(NULL, &actual_addr_str1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = lagopus_ip_address_str_get(ip1, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
}
free(actual_addr_str1);
free(actual_addr_str2);
lagopus_ip_address_destroy(ip1);
lagopus_ip_address_destroy(ip2);
}
void
test_channel_mgr_channel_create(void) {
lagopus_result_t ret;
lagopus_ip_address_t *addr4 = NULL;
lagopus_ip_address_create("127.0.0.1", true, &addr4);
ret = channel_mgr_channel_create("channel1", addr4, 10032, NULL, 0,
DATASTORE_CHANNEL_PROTOCOL_TCP);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_start("channel1");
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, ret);
ret = channel_mgr_channel_destroy("channel1");
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
lagopus_ip_address_destroy(addr4);
}
void
test_channel_mgr_apis(void) {
lagopus_ip_address_t *addr4 = NULL, *laddr4 = NULL;
struct channel *chan = NULL;
lagopus_result_t ret;
uint16_t sport;
datastore_controller_role_t role;
datastore_channel_status_t status;
uint8_t version;
lagopus_ip_address_create("127.0.0.1", true, &addr4);
ret = channel_mgr_channel_create("channel1", addr4, 10032, addr4, 20032,
DATASTORE_CHANNEL_PROTOCOL_TCP);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_lookup_by_name("channel1", &chan);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_controller_set("channel1", DATASTORE_CONTROLLER_ROLE_MASTER,
DATASTORE_CONTROLLER_CONNECTION_TYPE_AUXILIARY);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_local_port_get("channel1", &sport);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_EQUAL(20032, sport);
ret = channel_mgr_channel_local_addr_get("channel1", &laddr4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_EQUAL(true, lagopus_ip_address_equals(addr4, laddr4));
ret = channel_mgr_channel_connection_status_get("channel1", &status);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_EQUAL(DATASTORE_CHANNEL_DISONNECTED, status);
ret = channel_mgr_channel_role_get("channel1", &role);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_EQUAL(DATASTORE_CONTROLLER_ROLE_MASTER, role);
ret = channel_mgr_ofp_version_get("channel1", &version);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_EQUAL(4, version);
ret = channel_mgr_channel_dpid_set("channel1", (uint64_t) dpid);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_dpid_unset("channel1");
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_dpid_set("channel1", (uint64_t) dpid);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_start("channel1");
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_connection_status_get("channel1", &status);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_dpid_unset("channel1");
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_stop("channel1");
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_destroy("channel1");
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_lookup_by_name("channel1", &chan);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret);
lagopus_ip_address_destroy(addr4);
lagopus_ip_address_destroy(laddr4);
}
void
test_channel_tcp(void) {
int sock4, sock6;
socklen_t size;
struct sockaddr_in sin;
lagopus_ip_address_t *addr4 = NULL;
lagopus_ip_address_t *addr6 = NULL;
struct channel_list *chan_list ;
struct channel *chan4, *chan6, *chan = NULL;
lagopus_result_t ret;
int cnt;
printf("test_channel_tcp in\n");
channel_mgr_initialize();
ret = channel_mgr_channels_lookup_by_dpid(dpid, &chan_list );
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret);
TEST_ASSERT_EQUAL(NULL, chan_list );
ret = lagopus_ip_address_create("127.0.0.1", true, &addr4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = lagopus_ip_address_create("::1", false, &addr6);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_add(bridge_name, dpid, addr4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_add(bridge_name, dpid, addr6);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_add(bridge_name, dpid, addr4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_ALREADY_EXISTS, ret);
ret = channel_mgr_channel_lookup(bridge_name, addr4, &chan4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_EQUAL(0, channel_id_get(chan4));
ret = channel_port_set(chan4, 10022);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_local_port_set(chan4, 20022);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_local_addr_set(chan4, addr4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_add(bridge_name, dpid, addr6);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_ALREADY_EXISTS, ret);
ret = channel_mgr_channel_lookup(bridge_name, addr6, &chan6);
TEST_ASSERT_EQUAL(1, channel_id_get(chan6));
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_port_set(chan6, 10023);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_local_port_set(chan6, 20023);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_local_addr_set(chan6, addr6);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_lookup_by_channel_id(dpid, 1, &chan);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_NOT_EQUAL(NULL, chan);
ret = channel_mgr_channel_lookup_by_channel_id(dpid, 9999, &chan);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret);
TEST_ASSERT_EQUAL(NULL, chan);
cnt = 0;
ret = channel_mgr_channels_lookup_by_dpid(dpid, &chan_list );
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_list_iterate(chan_list , channel_count, &cnt);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_EQUAL(2, cnt);
cnt = 0;
ret = channel_mgr_dpid_iterate(dpid, channel_count, &cnt);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_EQUAL(2, cnt);
run = true;
size = sizeof(sin);
printf("accept in\n");
sock4 = accept(s4, (struct sockaddr *)&sin, &size);
TEST_ASSERT_NOT_EQUAL(-1, sock4);
sock6 = accept(s6, (struct sockaddr *)&sin, &size);
TEST_ASSERT_NOT_EQUAL(-1, sock6);
ret = channel_mgr_channel_lookup(bridge_name, addr4, &chan4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
channel_refs_get(chan4);
ret = channel_mgr_channel_delete(bridge_name, addr4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
channel_refs_put(chan4);
ret = channel_mgr_channel_delete(bridge_name, addr4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_lookup(bridge_name, addr4, &chan4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret);
ret = channel_mgr_channel_delete(bridge_name, addr6);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = channel_mgr_channel_lookup(bridge_name, addr6, &chan6);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret);
TEST_ASSERT_FALSE(channel_mgr_has_alive_channel_by_dpid(dpid));
ret = channel_mgr_event_upcall();
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
lagopus_ip_address_destroy(addr4);
lagopus_ip_address_destroy(addr6);
close(sock4);
close(sock6);
}
void
test_ip_address_public_sockaddr(void) {
lagopus_result_t rc;
lagopus_ip_address_t *ip1 = NULL;
lagopus_ip_address_t *ip2 = NULL;
lagopus_ip_address_t *ip3 = NULL;
lagopus_ip_address_t *ip4 = NULL;
const char *name1 = "127.0.0.1";
const char *name2 = "::1";
const char *name3 = "localhost";
struct sockaddr *actual_sockaddr1 = NULL;
struct sockaddr *actual_sockaddr2 = NULL;
struct sockaddr *actual_sockaddr3 = NULL;
struct sockaddr *actual_sockaddr4 = NULL;
socklen_t actual_sockaddr_len = 0;
char ipv4_addr[INET_ADDRSTRLEN];
char ipv6_addr[INET6_ADDRSTRLEN];
rc = lagopus_ip_address_create(name1, true, &ip1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
rc = lagopus_ip_address_create(name2, false, &ip2);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
rc = lagopus_ip_address_create(name3, true, &ip3);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
// create empty ip.
ip4 = (lagopus_ip_address_t *) calloc(1, (sizeof(lagopus_ip_address_t)));
TEST_ASSERT_NOT_NULL(ip4);
// Normal case of getter
{
/* sockaddr. */
rc = lagopus_ip_address_sockaddr_get(ip1, &actual_sockaddr1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(AF_INET, actual_sockaddr1->sa_family);
inet_ntop(AF_INET, &((struct sockaddr_in *) actual_sockaddr1)->sin_addr,
ipv4_addr, INET_ADDRSTRLEN);
TEST_ASSERT_EQUAL_STRING(name1, ipv4_addr);
/* length of sockaddr. */
rc = lagopus_ip_address_sockaddr_len_get(ip1, &actual_sockaddr_len);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(sizeof(struct sockaddr_in), actual_sockaddr_len);
/* sockaddr. */
rc = lagopus_ip_address_sockaddr_get(ip2, &actual_sockaddr2);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(AF_INET6, actual_sockaddr2->sa_family);
inet_ntop(AF_INET6, &((struct sockaddr_in6 *) actual_sockaddr2)->sin6_addr,
ipv6_addr, INET6_ADDRSTRLEN);
TEST_ASSERT_EQUAL_STRING(name2, ipv6_addr);
/* length of sockaddr. */
rc = lagopus_ip_address_sockaddr_len_get(ip2, &actual_sockaddr_len);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(sizeof(struct sockaddr_in6), actual_sockaddr_len);
/* sockaddr. */
rc = lagopus_ip_address_sockaddr_get(ip3, &actual_sockaddr3);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(AF_INET, actual_sockaddr3->sa_family);
inet_ntop(AF_INET, &((struct sockaddr_in *) actual_sockaddr3)->sin_addr,
ipv4_addr, INET_ADDRSTRLEN);
TEST_ASSERT_EQUAL_STRING(name1, ipv4_addr);
/* length of sockaddr. */
rc = lagopus_ip_address_sockaddr_len_get(ip3, &actual_sockaddr_len);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(sizeof(struct sockaddr_in), actual_sockaddr_len);
}
// Abnormal case of getter
{
rc = lagopus_ip_address_sockaddr_get(NULL, &actual_sockaddr1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = lagopus_ip_address_sockaddr_get(ip1, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = lagopus_ip_address_sockaddr_get(ip4, &actual_sockaddr4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_OBJECT, rc);
rc = lagopus_ip_address_sockaddr_len_get(NULL, &actual_sockaddr_len);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = lagopus_ip_address_sockaddr_len_get(ip1, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
}
free(actual_sockaddr1);
free(actual_sockaddr2);
free(actual_sockaddr3);
free(actual_sockaddr4);
lagopus_ip_address_destroy(ip1);
lagopus_ip_address_destroy(ip2);
lagopus_ip_address_destroy(ip3);
free(ip4);
}
void
test_ip_address_create_and_destroy(void) {
lagopus_result_t rc;
const char *name1 = "127.0.0.1";
const char *name2 = "::1";
const char *name3 = "localhost";
//const char *name4 = "QkwUfh2GGN9sjCx";
const char *name5 = "127.0";
const char *name6 = "127.0.0.0";
const char *name7 = "127.0.0.1.1";
lagopus_ip_address_t *ip1 = NULL;
lagopus_ip_address_t *ip2 = NULL;
lagopus_ip_address_t *ip3 = NULL;
//lagopus_ip_address_t *ip4 = NULL;
lagopus_ip_address_t *ip5 = NULL;
lagopus_ip_address_t *ip6 = NULL;
bool is_ipv4 = false;
{
// Normal case(name = IPv4, ai_family = AF_INET)
rc = lagopus_ip_address_create(name1, true, &ip1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(AF_INET, (ip1->saddr).ss_family);
TEST_ASSERT_NOT_NULL_MESSAGE(
ip1, "lagopus_ip_address_create() will create new ip_address");
TEST_ASSERT_EQUAL_STRING(name1, ip1->addr_str);
TEST_ASSERT_EQUAL(AF_INET, IS_IPV4(ip1->is_ipv4));
rc = lagopus_ip_address_is_ipv4(ip1, &is_ipv4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(true, is_ipv4);
lagopus_ip_address_destroy(ip1);
// Normal case(name = IPv6, ai_family = AF_INET6)
rc = lagopus_ip_address_create(name2, false, &ip2);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(AF_INET6, (ip2->saddr).ss_family);
TEST_ASSERT_NOT_NULL_MESSAGE(
ip2, "lagopus_ip_address_create() will create new ip_address");
TEST_ASSERT_EQUAL_STRING(name2, ip2->addr_str);
TEST_ASSERT_EQUAL(AF_INET6, IS_IPV4(ip2->is_ipv4));
rc = lagopus_ip_address_is_ipv4(ip2, &is_ipv4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(false, is_ipv4);
lagopus_ip_address_destroy(ip2);
// Normal case(name = IPv4, ai_family = AF_INET6)
rc = lagopus_ip_address_create(name1, false, &ip1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(AF_INET, (ip1->saddr).ss_family);
TEST_ASSERT_NOT_NULL_MESSAGE(
ip1, "lagopus_ip_address_create() will create new ip_address");
TEST_ASSERT_EQUAL_STRING(name1, ip1->addr_str);
TEST_ASSERT_EQUAL(AF_INET, IS_IPV4(ip1->is_ipv4));
// Normal case(name = IPv6, ai_family = AF_INET)
rc = lagopus_ip_address_create(name2, true, &ip2);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(AF_INET6, (ip2->saddr).ss_family);
TEST_ASSERT_NOT_NULL_MESSAGE(
ip2, "lagopus_ip_address_create() will create new ip_address");
TEST_ASSERT_EQUAL_STRING(name2, ip2->addr_str);
TEST_ASSERT_EQUAL(AF_INET6, IS_IPV4(ip2->is_ipv4));
// Normal case(IP address obtained from a host name,
// result addr_str = '127.0.0.1')
rc = lagopus_ip_address_create(name3, true, &ip3);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(AF_INET, (ip3->saddr).ss_family);
TEST_ASSERT_NOT_NULL_MESSAGE(
ip3, "lagopus_ip_address_create() will create new ip_address");
TEST_ASSERT_EQUAL_STRING(name1, ip3->addr_str);
TEST_ASSERT_EQUAL(AF_INET, IS_IPV4(ip3->is_ipv4));
// Normal case(IP address obtained from a host name)
//rc = lagopus_ip_address_create(name4, true, &ip4);
//TEST_ASSERT_EQUAL(LAGOPUS_RESULT_ADDR_RESOLVER_FAILURE, rc);
// Normal case(name = IPv4, ai_family = AF_INET,
// name = '127.0', result addr_str = '127.0.0.0')
rc = lagopus_ip_address_create(name5, true, &ip5);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL(AF_INET, (ip5->saddr).ss_family);
TEST_ASSERT_NOT_NULL_MESSAGE(
ip1, "lagopus_ip_address_create() will create new ip_address");
TEST_ASSERT_EQUAL_STRING(name6, ip5->addr_str);
TEST_ASSERT_EQUAL(AF_INET, IS_IPV4(ip5->is_ipv4));
lagopus_ip_address_destroy(ip5);
// Normal case(IP address bad format.)
rc = lagopus_ip_address_create(name7, true, &ip6);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_ADDR_RESOLVER_FAILURE, rc);
}
// Abnormal case
{
rc = lagopus_ip_address_create(NULL, true, &ip1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = lagopus_ip_address_create(name1, true, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
}
lagopus_ip_address_destroy(ip1);
lagopus_ip_address_destroy(ip2);
lagopus_ip_address_destroy(ip3);
//lagopus_ip_address_destroy(ip4);
}
void
test_lagopus_ip_address_equals(void) {
lagopus_result_t rc;
bool result;
const char *name1 = "127.0.0.1";
const char *name2 = "127.0.0.1";
const char *name3 = "10.0.0.1";
const char *name4 = "::1";
const char *name5 = "0:0:0:0:0:0:0:1";
const char *name6 = "::0:0:1";
const char *name7 = "1::1";
lagopus_ip_address_t *ip1;
lagopus_ip_address_t *ip2;
lagopus_ip_address_t *ip3;
lagopus_ip_address_t *ip4;
lagopus_ip_address_t *ip5;
lagopus_ip_address_t *ip6;
lagopus_ip_address_t *ip7;
rc = lagopus_ip_address_create(name1, true, &ip1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
rc = lagopus_ip_address_create(name2, true, &ip2);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
rc = lagopus_ip_address_create(name3, true, &ip3);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
rc = lagopus_ip_address_create(name4, true, &ip4);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
rc = lagopus_ip_address_create(name5, true, &ip5);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
rc = lagopus_ip_address_create(name6, true, &ip6);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
rc = lagopus_ip_address_create(name7, true, &ip7);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
// Normal case
{
// equal
result = lagopus_ip_address_equals(ip1, ip2);
TEST_ASSERT_TRUE(result);
// not equal
result = lagopus_ip_address_equals(ip1, ip3);
TEST_ASSERT_FALSE(result);
// not equal
result = lagopus_ip_address_equals(ip2, ip3);
TEST_ASSERT_FALSE(result);
// equal
result = lagopus_ip_address_equals(ip4, ip5);
TEST_ASSERT_TRUE(result);
// equal
result = lagopus_ip_address_equals(ip4, ip6);
TEST_ASSERT_TRUE(result);
// equal
result = lagopus_ip_address_equals(ip5, ip6);
TEST_ASSERT_TRUE(result);
// not equal
result = lagopus_ip_address_equals(ip4, ip7);
TEST_ASSERT_FALSE(result);
// not equal
result = lagopus_ip_address_equals(ip1, ip4);
TEST_ASSERT_FALSE(result);
}
// Abnormal case
{
// not equal
result = lagopus_ip_address_equals(NULL, NULL);
TEST_ASSERT_FALSE(result);
// not equal
result = lagopus_ip_address_equals(ip1, NULL);
TEST_ASSERT_FALSE(result);
// not equal
result = lagopus_ip_address_equals(NULL, ip1);
TEST_ASSERT_FALSE(result);
}
lagopus_ip_address_destroy(ip1);
lagopus_ip_address_destroy(ip2);
lagopus_ip_address_destroy(ip3);
lagopus_ip_address_destroy(ip4);
lagopus_ip_address_destroy(ip5);
lagopus_ip_address_destroy(ip6);
lagopus_ip_address_destroy(ip7);
}
