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."); }