void
test_ofp_set_config_handle_normal_pattern(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
ret = check_packet_parse(
s_ofp_set_config_request_handle_wrap,
"04 09 00 0c 00 00 00 10"
"00 01 ff e4");
/*
* <---> flags
* <---> miss_send_len
*/
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_get_config_request_handle(normal) error.");
}
void
meter_destroy(uint64_t dpid, uint32_t meter_id) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct ofp_meter_mod mod;
struct ofp_error error;
mod.command = OFPMC_DELETE;
mod.flags = OFPMF_KBPS | OFPMF_BURST;
mod.meter_id = meter_id;
ret = ofp_meter_mod_delete(dpid, &mod, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_meter_mod_delete error.");
}
void
test_ofp_flow_handle_error_length9(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct ofp_error expected_error;
ofp_error_set(&expected_error, OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
/* invalid body */
ret = check_packet_parse_expect_error(
ofp_multipart_request_handle,
"04 12 00 40 00 00 00 10 00 01 00 00 00 00 00 00 "
"01 00 00 00 00 00 00 02 00 00 00 03 00 00 00 00 "
"00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 05",
&expected_error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OFP_ERROR, ret, "invalid-body error");
}
void
test_ofp_group_features_request_handle_error_invalid_length1(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct ofp_error expected_error;
ofp_error_set(&expected_error, OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
ret = check_packet_parse_expect_error(ofp_multipart_request_handle_wrap,
"04 12 00 10 00 00 00 10"
"00 08 00 00 00 00 00 00"
"00",
&expected_error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OFP_ERROR, ret,
"invalid-body error.");
}
void
test_group_mod_handle_add_invalid_length2(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct ofp_error expected_error = {0, 0, {NULL}};
ofp_error_set(&expected_error, OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
/* only header, no data */
/* no type, pad, group_id, buckets */
ret = check_packet_parse_expect_error(
ofp_group_mod_handle_wrap,
"04 0f 00 0a 00 00 00 10 00 00",
&expected_error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OFP_ERROR, ret,
"invalid body error.");
}
void
test_match_basic_IPV4_IP_ECN(void) {
struct lagopus_packet *pkt;
struct port port;
struct flow *flow;
OS_MBUF *m;
bool rv;
/* prepare packet */
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = pkt->mbuf;
OS_M_APPEND(m, 64);
/* prepare flow */
flow = calloc(1, sizeof(struct flow) + 10 * sizeof(struct match));
TAILQ_INIT(&flow->match_list);
add_match(&flow->match_list, 2, OFPXMT_OFB_ETH_TYPE << 1,
0x08, 0x00);
refresh_match(flow);
OS_MTOD(m, uint8_t *)[12] = 0x08;
OS_MTOD(m, uint8_t *)[13] = 0x00;
OS_MTOD(m, uint8_t *)[14] = 0x45;
add_match(&flow->match_list, 1, OFPXMT_OFB_IP_ECN << 1,
0x3);
OS_MTOD(m, uint8_t *)[15] = 0xcc;
refresh_match(flow);
lagopus_packet_init(pkt, m, &port);
rv = match_basic(pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, false,
"IP_ECN mismatch error.");
OS_MTOD(m, uint8_t *)[15] = 0x03;
rv = match_basic(pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, true,
"IP_ECN match error.");
}
void
test_match_basic_IPV6_IP_ECN(void) {
struct lagopus_packet pkt;
struct port port;
struct flow *flow;
OS_MBUF *m;
bool rv;
/* prepare packet */
pkt.in_port = &port;
m = calloc(1, sizeof(*m));
TEST_ASSERT_NOT_NULL_MESSAGE(m, "calloc error.");
m->data = &m->dat[128];
OS_M_PKTLEN(m) = 64;
/* prepare flow */
flow = calloc(1, sizeof(struct flow) + 10 * sizeof(struct match));
TAILQ_INIT(&flow->match_list);
add_match(&flow->match_list, 2, OFPXMT_OFB_ETH_TYPE << 1,
0x86, 0xdd);
m->data[12] = 0x86;
m->data[13] = 0xdd;
add_match(&flow->match_list, 1, OFPXMT_OFB_IP_ECN << 1,
0x03);
m->data[15] = 0x00;
refresh_match(flow);
lagopus_packet_init(&pkt, m);
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, false,
"IPV6_IP_ECN mismatch error.");
m->data[15] = 0x30;
lagopus_packet_init(&pkt, m);
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, true,
"IPV6_IP_ECN match error.");
}
void
test_ofp_queue_get_config_reply_create_null(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct event_manager *em = event_manager_alloc();
struct channel *channel = channel_alloc_ip4addr("127.0.0.1", "1000",
em, 0x01);
struct pbuf *pbuf = pbuf_alloc(65535);
static struct packet_queue_list packet_queue_list;
struct ofp_header ofp_header;
ret = ofp_queue_get_config_reply_create(NULL, &pbuf, 0,
&packet_queue_list,
&ofp_header);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (channel)");
ret = ofp_queue_get_config_reply_create(channel, NULL, 0,
&packet_queue_list,
&ofp_header);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (pbuf)");
ret = ofp_queue_get_config_reply_create(channel, &pbuf, 0,
NULL, &ofp_header);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (packet_queue_list)");
ret = ofp_queue_get_config_reply_create(channel, &pbuf, 0,
&packet_queue_list,
NULL);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (ofp_header)");
channel_free(channel);
pbuf_free(pbuf);
event_manager_free(em);
}
lagopus_result_t
check_packet_parse_with_dequeue_expect_error(ofp_handler_proc_t handler_proc,
const char packet[],
void **get,
const struct ofp_error *expected_error) {
lagopus_result_t res = LAGOPUS_RESULT_ANY_FAILURES;
struct channel *channel = create_data_channel();
struct ofp_header xid_header;
struct ofp_bridge *ofpb = NULL;
struct pbuf *pbuf;
struct ofp_error error;
struct ofp_bridgeq *bridgeq;
if (get == NULL) {
return LAGOPUS_RESULT_INVALID_ARGS;
}
/* start ofp_handler */
if (s_start_ofp_handler() == false) {
goto done;
}
/* register ofp_bridge */
res = ofp_bridgeq_mgr_bridge_register(channel_dpid_get(channel));
if (res == LAGOPUS_RESULT_OK) {
res = ofp_bridgeq_mgr_bridge_lookup(channel_dpid_get(channel), &bridgeq);
if (res == LAGOPUS_RESULT_OK) {
ofpb = ofp_bridgeq_mgr_bridge_get(bridgeq);
ofp_bridgeq_mgr_bridgeq_free(bridgeq);
} else {
TEST_FAIL_MESSAGE("handler_test_utils.c: "
"ofp_bridgeq_mgr_bridge_get error.");
}
} else {
lagopus_perror(res);
TEST_FAIL_MESSAGE("handler_test_utils.c: register error.");
goto done;
}
/* create packet */
create_packet(packet, &pbuf);
/* parse header */
if (ofp_header_decode_sneak_test(pbuf, &xid_header) != LAGOPUS_RESULT_OK) {
TEST_FAIL_MESSAGE("handler_test_utils.c: cannot decode header\n");
return LAGOPUS_RESULT_OFP_ERROR;
}
/* call func & check */
res = (handler_proc)(channel, pbuf, &xid_header, &error);
if (res == LAGOPUS_RESULT_OK) {
res = lagopus_bbq_get(&ofpb->event_dataq, get, void *, TIMEOUT);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, res,
"handler_test_utils.c: lagopus_bbq_get error.");
} else if (res == LAGOPUS_RESULT_OFP_ERROR) {
void
test_ofp_port_mod_handle_invalid_length8(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct ofp_error expected_error = {0, 0, {NULL}};
/* over size */
ofp_error_set(&expected_error, OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
ret = check_packet_parse_expect_error(
ofp_port_mod_handle_wrap,
"04 10 00 2c 00 00 00 10 00 00 00 01 00 00 00 00 "
"ff ff ff ff ff ff 00 00 00 00 00 24 00 00 00 04 "
"00 00 00 05 00 00 00 00 ff ff ff ff",
&expected_error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OFP_ERROR, ret,
"invalid body error.");
}
/** 2-node case
* remove 2
* root -> 1(b) ---------> Throw ERR_NODE_UNAVAILABLE
*/
void test_genericDelRedBlackTree_remove_node2_from_tree_with_only_node1_should_throw_ERR_NODE_UNAVAILABLE(void)
{
setNode(&node2, NULL, NULL, 'r');
setNode(&node1, NULL, NULL, 'b');
Node *root = &node1;
CEXCEPTION_T err;
Try{
genericDelRedBlackTree(&root, &node2, compareEventInfo);
TEST_FAIL_MESSAGE("Expected ERR_NODE_UNAVAILABLE to be thrown. But receive none");
} Catch(err)
{
TEST_ASSERT_EQUAL_MESSAGE(ERR_NODE_UNAVAILABLE, err, "Expected ERR_NODE_UNAVAILABLE exception");
}
}
void
test_group_mod_handle_modify_no_actions(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
const char *data[2] = {
/* add */
"04 0f 00 10 00 00 00 10 00 00 00 00 ff ff ff 00",
/* mod */
"04 0f 00 30 00 00 00 10 00 01 00 00 ff ff ff 00 "
"00 10 00 02 00 00 00 03 00 00 00 04 00 00 00 00 "
"00 10 00 06 00 00 00 07 00 00 00 08 00 00 00 00"
};
ret = check_packet_parse_array(ofp_group_mod_handle_wrap, data, 2);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"modify no_actions error.");
}
void
test_set_field_PBB_ISID(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet pkt;
OS_MBUF *m;
TAILQ_INIT(&action_list);
action = calloc(1, sizeof(*action) + 64);
action_set = (struct ofp_action_set_field *)&action->ofpat;
action_set->type = OFPAT_SET_FIELD;
lagopus_set_action_function(action);
TAILQ_INSERT_TAIL(&action_list, action, entry);
m = calloc(1, sizeof(*m));
TEST_ASSERT_NOT_NULL_MESSAGE(m, "calloc error.");
m->data = &m->dat[128];
OS_M_PKTLEN(m) = 64;
m->data[12] = 0x88;
m->data[13] = 0xe7;
lagopus_set_in_port(&pkt, &port);
lagopus_packet_init(&pkt, m);
set_match(action_set->field, 3, OFPXMT_OFB_PBB_ISID << 1,
0xa5, 0x5a, 0xc3);
execute_action(&pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(m->data[15], 0xa5,
"SET_FIELD PBB_ISID[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[16], 0x5a,
"SET_FIELD PBB_ISID[1] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[17], 0xc3,
"SET_FIELD PBB_ISID[2] error.");
}
void
test_group_mod_handle_delete_with_actions(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
ret = check_packet_parse(ofp_group_mod_handle_wrap,
"04 0f 00 80 00 00 00 10 00 02 00 00 ff ff ff 00 "
"00 30 00 02 00 00 00 03 00 00 00 04 00 00 00 00 "
"00 00 00 10 00 00 00 0a 03 e8 00 00 00 00 00 00 "
"00 00 00 10 00 00 00 14 07 d0 00 00 00 00 00 00 "
"00 30 00 06 00 00 00 07 00 00 00 08 00 00 00 00 "
"00 00 00 10 00 00 00 0a 03 e8 00 00 00 00 00 00 "
"00 00 00 10 00 00 00 14 07 d0 00 00 00 00 00 00 "
"00 10 00 02 00 00 00 03 00 00 00 04 00 00 00 00");
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OFP_ERROR, ret,
"delete error.");
}
void
test_ofp_bridgeq_mgr_bridge_register_orver_length(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
int data_num = MAX_BRIDGES;
struct {
uint64_t dpid;
char name[20];
} bridges[MAX_BRIDGES + 1];
datastore_bridge_info_t info = {0};
datastore_bridge_queue_info_t q_info =
{1000LL, 1000LL, 1000LL, 1000LL, 1000LL, 1000LL};
int i;
/* create data. */
for (i = 0; i < data_num + 1; i++) {
bridges[i].dpid = (uint64_t) (i + 1);
snprintf(bridges[i].name, sizeof(bridges[i].name), "test_bridge%d", i);
}
/* register bridge. */
for (i = 0; i < data_num; i++) {
ret = ofp_bridgeq_mgr_bridge_register(bridges[i].dpid,
bridges[i].name,
&info,
&q_info);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_bridgeq_mgr_bridge_registererror.");
}
ret = ofp_bridgeq_mgr_bridge_register(bridges[data_num].dpid,
bridges[data_num].name,
&info,
&q_info);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_ITERATION_HALTED, ret,
"ofp_bridgeq_mgr_bridge_register(orver length) error.");
}
void
test_match_basic_VLAN_VID(void) {
struct lagopus_packet *pkt;
struct port port;
struct flow *flow;
OS_MBUF *m;
bool rv;
/* prepare packet */
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = PKT2MBUF(pkt);
OS_M_APPEND(m, 64);
/* prepare flow */
flow = calloc(1, sizeof(struct flow) + 10 * sizeof(struct match));
TAILQ_INIT(&flow->match_list);
/* VLAN */
add_match(&flow->match_list, 2, OFPXMT_OFB_VLAN_VID << 1,
0x10, 0x01);
refresh_match(flow);
lagopus_packet_init(pkt, m, &port);
rv = match_basic(pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, false,
"VLAN_VID mismatch error.");
OS_MTOD(m, uint8_t *)[12] = 0x81;
OS_MTOD(m, uint8_t *)[13] = 0x00;
OS_MTOD(m, uint8_t *)[14] = 0x00;
OS_MTOD(m, uint8_t *)[15] = 0x01;
lagopus_packet_init(pkt, m, &port);
rv = match_basic(pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, true,
"VLAN VID match error.");
free(m);
}
void
test_ofp_barrier_reply_send_null(void) {
lagopus_result_t ret;
struct eventq_data *ed;
uint64_t dpid = 0x10;
struct event_manager *em = event_manager_alloc();
struct channel *channel =
channel_alloc_ip4addr("127.0.0.1", "1000", em, 0x01);
ed = create_data(OFPT_BARRIER_REPLY);
ret = ofp_barrier_reply_send(NULL, &ed->barrier, dpid);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_INVALID_ARGS,
"ofp_barrier_reply_send error.");
ret = ofp_barrier_reply_send(channel, NULL, dpid);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_INVALID_ARGS,
"ofp_barrier_reply_send error.");
/* after. */
ofp_barrier_free(ed);
channel_free(channel);
event_manager_free(em);
}
void
test_pbuf_encode_normal(void) {
struct pbuf *pbuf = pbuf_alloc(PBUF_LENGTH);
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
size_t data_length = 2;
uint8_t data[2] = {0x01, 0x02};
/* create test data */
pbuf->plen = data_length;
/* call func. */
ret = pbuf_encode(pbuf, data, data_length);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"pbuf_encode error.");
TEST_ASSERT_EQUAL_MESSAGE(0, pbuf->plen,
"packet length error.");
TEST_ASSERT_EQUAL_MESSAGE(data_length, pbuf->putp - pbuf->getp,
"packet data length error.");
TEST_ASSERT_EQUAL_MESSAGE(0, memcmp(pbuf->data, data, data_length),
"data error.");
/* after. */
pbuf_free(pbuf);
}
void
test_match_basic_IN_PORT(void) {
struct lagopus_packet pkt;
struct port port;
struct flow *flow;
OS_MBUF *m;
bool rv;
/* prepare packet */
m = calloc(1, sizeof(*m));
TEST_ASSERT_NOT_NULL_MESSAGE(m, "calloc error.");
m->data = &m->dat[128];
OS_M_PKTLEN(m) = 64;
/* prepare flow */
flow = allocate_test_flow(10 * sizeof(struct match));
refresh_match(flow);
/* Port */
pkt.oob_data.in_port = htonl(2);
lagopus_packet_init(&pkt, m, &port);
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, true,
"IN_PORT wildcard match error.");
FLOW_ADD_PORT_MATCH(flow, 1);
refresh_match(flow);
pkt.oob_data.in_port = htonl(2);
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, false,
"IN_PORT mismatch error.");
pkt.oob_data.in_port = htonl(1);
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, true,
"IN_PORT match error.");
free(m);
}
void
test_ofp_port_stats_handle_error_invalid_length0(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct ofp_error expected_error;
ofp_error_set(&expected_error, OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
/* invalid body (no flags, pad) */
ret = check_packet_parse_expect_error(ofp_multipart_request_handle_wrap,
"04 12 00 08 00 00 00 10 "
"00 04",
&expected_error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OFP_ERROR,
ret,
"invalid-body error");
}
void
test_ofp_meter_band_list_elem_free(void) {
int i;
int max_cnt = 4;
struct meter_band_list band_list;
struct meter_band *band;
TAILQ_INIT(&band_list);
/* data */
for (i = 0; i < max_cnt; i++) {
band = (struct meter_band *)
malloc(sizeof(struct meter_band));
TAILQ_INSERT_TAIL(&band_list, band, entry);
}
TEST_ASSERT_EQUAL_MESSAGE(TAILQ_EMPTY(&band_list),
false, "not band_list error.");
/* Call func.*/
ofp_meter_band_list_elem_free(&band_list);
TEST_ASSERT_EQUAL_MESSAGE(TAILQ_EMPTY(&band_list),
true, "band_list error.");
}
void
test_lagopus_dstring_concat_clear_srt_get(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
char *str = NULL;
char test_str1[] = "hoge foo\n";
char test_str2[] = "bas\n";
char test_str3[] = "hoge foo\nbas\n";
char test_str4[] = "\0";
char test_str5[] = "1234 5678\n";
char test_str6[] = "hoge foo\nbas\n1234 5678\n";
/* append ds. */
ret = lagopus_dstring_appendf(&ds, "%s foo\n", "hoge");
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"lagopus_dstring_appendf error.");
TEST_DSTRING(ret, &ds, str, test_str1);
/* append ds2. */
ret = lagopus_dstring_appendf(&ds2, "%s\n", "bas");
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"lagopus_dstring_appendf error.");
TEST_DSTRING(ret, &ds2, str, test_str2);
/* concat (ds + ds2). */
ret = lagopus_dstring_concat(&ds, &ds2);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"lagopus_dstring_concat error.");
TEST_DSTRING(ret, &ds, str, test_str3);
/* check const ds2. */
TEST_DSTRING(ret, &ds2, str, test_str2);
/* clear ds2. */
ret = lagopus_dstring_clear(&ds2);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"lagopus_dstring_clear error.");
TEST_DSTRING(ret, &ds2, str, test_str4);
/* append ds2. */
ret = lagopus_dstring_appendf(&ds2, "1234 %d\n", 5678);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"lagopus_dstring_appendf error.");
TEST_DSTRING(ret, &ds2, str, test_str5);
/* concat (ds + ds2).*/
ret = lagopus_dstring_concat(&ds, &ds2);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"lagopus_dstring_concat error.");
TEST_DSTRING(ret, &ds, str, test_str6);
/* check const ds2. */
TEST_DSTRING(ret, &ds2, str, test_str5);
}
void
test_ofp_role_channel_write_filtering(void) {
lagopus_result_t ret;
int i;
/* set role mask. */
for (i = 0; i < 2; i++) {
test_role_mask.packet_in_mask[i] = 0x00;
test_role_mask.port_status_mask[i] = 0x00;
test_role_mask.flow_removed_mask[i] = 0x00;
}
ret = check_use_channels_send(ofp_role_channel_write_wrap,
"04 10 00 08 00 00 00 64");
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_role_channel_write(filtering) error.");
}
void
test_group_desc(void) {
struct bridge *bridge;
struct group_table *group_table;
struct group *group;
struct ofp_group_mod group_mod;
struct bucket_list bucket_list;
struct group_desc_list group_desc_list;
struct group_desc *desc;
struct ofp_error error;
lagopus_result_t ret;
bridge = dp_bridge_lookup("br0");
TEST_ASSERT_NOT_NULL_MESSAGE(bridge, "bridge alloc error.");
TAILQ_INIT(&bucket_list);
group_table = group_table_alloc(bridge);
TEST_ASSERT_NOT_NULL_MESSAGE(bridge, "group_table alloc error.");
bridge->group_table = group_table;
group_mod.group_id = 1;
group_mod.type = OFPGT_ALL;
group = group_alloc(&group_mod, &bucket_list);
ret = group_table_add(group_table, group, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"group_table_add error");
group_mod.group_id = 1000000;
group_mod.type = OFPGT_SELECT;
group = group_alloc(&group_mod, &bucket_list);
ret = group_table_add(group_table, group, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"group_table_add error");
TAILQ_INIT(&group_desc_list);
ret = group_descs(group_table, &group_desc_list, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"get desc error");
desc = TAILQ_FIRST(&group_desc_list);
TEST_ASSERT_NOT_NULL_MESSAGE(desc, "group not found");
TEST_ASSERT_EQUAL_MESSAGE(desc->ofp.group_id, 1,
"group id error");
TEST_ASSERT_EQUAL_MESSAGE(desc->ofp.type, OFPGT_ALL,
"group type error");
desc = TAILQ_NEXT(desc, entry);
TEST_ASSERT_NOT_NULL_MESSAGE(desc, "number of groups error");
TEST_ASSERT_EQUAL_MESSAGE(desc->ofp.group_id, 1000000,
"group id error");
TEST_ASSERT_EQUAL_MESSAGE(desc->ofp.type, OFPGT_SELECT,
"group type error");
}
void
test_group_table_alloc(void) {
struct dpmgr *dpmgr;
struct bridge *bridge;
struct group_table *group_table;
lagopus_result_t rv;
dpmgr = dpmgr_alloc();
TEST_ASSERT_NOT_NULL_MESSAGE(dpmgr, "dpmgr alloc error.");
rv = dpmgr_bridge_add(dpmgr, "br0", 0);
TEST_ASSERT_EQUAL_MESSAGE(rv, LAGOPUS_RESULT_OK,
"bridge add error");
bridge = dpmgr_bridge_lookup(dpmgr, "br0");
TEST_ASSERT_NOT_NULL_MESSAGE(bridge, "bridge alloc error.");
group_table = group_table_alloc(bridge);
TEST_ASSERT_NOT_NULL_MESSAGE(group_table, "alloc error");
}
void
test_ofp_set_config_handle_invalid_too_large_miss_send_len(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct ofp_error expected_error = {0, 0, {NULL}};
ofp_error_set(&expected_error, OFPET_SWITCH_CONFIG_FAILED, OFPSCFC_BAD_LEN);
ret = check_packet_parse_expect_error(
s_ofp_set_config_request_handle_wrap,
"04 09 00 0c 00 00 00 10"
"00 01 ff e6",
/*
* <---> flags 0xffff is undefined
* <---> miss_send_len > OFPCML_MAX
*/
&expected_error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OFP_ERROR, ret,
"invalid miss send len.");
}
void test_ExceptionPointsToBadConfigLine(void)
{
CEXCEPTION_T e;
config_t dummy_config;
const char * bad_config_file = "test/support/config_with_error_line_3";
Try {
Config_FromFile(bad_config_file, &dummy_config);
}
Catch (e) {
}
TEST_ASSERT_EQUAL_MESSAGE(BAD_CONFIG_PARAM, e, "Should have caught bad config file");
TEST_ASSERT_EQUAL_STRING(bad_config_file, exception_file);
TEST_ASSERT_EQUAL(3, exception_line);
}
void
test_port_add(void) {
struct vector *ports;
struct port port;
lagopus_result_t rv;
ports = ports_alloc();
TEST_ASSERT_NOT_NULL_MESSAGE(ports, "ports_alloc error");
strncpy(port.ofp_port.name, "port1", sizeof(port.ofp_port.name));
port.ofp_port.port_no = 1;
port.ifindex = 120;
port.type = LAGOPUS_PORT_TYPE_NULL;
rv = port_add(ports, &port);
TEST_ASSERT_EQUAL_MESSAGE(rv, LAGOPUS_RESULT_OK, "port_add error");
}
void
test_ofp_table_stats_reply_create_01(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
const char *data[1] = {"04 13 00 28 00 00 00 10 "
"00 03 00 00 00 00 00 00 "
// body
"01 "
"00 00 00 "
"00 00 00 02 "
"00 00 00 00 00 00 00 03 "
"00 00 00 00 00 00 00 04 "
};
ret = check_pbuf_list_packet_create(s_ofp_table_stats_reply_create_wrap,
data, 1);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret, "create port 0 error.");
}
void
test_ofp_queue_stats_reply_create(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
const char *data[1] = {"04 13 00 38 00 00 00 10"
"00 05 00 00 00 00 00 00"
"00 00 00 01 00 00 00 02"
"00 00 00 00 00 00 00 03"
"00 00 00 00 00 00 00 04"
"00 00 00 00 00 00 00 05"
"00 00 00 06 00 00 00 07"
};
ret = check_pbuf_list_packet_create(ofp_queue_stats_reply_create_wrap,
data, 1);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_queue_stats_reply_create(normal) error.");
}
