int
main(
const int argc,
const char* const* argv)
{
int exitCode = EXIT_FAILURE;
if (log_init(argv[0])) {
(void)fprintf(stderr, "Couldn't initialize logging system\n");
}
else {
if (CUE_SUCCESS == CU_initialize_registry()) {
CU_Suite* testSuite = CU_add_suite(__FILE__, setup,
teardown);
if (NULL != testSuite) {
CU_ADD_TEST(testSuite, test_add_get);
CU_ADD_TEST(testSuite, test_order);
if (CU_basic_run_tests() == CUE_SUCCESS)
exitCode = CU_get_number_of_suites_failed() +
CU_get_number_of_tests_failed();
}
CU_cleanup_registry();
} /* CUnit registery allocated */
log_free();
} /* logging system initialized */
return exitCode;
}
/*
* Main
*/
int
main(void)
{
CU_pSuite ptr_suite = NULL;
int nr_of_failed_tests = 0;
int nr_of_failed_suites = 0;
/* Initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
/* add a suite to the registry */
ptr_suite = CU_add_suite("ofp port config", init_suite, clean_suite);
if (NULL == ptr_suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_sinlge_port_basic)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_two_ports_vlan)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_gre_port)) {
CU_cleanup_registry();
return CU_get_error();
}
#if OFP_TESTMODE_AUTO
CU_set_output_filename("CUnit-Port-conf");
CU_automated_run_tests();
#else
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
#endif
nr_of_failed_tests = CU_get_number_of_tests_failed();
nr_of_failed_suites = CU_get_number_of_suites_failed();
CU_cleanup_registry();
return (nr_of_failed_suites > 0 ?
nr_of_failed_suites : nr_of_failed_tests);
}
int main(void)
{
CU_pSuite ptr_suite = NULL;
int nr_of_failed_tests = 0;
int nr_of_failed_suites = 0;
/* Initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
/* add a suite to the registry */
ptr_suite = CU_add_suite("ofp errno", init_suite, NULL);
if (NULL == ptr_suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite, test_strerrno)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite, test_tls_errno)) {
CU_cleanup_registry();
return CU_get_error();
}
#if defined(OFP_TESTMODE_AUTO)
CU_set_output_filename("CUnit-Util");
CU_automated_run_tests();
#else
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
#endif
nr_of_failed_tests = CU_get_number_of_tests_failed();
nr_of_failed_suites = CU_get_number_of_suites_failed();
CU_cleanup_registry();
return (nr_of_failed_suites > 0 ?
nr_of_failed_suites : nr_of_failed_tests);
}
int main(
const int argc,
const char* const* argv)
{
int exitCode = 1;
if (CUE_SUCCESS == CU_initialize_registry()) {
CU_Suite* testSuite = CU_add_suite(__FILE__, setup, teardown);
if (NULL != testSuite) {
if (CU_ADD_TEST(testSuite, test_cond_wait)) {
CU_basic_set_mode(CU_BRM_VERBOSE);
(void)CU_basic_run_tests();
}
}
exitCode = CU_get_number_of_suites_failed() +
CU_get_number_of_tests_failed();
CU_cleanup_registry();
}
return exitCode;
}
/*
* Main
*/
int
main(void)
{
CU_pSuite ptr_suite = NULL;
int nr_of_failed_tests = 0;
int nr_of_failed_suites = 0;
/* Initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
/* add a suite to the registry */
ptr_suite = CU_add_suite("ofp packet out", init_suite, clean_suite);
if (NULL == ptr_suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_packet_output_gre)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_packet_output_gre_no_nexthop)) {
CU_cleanup_registry();
return CU_get_error();
}
#ifdef INET6
if (NULL == CU_ADD_TEST(ptr_suite,
test_packet_output_ipv6_to_gre)) {
CU_cleanup_registry();
return CU_get_error();
}
#endif
if (NULL == CU_ADD_TEST(ptr_suite,
test_send_frame_packet_len_bigger_than_mtu)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_send_frame_novlan_to_novlan)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_send_frame_novlan_to_vlan)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_send_frame_vlan_to_novlan)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_send_frame_vlan_to_vlan)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_hook_out_ipv4)) {
CU_cleanup_registry();
return CU_get_error();
}
#ifdef INET6
if (NULL == CU_ADD_TEST(ptr_suite,
test_hook_out_ipv6)) {
CU_cleanup_registry();
return CU_get_error();
}
#endif /*INET6*/
#if OFP_TESTMODE_AUTO
CU_set_output_filename("CUnit-PKT-OUT");
CU_automated_run_tests();
#else
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
#endif
nr_of_failed_tests = CU_get_number_of_tests_failed();
nr_of_failed_suites = CU_get_number_of_suites_failed();
CU_cleanup_registry();
return (nr_of_failed_suites > 0 ?
nr_of_failed_suites : nr_of_failed_tests);
}
/*
* Main
*/
int
main(void)
{
CU_pSuite ptr_suite = NULL;
int nr_of_failed_tests = 0;
int nr_of_failed_suites = 0;
/* Initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
/* add a suite to the registry */
ptr_suite = CU_add_suite("ofp fragmentation", init_suite, clean_suite);
if (NULL == ptr_suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_packet_size_is_less_then_mtu)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_dont_fragment_set_pkt_dropped)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_packet_to_two_fragments)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_packet_to_many_fragments)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_fragment_fragmented_to_two)) {
CU_cleanup_registry();
return CU_get_error();
}
#if OFP_TESTMODE_AUTO
CU_set_output_filename("CUnit-fragmentation");
CU_automated_run_tests();
#else
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
#endif
nr_of_failed_tests = CU_get_number_of_tests_failed();
nr_of_failed_suites = CU_get_number_of_suites_failed();
CU_cleanup_registry();
return (nr_of_failed_suites > 0 ?
nr_of_failed_suites : nr_of_failed_tests);
}
void *pp_thread(void *arg)
{
ALLOW_UNUSED_LOCAL(arg);
#if ODP_VERSION >= 102
if (odp_init_local(ODP_THREAD_WORKER)) {
#else
if (odp_init_local()) {
#endif
OFP_ERR("odp_init_local failed");
return NULL;
}
if (ofp_init_local()) {
OFP_ERR("ofp_init_local failed");
return NULL;
}
while (odp_atomic_load_u32(&still_running)) {
odp_event_t event;
odp_queue_t source_queue;
event = odp_schedule(&source_queue, ODP_SCHED_WAIT);
if (odp_event_type(event) != ODP_EVENT_TIMEOUT) {
OFP_ERR("Unexpected event type %d",
odp_event_type(event));
continue;
}
ofp_timer_handle(event);
}
return NULL;
}
static void test_arp(void)
{
struct ofp_ifnet mock_ifnet;
struct in_addr ip;
uint8_t mac[OFP_ETHER_ADDR_LEN] = { 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, };
/* The buffer passed into ofp_ipv4_lookup_mac() must be 8 bytes since
* a 64-bit operation is currently being used to copy a MAC address.
*/
uint8_t mac_result[OFP_ETHER_ADDR_LEN + 2];
CU_ASSERT(0 == ofp_init_local());
memset(&mock_ifnet, 0, sizeof(mock_ifnet));
CU_ASSERT(0 != inet_aton("1.1.1.1", &ip));
/* Test entry insert, lookup, and remove. */
CU_ASSERT(-1 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
CU_ASSERT(0 == ofp_arp_ipv4_insert(ip.s_addr, mac, &mock_ifnet));
memset(mac_result, 0xFF, OFP_ETHER_ADDR_LEN);
CU_ASSERT(0 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
CU_ASSERT(0 == memcmp(mac, mac_result, OFP_ETHER_ADDR_LEN));
CU_ASSERT(0 == ofp_arp_ipv4_remove(ip.s_addr, &mock_ifnet));
CU_ASSERT(-1 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
/* Test entry is aged out. */
CU_ASSERT(0 == ofp_arp_ipv4_insert(ip.s_addr, mac, &mock_ifnet));
OFP_INFO("Inserted ARP entry");
sleep(ARP_AGE_INTERVAL + ARP_ENTRY_TIMEOUT);
CU_ASSERT(-1 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
/* Test entry is aged out after a few hits. */
CU_ASSERT(0 == ofp_arp_ipv4_insert(ip.s_addr, mac, &mock_ifnet));
OFP_INFO("Inserted ARP entry");
sleep(ARP_AGE_INTERVAL);
CU_ASSERT(0 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
sleep(ARP_AGE_INTERVAL);
CU_ASSERT(0 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
sleep(ARP_AGE_INTERVAL + ARP_ENTRY_TIMEOUT);
CU_ASSERT(-1 == ofp_ipv4_lookup_mac(ip.s_addr, mac_result, &mock_ifnet));
}
int main(void)
{
CU_pSuite ptr_suite = NULL;
int nr_of_failed_tests = 0;
int nr_of_failed_suites = 0;
/* Initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
/* add a suite to the registry */
ptr_suite = CU_add_suite("ofp errno", init_suite, end_suite);
if (NULL == ptr_suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite, test_arp)) {
CU_cleanup_registry();
return CU_get_error();
}
#if defined(OFP_TESTMODE_AUTO)
CU_set_output_filename("CUnit-Util");
CU_automated_run_tests();
#else
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
#endif
nr_of_failed_tests = CU_get_number_of_tests_failed();
nr_of_failed_suites = CU_get_number_of_suites_failed();
CU_cleanup_registry();
return (nr_of_failed_suites > 0 ?
nr_of_failed_suites : nr_of_failed_tests);
}
int main(int argc, char **argv)
{
CU_pSuite pSuite = NULL;
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
pSuite = CU_add_suite("suite_serverInit", NULL, NULL);
if (NULL == pSuite)
{
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_add_test(pSuite, "TEST: Server Initialization", test_serverInit))
{
CU_cleanup_registry();
return CU_get_error();
}
pSuite = CU_add_suite("suite_serverHandlers", NULL, NULL);
if (NULL == pSuite)
{
CU_cleanup_registry();
return CU_get_error();
}
if ((NULL == CU_add_test(pSuite, "TEST: Server Handlers - Add users", test_serverHandler_userAdd)) ||
(NULL == CU_add_test(pSuite, "TEST: Server Handlers - Add books", test_serverHandler_bookAdd)) ||
(NULL == CU_add_test(pSuite, "TEST: Server Handlers - Retrieve book properties", test_serverHandler_bookProp)) ||
(NULL == CU_add_test(pSuite, "TEST: Server Handlers - Create user activities and book history", test_serverHandler_createActy)) ||
(NULL == CU_add_test(pSuite, "TEST: Server Handlers - Send/receive messages", test_serverHandler_msgs)) ||
(NULL == CU_add_test(pSuite, "TEST: Server Handlers - Retrieve user activies and bok history", test_serverHandler_checkActies)))
{
CU_cleanup_registry();
return CU_get_error();
}
pSuite = CU_add_suite("suite_serverTerm", NULL, NULL);
if (NULL == pSuite)
{
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_add_test(pSuite, "TEST: Server Termination", test_serverTerm))
{
CU_cleanup_registry();
return CU_get_error();
}
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
/*CU_basic_run_tests();*/
CU_automated_run_tests();
CU_list_tests_to_file();
printf("\n\n");
printf("======================================\n");
printf(" number of suites run: %d\n", CU_get_number_of_suites_run());
printf(" number of suites failed: %d\n", CU_get_number_of_suites_failed());
printf(" number of tests run: %d\n", CU_get_number_of_tests_run());
printf(" number of tests failed: %d\n", CU_get_number_of_tests_failed());
printf(" number of asserts done: %d\n", CU_get_number_of_asserts());
printf(" number of asserts successful: %d\n", CU_get_number_of_successes());
printf(" number of asserts failed: %d\n", CU_get_number_of_failures());
printf("======================================\n");
CU_cleanup_registry();
return CU_get_error();
}
/*
* Main
*/
int
main(void)
{
CU_pSuite ptr_suite = NULL;
int nr_of_failed_tests = 0;
int nr_of_failed_suites = 0;
(void)gre_frame;
/* Initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry())
return CU_get_error();
/* add a suite to the registry */
ptr_suite = CU_add_suite("ofp packet input", init_suite, clean_suite);
if (NULL == ptr_suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_init_packet_input_basic)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_init_ifnet)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_local_hook)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_local_IPv4_hook)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_local_UDPv4_hook)) {
CU_cleanup_registry();
return CU_get_error();
}
#ifdef SP
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_to_sp)) {
CU_cleanup_registry();
return CU_get_error();
}
#endif /* SP */
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_send_arp)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_forwarding_to_output)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_gre_processed_inner_pkt_forwarded)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_gre_orig_pkt_to_sp)) {
CU_cleanup_registry();
return CU_get_error();
}
ptr_suite = CU_add_suite("test VRF", NULL , NULL);
if (NULL == ptr_suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_init_packet_input_vrf)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_init_ifnet)) {
CU_cleanup_registry();
return CU_get_error();
}
#ifdef SP
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_to_sp)) {
CU_cleanup_registry();
return CU_get_error();
}
#endif /* SP */
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_send_arp)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_forwarding_to_output)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_gre_processed_inner_pkt_forwarded)) {
CU_cleanup_registry();
return CU_get_error();
}
if (NULL == CU_ADD_TEST(ptr_suite,
test_ofp_packet_input_gre_orig_pkt_to_sp)) {
CU_cleanup_registry();
return CU_get_error();
}
#if OFP_TESTMODE_AUTO
CU_set_output_filename("CUnit-PKT-IN");
CU_automated_run_tests();
#else
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
#endif
nr_of_failed_tests = CU_get_number_of_tests_failed();
nr_of_failed_suites = CU_get_number_of_suites_failed();
CU_cleanup_registry();
return (nr_of_failed_suites > 0 ?
nr_of_failed_suites : nr_of_failed_tests);
}
