static void test_func_syslog(void) { struct filter_context_t ctx; struct property_list_t properties; struct message_t msg_in; struct message_t msg_out; const char SCRIPT[] = "function filter(mout, min)\n" " syslog(LOG_NOTICE, 'executing filter: testing syslog')\n" " return FILTER_DISCARD\n" "end\n" "\n" ; memset(&msg_in, 0, sizeof(msg_in)); memset(&msg_out, 0, sizeof(msg_out)); CU_ASSERT_PTR_NOT_NULL(filter); CU_ASSERT_PTR_NOT_NULL(filter->init); CU_ASSERT_PTR_NOT_NULL(filter->func); CU_ASSERT_PTR_NOT_NULL(filter->exit); proplist_init(&properties); proplist_set(&properties, "script", tmpfilename); prepare_script(SCRIPT); CU_ASSERT_EQUAL_FATAL(filter->init(&ctx, &properties), EXIT_SUCCESS); CU_ASSERT_EQUAL(filter->func(&msg_out, &msg_in, &ctx, &properties), FILTER_DISCARD); CU_ASSERT_EQUAL(filter->exit(&ctx), FILTER_SUCCESS); proplist_free(&properties); }
static void test_existance(void) { CU_ASSERT_PTR_NOT_NULL(filter); CU_ASSERT_PTR_NOT_NULL(filter->init); CU_ASSERT_PTR_NOT_NULL(filter->exit); CU_ASSERT_PTR_NOT_NULL(filter->func); }
void test_find_index(void) { FILENODE *node[5]; FILENODE *current_node; GtkTreeIter iter; int index[11] = {4, 3, 2, 1, 0, 3, 2, 4, 0, 1, 1}; int i = 0; init_file_list(); node[0] = append_file("file1", "schema", "table", "geom_column", "-1", 'c', &iter); CU_ASSERT_PTR_NOT_NULL(node[0]); node[1] = append_file("file2", "schema", "table", "geom_column", "-1", 'c', &iter); CU_ASSERT_PTR_NOT_NULL(node[1]); node[2] = append_file("file3", "schema", "table", "geom_column", "-1", 'c', &iter); CU_ASSERT_PTR_NOT_NULL(node[2]); node[3] = append_file("file4", "schema", "table", "geom_column", "-1", 'c', &iter); CU_ASSERT_PTR_NOT_NULL(node[3]); node[4] = append_file("file5", "schema", "table", "geom_column", "-1", 'c', &iter); CU_ASSERT_PTR_NOT_NULL(node[4]); for (i = 0; i < 11; i++) { current_node = find_file_by_index(index[i]); CU_ASSERT_PTR_EQUAL(node[index[i]], current_node); } destroy_file_list(); }
void t_mutable_string_parse_int(void) { mutable_string_t a; CU_ASSERT_PTR_NOT_NULL( mutable_string_init_with_value( &a, TEST_STR_NUMERIC_1 ) ); CU_ASSERT_EQUAL( mutable_string_parse_int(&a), 123 ); CU_ASSERT_EQUAL( mutable_string_parse_long(&a), 123 ); CU_ASSERT_EQUAL( mutable_string_parse_long_long(&a), 123 ); CU_ASSERT_PTR_NOT_NULL( mutable_string_assign( &a, TEST_STR_NUMERIC_2 ) ); CU_ASSERT_EQUAL( mutable_string_parse_double(&a), 1.23 ); mutable_string_free(&a); }
void test_next_nonEmptyList(void) { list_t* lista = list_init(); addElement(lista, (void*)a); addElement(lista, (void*)b); addElement(lista, (void*)c); iterator_t* i=iterator_init(lista); payload_t * corrente = next(i); CU_ASSERT_PTR_NOT_NULL(corrente); CU_ASSERT_PTR_EQUAL(corrente, lista->head->payload); corrente = next(i); CU_ASSERT_PTR_NOT_NULL(corrente); CU_ASSERT_PTR_EQUAL(corrente, lista->head->next->payload); corrente = next(i); CU_ASSERT_PTR_NOT_NULL(corrente); CU_ASSERT_PTR_EQUAL(corrente, lista->tail->payload); corrente = next(i); CU_ASSERT_PTR_NULL(corrente); iterator_destroy(i); list_destroy(lista); }
static void test_existance(void) { CU_ASSERT_PTR_NOT_NULL(proc); CU_ASSERT_PTR_NOT_NULL(proc->init); CU_ASSERT_PTR_NOT_NULL(proc->func); CU_ASSERT_PTR_NOT_NULL(proc->exit); }
static void test_file_path() { belle_generic_uri_t* source_uri = belle_generic_uri_parse("/index.html"); char* source_uri_raw = belle_sip_object_to_string(source_uri); belle_generic_uri_t* first_uri = belle_generic_uri_parse(source_uri_raw); belle_generic_uri_t* uri=BELLE_GENERIC_URI(belle_sip_object_clone(BELLE_SIP_OBJECT(first_uri))); belle_sip_free(source_uri_raw); belle_sip_object_unref(source_uri); belle_sip_object_unref(first_uri); CU_ASSERT_PTR_NULL(belle_generic_uri_get_scheme(uri)); CU_ASSERT_PTR_NULL(belle_generic_uri_get_host(uri)); CU_ASSERT_STRING_EQUAL(belle_generic_uri_get_path(uri),"/index.html"); belle_sip_object_unref(uri); source_uri = belle_generic_uri_parse("file:///tmp/absolute-file"); CU_ASSERT_PTR_NOT_NULL(source_uri); if (source_uri!=NULL){ CU_ASSERT_STRING_EQUAL(belle_generic_uri_get_scheme(source_uri),"file"); CU_ASSERT_PTR_NULL(belle_generic_uri_get_host(source_uri)); CU_ASSERT_STRING_EQUAL(belle_generic_uri_get_path(source_uri),"/tmp/absolute-file"); belle_sip_object_unref(source_uri); } /*this is INVALID*/ source_uri = belle_generic_uri_parse("file://./relative-file"); CU_ASSERT_PTR_NOT_NULL(source_uri); /* PATH segment always start by / */ source_uri = belle_generic_uri_parse("./relative-file"); CU_ASSERT_PTR_NULL(source_uri); if (source_uri!=NULL){ belle_sip_object_unref(source_uri); } }
void test_pl_create_delete(void) { int rc; pooled_list *pl = NULL; rc = pl_create(&pl, sizeof(my_message_t), ELEM_COUNT_DEFAULT); /* make sure object creation successful before proceeding */ CU_ASSERT_EQUAL_FATAL(rc, PL_SUCCESS); CU_ASSERT_PTR_NOT_NULL_FATAL(pl); /* Check all default internal values */ CU_ASSERT((int)pl->elem_size == (int)sizeof(my_message_t)); CU_ASSERT(pl->elem_count == ELEM_COUNT_DEFAULT); CU_ASSERT(pl->count_free == ELEM_COUNT_DEFAULT); CU_ASSERT(pl->count_total == ELEM_COUNT_DEFAULT); CU_ASSERT(pl->count_current == 0); /* Check address node list */ CU_ASSERT_PTR_NOT_NULL(pl->addr_list); /* address node exists */ CU_ASSERT_PTR_NULL(pl->addr_list->next); /* no second node */ CU_ASSERT_PTR_NOT_NULL(pl->addr_list->addr); /* memory block allocated */ CU_ASSERT_PTR_EQUAL(pl->active_memblock, pl->addr_list); /*active blk set*/ /* check datablock pointers */ CU_ASSERT_PTR_NULL(pl->head); /* head pointer unset */ CU_ASSERT_PTR_NULL(pl->tail); /* tail pointer unset */ CU_ASSERT_PTR_EQUAL(pl->next_free, pl->addr_list->addr); /* next_free set */ destroy_pl_object(&pl); }
db_result_t* __db_result_list_next(void* data, int finish) { db_value_set_t* value_set; db_result_t* result; CU_ASSERT_FATAL(data == &fake_pointer); if (finish) { return NULL; } if (__db_result_list_next_count > 2) { return NULL; } CU_ASSERT_PTR_NOT_NULL_FATAL((value_set = db_value_set_new(2))); CU_ASSERT(db_value_set_size(value_set) == 2); CU_ASSERT_PTR_NOT_NULL(db_value_set_at(value_set, 0)); CU_ASSERT_PTR_NOT_NULL(db_value_set_at(value_set, 1)); CU_ASSERT_PTR_NULL(db_value_set_at(value_set, 2)); CU_ASSERT_PTR_NOT_NULL(db_value_set_get(value_set, 0)); CU_ASSERT_PTR_NOT_NULL(db_value_set_get(value_set, 1)); CU_ASSERT_PTR_NULL(db_value_set_get(value_set, 2)); CU_ASSERT_PTR_NOT_NULL_FATAL((result = db_result_new())); CU_ASSERT(!db_result_set_value_set(result, value_set)); CU_ASSERT(!db_result_not_empty(result)); __db_result_list_next_count++; return result; }
void test_class_db_result_list(void) { db_result_t* local_result = result; db_result_t* local_result2 = result2; CU_ASSERT_PTR_NOT_NULL_FATAL((result_list = db_result_list_new())); CU_ASSERT_FATAL(!db_result_list_add(result_list, result)); result = NULL; CU_ASSERT_FATAL(!db_result_list_add(result_list, result2)); result2 = NULL; CU_ASSERT(db_result_list_size(result_list) == 2); CU_ASSERT(db_result_list_begin(result_list) == local_result); CU_ASSERT(db_result_list_next(result_list) == local_result2); db_result_list_free(result_list); result_list = NULL; CU_PASS("db_result_list_free"); CU_PASS("db_result_free"); CU_ASSERT_PTR_NOT_NULL_FATAL((result_list = db_result_list_new())); CU_ASSERT_FATAL(!db_result_list_set_next(result_list, __db_result_list_next, &fake_pointer, 2)); CU_ASSERT(db_result_list_size(result_list) == 2); CU_ASSERT_PTR_NOT_NULL(db_result_list_begin(result_list)); CU_ASSERT_PTR_NOT_NULL(db_result_list_next(result_list)); db_result_list_free(result_list); result_list = NULL; CU_PASS("db_result_list_free"); CU_PASS("db_result_free"); }
void test_class_db_clause(void) { CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new())); CU_ASSERT(!db_clause_set_table(clause, "table")); CU_ASSERT(!db_clause_set_field(clause, "field")); CU_ASSERT(!db_clause_set_type(clause, DB_CLAUSE_NOT_EQUAL)); CU_ASSERT(!db_clause_set_operator(clause, DB_CLAUSE_OPERATOR_OR)); CU_ASSERT_PTR_NOT_NULL_FATAL(db_clause_get_value(clause)); CU_ASSERT(!db_value_from_int32(db_clause_get_value(clause), 1)); CU_ASSERT(!db_clause_not_empty(clause)); CU_ASSERT_PTR_NOT_NULL_FATAL(db_clause_table(clause)); CU_ASSERT(!strcmp(db_clause_table(clause), "table")); CU_ASSERT_PTR_NOT_NULL_FATAL(db_clause_field(clause)); CU_ASSERT(!strcmp(db_clause_field(clause), "field")); CU_ASSERT(db_clause_type(clause) == DB_CLAUSE_NOT_EQUAL); CU_ASSERT(db_clause_operator(clause) == DB_CLAUSE_OPERATOR_OR); CU_ASSERT_PTR_NOT_NULL(db_clause_value(clause)); CU_ASSERT_PTR_NULL(db_clause_next(clause)); CU_ASSERT_PTR_NOT_NULL_FATAL((clause2 = db_clause_new())); CU_ASSERT(!db_clause_set_type(clause2, DB_CLAUSE_NESTED)); CU_ASSERT(!db_clause_set_operator(clause2, DB_CLAUSE_OPERATOR_OR)); CU_ASSERT(!db_clause_set_list(clause2, (db_clause_list_t*)&fake_pointer)); CU_ASSERT(!db_clause_not_empty(clause2)); CU_ASSERT(db_clause_type(clause2) == DB_CLAUSE_NESTED); CU_ASSERT(db_clause_operator(clause2) == DB_CLAUSE_OPERATOR_OR); CU_ASSERT(db_clause_list(clause2) == (db_clause_list_t*)&fake_pointer); CU_ASSERT_PTR_NOT_NULL(db_clause_value(clause2)); }
void test_class_db_backend_meta_data_list(void) { db_backend_meta_data_t* local_backend_meta_data = backend_meta_data; db_backend_meta_data_t* local_backend_meta_data2 = backend_meta_data2; db_backend_meta_data_t* local_backend_meta_data3 = backend_meta_data3; db_backend_meta_data_t* local_backend_meta_data4 = backend_meta_data4; CU_ASSERT_PTR_NOT_NULL_FATAL((backend_meta_data_list = db_backend_meta_data_list_new())); CU_ASSERT_FATAL(!db_backend_meta_data_list_add(backend_meta_data_list, backend_meta_data)); backend_meta_data = NULL; CU_ASSERT_FATAL(!db_backend_meta_data_list_add(backend_meta_data_list, backend_meta_data2)); backend_meta_data2 = NULL; CU_ASSERT(db_backend_meta_data_list_find(backend_meta_data_list, "name1") == local_backend_meta_data); CU_ASSERT(db_backend_meta_data_list_find(backend_meta_data_list, "name2") == local_backend_meta_data2); CU_ASSERT_PTR_NOT_NULL_FATAL((backend_meta_data_list2 = db_backend_meta_data_list_new())); CU_ASSERT_FATAL(!db_backend_meta_data_list_copy(backend_meta_data_list2, backend_meta_data_list)); CU_ASSERT_PTR_NOT_NULL(db_backend_meta_data_list_find(backend_meta_data_list2, "name1")); CU_ASSERT_PTR_NOT_NULL(db_backend_meta_data_list_find(backend_meta_data_list2, "name2")); db_backend_meta_data_list_free(backend_meta_data_list2); backend_meta_data_list2 = NULL; CU_PASS("db_backend_meta_data_list_free"); CU_ASSERT_PTR_NOT_NULL_FATAL((backend_meta_data_list2 = db_backend_meta_data_list_new())); CU_ASSERT_FATAL(!db_backend_meta_data_list_add(backend_meta_data_list2, backend_meta_data3)); backend_meta_data3 = NULL; CU_ASSERT_FATAL(!db_backend_meta_data_list_add(backend_meta_data_list2, backend_meta_data4)); backend_meta_data4 = NULL; CU_ASSERT(db_backend_meta_data_list_find(backend_meta_data_list2, "name3") == local_backend_meta_data3); CU_ASSERT(db_backend_meta_data_list_find(backend_meta_data_list2, "name4") == local_backend_meta_data4); }
static void testItemMove (void) { Inventory inv; const objDef_t* od; const invDef_t* container, *containerTo; Item* addedItem; ResetInventoryList(); od = INVSH_GetItemByIDSilent("assault"); CU_ASSERT_PTR_NOT_NULL(od); container = INVSH_GetInventoryDefinitionByID("right"); CU_ASSERT_PTR_NOT_NULL(container); Item item(od); CU_ASSERT(inv.containsItem(container->id, &item) == false); addedItem = i.addToInventory(&inv, &item, container, NONE, NONE, 1); CU_ASSERT_PTR_NOT_NULL(addedItem); CU_ASSERT(inv.containsItem(container->id, &item) == true); containerTo = INVSH_GetInventoryDefinitionByID("backpack"); CU_ASSERT_PTR_NOT_NULL(containerTo); CU_ASSERT_EQUAL(IA_MOVE, i.moveInInventory(&inv, container, addedItem, containerTo, NONE, NONE, nullptr, nullptr)); CU_ASSERT(inv.containsItem(container->id, &item) == false); CU_ASSERT(inv.containsItem(containerTo->id, &item) == true); }
static void testItemDel (void) { Inventory inv; const objDef_t* od; const invDef_t* container; Item* addedItem; ResetInventoryList(); od = INVSH_GetItemByIDSilent("assault"); CU_ASSERT_PTR_NOT_NULL(od); container = INVSH_GetInventoryDefinitionByID("right"); CU_ASSERT_PTR_NOT_NULL(container); Item item(od); CU_ASSERT(inv.containsItem(container->id, &item) == false); addedItem = i.addToInventory(&inv, &item, container, NONE, NONE, 1); CU_ASSERT(inv.containsItem(container->id, &item) == true); CU_ASSERT(i.removeFromInventory(&inv, container, addedItem)); CU_ASSERT(inv.containsItem(container->id, &item) == false); }
static void test_create_new_program_with_broken_fragment_shader(void) { char *vertexShader = pgTestsCreateAssetPath("test_01.vsh"); char *fragmentShader = pgTestsCreateAssetPath("test_02_broken.fsh"); PGProgram program = NULL; PGResult result = pgProgramCreateAndBuild(&program, vertexShader, fragmentShader); CU_ASSERT_EQUAL(result, PGR_CouldNotCompileShader); CU_ASSERT_NOT_EQUAL(pgProgramVertexShader(program), 0); CU_ASSERT_EQUAL(pgProgramFragmentShader(program), 0); CU_ASSERT_EQUAL(pgProgramGlHandle(program), 0); CU_ASSERT_PTR_NOT_NULL(pgProgramVertexShaderCompileLog(program)); CU_ASSERT_PTR_NOT_NULL(pgProgramFragmentShaderCompileLog(program)); CU_ASSERT_PTR_NOT_NULL(pgProgramLinkLog(program)); CU_ASSERT_EQUAL(strlen(pgProgramVertexShaderCompileLog(program)), 0); CU_ASSERT_NOT_EQUAL(strlen(pgProgramFragmentShaderCompileLog(program)), 0); CU_ASSERT_EQUAL(strlen(pgProgramLinkLog(program)), 0); pgProgramDestroy(&program); CU_ASSERT_PTR_NULL(program); free(vertexShader); free(fragmentShader); }
static void test_cimunit_event_add_multiple_actions(void) { cimunit_event_t condition; cimunit_event_t action1; cimunit_event_t action2; cimunit_event_init(&condition, "condition"); cimunit_event_init(&action1, "action1"); cimunit_event_init(&action2, "action2"); cimunit_event_add_action(&condition, &action1); /// - Run SUT cimunit_event_add_action(&condition, &action2); /// - Verify both items are in the list CU_ASSERT_PTR_NOT_NULL(cimunit_event_list_find(condition.action_events, action1.event_name)); CU_ASSERT_PTR_NOT_NULL(cimunit_event_list_find(condition.action_events, action2.event_name)); /// - Clean up cimunit_event_destroy(&condition); cimunit_event_destroy(&action1); cimunit_event_destroy(&action2); }
static void testItemAdd (void) { inventory_t inv; const objDef_t *od; item_t item; const invDef_t *container; ResetInventoryList(); OBJZERO(inv); od = INVSH_GetItemByIDSilent("assault"); CU_ASSERT_PTR_NOT_NULL(od); container = INVSH_GetInventoryDefinitionByID("right"); CU_ASSERT_PTR_NOT_NULL(container); item.t = od; item.m = NULL; item.a = 0; CU_ASSERT(INVSH_ExistsInInventory(&inv, container, &item) == false); CU_ASSERT_PTR_NOT_NULL(i.AddToInventory(&i, &inv, &item, container, NONE, NONE, 1)); CU_ASSERT(INVSH_ExistsInInventory(&inv, container, &item) == true); }
static void identify_test(void) { WsXmlDocH response; static int i = 0; char *xp = NULL; wsmc_reinit_conn(cl); options = wsmc_options_init(); response = wsmc_action_identify(cl, options); CU_ASSERT_TRUE(wsmc_get_response_code(cl) == tests[i].final_status); CU_ASSERT_PTR_NOT_NULL(response); if (response == NULL) { goto RETURN; } if (tests[i].value1 != NULL) { xp = ws_xml_get_xpath_value(response, tests[i].expr1); CU_ASSERT_PTR_NOT_NULL(xp); if (xp) { CU_ASSERT_STRING_EQUAL(xp, tests[i].value1 ); } } RETURN: if (response) { ws_xml_destroy_doc(response); } u_free(xp); wsmc_options_destroy(options); i++; }
static void test_init_exit(void) { struct filter_context_t ctx; struct property_list_t properties; const char SCRIPT[] = "\n"; memset(&ctx, 0, sizeof(ctx)); CU_ASSERT_PTR_NOT_NULL(filter); CU_ASSERT_PTR_NOT_NULL(filter->init); CU_ASSERT_PTR_NOT_NULL(filter->exit); proplist_init(&properties); CU_ASSERT_EQUAL(filter->init(NULL, NULL), EXIT_FAILURE); CU_ASSERT_EQUAL(filter->init(NULL, &properties), EXIT_FAILURE); CU_ASSERT_EQUAL(filter->init(&ctx, NULL), EXIT_FAILURE); CU_ASSERT_EQUAL(filter->init(&ctx, &properties), EXIT_FAILURE); proplist_set(&properties, "script", ""); CU_ASSERT_EQUAL_FATAL(filter->init(&ctx, &properties), EXIT_FAILURE); prepare_script(SCRIPT); proplist_set(&properties, "script", tmpfilename); CU_ASSERT_EQUAL(filter->init(&ctx, &properties), EXIT_SUCCESS); CU_ASSERT_NOT_EQUAL(ctx.data, NULL); CU_ASSERT_EQUAL(filter->exit(&ctx), EXIT_SUCCESS); proplist_free(&properties); }
void test_prepend ( void ) { uint32_t arr[] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512}; uint32_t i; list * new_list = make_new_list(); node * cur = NULL; CU_ASSERT_PTR_NOT_NULL(new_list); for(i = 0; i < 10; i++) { prepend(new_list, &(arr[i])); } cur = get_head(new_list); CU_ASSERT_PTR_NOT_NULL(cur); i = 9; while(cur != NULL) { CU_ASSERT_EQUAL(*(uint32_t *)cur->data, arr[i]); cur = cur->next; i--; } cur = NULL; cur = get_tail(new_list); CU_ASSERT_PTR_NOT_NULL(cur); i = 0; while(cur != NULL) { CU_ASSERT_EQUAL(*(uint32_t *)cur->data, arr[i]); cur = cur->prev; i++; } CU_ASSERT_EQUAL(new_list->size, 10); }
static void test_queue(void) { struct ofp_ifqueue ifq; struct ifq_entry e; ifq.ifq_tail = NULL; ifq.ifq_len = 0; e.next = NULL; odp_packet_t m = odp_packet_alloc(ofp_packet_pool, 0); IF_ENQUEUE(&ifq, m) while (0); CU_ASSERT_PTR_NOT_NULL(ifq.ifq_head); CU_ASSERT_PTR_EQUAL(ifq.ifq_head, ifq.ifq_tail); CU_ASSERT_PTR_NULL(ifq.ifq_tail->next); CU_ASSERT_EQUAL(ifq.ifq_len, 1); ifq.ifq_head = ifq.ifq_tail = &e; IF_ENQUEUE(&ifq, m) while (0); CU_ASSERT_PTR_NOT_NULL(ifq.ifq_head); CU_ASSERT_PTR_NOT_NULL(ifq.ifq_tail); CU_ASSERT_PTR_NOT_EQUAL(ifq.ifq_head, ifq.ifq_tail); CU_ASSERT_PTR_EQUAL(ifq.ifq_head->next, ifq.ifq_tail); CU_ASSERT_PTR_NULL(ifq.ifq_tail->next); CU_ASSERT_EQUAL(ifq.ifq_len, 2); odp_packet_free(m); }
//-------------------------------------------------------------------------------------------------- void Testle_sms_msg_SendText() { le_result_t res; le_sms_msg_Ref_t myMsg; myMsg = le_sms_msg_Create(); CU_ASSERT_PTR_NOT_NULL(myMsg); LE_DEBUG("-TEST- Create Msg %p", myMsg); testHdlrRef=le_sms_msg_AddRxMessageHandler(TestRxHandler, NULL); CU_ASSERT_PTR_NOT_NULL(testHdlrRef); res=le_sms_msg_SetDestination(myMsg, DEST_TEST_PATTERN); CU_ASSERT_EQUAL(res, LE_OK); res=le_sms_msg_SetText(myMsg, LARGE_TEXT_TEST_PATTERN); CU_ASSERT_EQUAL(res, LE_OK); res=le_sms_msg_Send(myMsg); CU_ASSERT_NOT_EQUAL(res, LE_FAULT); CU_ASSERT_NOT_EQUAL(res, LE_FORMAT_ERROR); res=le_sms_msg_SetText(myMsg, SHORT_TEXT_TEST_PATTERN); CU_ASSERT_EQUAL(res, LE_OK); res=le_sms_msg_Send(myMsg); CU_ASSERT_NOT_EQUAL(res, LE_FAULT); CU_ASSERT_NOT_EQUAL(res, LE_FORMAT_ERROR); le_sms_msg_Delete(myMsg); }
static void testRegisterMessage(void) { const char* raw_message = "REGISTER sip:192.168.0.20 SIP/2.0\r\n"\ "v: SIP/2.0/UDP 192.168.1.8:5062;rport;branch=z9hG4bK1439638806\r\n"\ "f: <sip:[email protected]>;tag=465687829\r\n"\ "t: <sip:[email protected]>\r\n"\ "i: 1053183492\r\n"\ "CSeq: 1 REGISTER\r\n"\ "m: <sip:[email protected]:5062>\r\n"\ "Max-Forwards: 70\r\n"\ "User-Agent: Linphone/3.3.99.10 (eXosip2/3.3.0)\r\n"\ "Expires: 3600\r\n"\ "Proxy-Authorization: Digest username=\"8117396\", realm=\"Realm\", nonce=\"MTMwNDAwMjIxMjA4NzVkODY4ZmZhODMzMzU4ZDJkOTA1NzM2NTQ2NDZlNmIz"\ ", uri=\"sip:linphone.net\", response=\"eed376ff7c963441255ec66594e470e7\", algorithm=MD5, cnonce=\"0a4f113b\", qop=auth, nc=00000001\r\n"\ "l: 0\r\n\r\n"; belle_sip_request_t* request; belle_sip_message_t* message = belle_sip_message_parse(raw_message); char* encoded_message = belle_sip_object_to_string(BELLE_SIP_OBJECT(message)); belle_sip_object_unref(BELLE_SIP_OBJECT(message)); message = belle_sip_message_parse(encoded_message); request = BELLE_SIP_REQUEST(message); CU_ASSERT_STRING_EQUAL(belle_sip_request_get_method(request),"REGISTER"); CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Expires")); CU_ASSERT_PTR_NOT_NULL(BELLE_SIP_HEADER_EXPIRES(belle_sip_message_get_header(message,"Expires"))); CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Proxy-Authorization")); CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Contact")); check_uri_and_headers(message); belle_sip_free(encoded_message); belle_sip_object_unref(message); }
static void testInviteMessage(void) { const char* raw_message = "INVITE sip:[email protected] SIP/2.0\r\n"\ "Via: SIP/2.0/UDP 10.23.17.117:22600;branch=z9hG4bK-d8754z-4d7620d2feccbfac-1---d8754z-;rport=4820;received=202.165.193.129\r\n"\ "Max-Forwards: 70\r\n"\ "Contact: <sip:[email protected]:4820>\r\n"\ "To: \"becheong\" <sip:[email protected]>\r\n"\ "From: \"Benjamin Cheong\" <sip:[email protected]>;tag=7326e5f6\r\n"\ "Call-ID: Y2NlNzg0ODc0ZGIxODU1MWI5MzhkNDVkNDZhOTQ4YWU.\r\n"\ "CSeq: 1 INVITE\r\n"\ "Allow: INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO\r\n"\ "c: application/sdp\r\n"\ "Supported: replaces\r\n"\ "Authorization: Digest username=\"003332176\", realm=\"sip.ovh.net\", nonce=\"24212965507cde726e8bc37e04686459\", uri=\"sip:sip.ovh.net\", response=\"896e786e9c0525ca3085322c7f1bce7b\", algorithm=MD5, opaque=\"241b9fb347752f2\"\r\n"\ "User-Agent: X-Lite 4 release 4.0 stamp 58832\r\n"\ "Content-Length: 230\r\n\r\n"; belle_sip_request_t* request; belle_sip_message_t* message = belle_sip_message_parse(raw_message); char* encoded_message = belle_sip_object_to_string(BELLE_SIP_OBJECT(message)); belle_sip_object_unref(BELLE_SIP_OBJECT(message)); message = belle_sip_message_parse(encoded_message); request = BELLE_SIP_REQUEST(message); CU_ASSERT_STRING_EQUAL(belle_sip_request_get_method(request),"INVITE"); CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Contact")); CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Authorization")); CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Content-Type")); check_uri_and_headers(message); belle_sip_object_unref(message); belle_sip_free(encoded_message); }
static void test_overflow(void){ belle_sdp_session_description_t* sdp; belle_sip_list_t *mds; belle_sdp_media_description_t *vmd; int i; const size_t orig_buffsize=1024; size_t buffsize=orig_buffsize; char *buffer=belle_sip_malloc0(buffsize); size_t offset=0; sdp=belle_sdp_session_description_parse(big_sdp); CU_ASSERT_PTR_NOT_NULL(sdp); mds=belle_sdp_session_description_get_media_descriptions(sdp); CU_ASSERT_PTR_NOT_NULL(mds); CU_ASSERT_PTR_NOT_NULL(mds->next); vmd=(belle_sdp_media_description_t*)mds->next->data; for(i=0;i<16;i++){ belle_sdp_media_description_add_attribute(vmd,belle_sdp_attribute_create("candidate","2 1 UDP 1694498815 82.65.223.97 9078 typ srflx raddr 192.168.0.2 rport 9078")); } CU_ASSERT_EQUAL(belle_sip_object_marshal(BELLE_SIP_OBJECT(sdp),buffer,buffsize,&offset),BELLE_SIP_BUFFER_OVERFLOW); belle_sip_message("marshal size is %i",(int)offset); CU_ASSERT_TRUE(offset==buffsize); belle_sip_object_unref(sdp); belle_sip_free(buffer); }
/* insert new node as fourth element in queue */ void t_sendqueue4(void) { int result; result = coap_insert_node(&sendqueue, node[4]); CU_ASSERT(result > 0); CU_ASSERT_PTR_EQUAL(sendqueue, node[3]); CU_ASSERT_PTR_NOT_NULL(sendqueue->next); CU_ASSERT_PTR_EQUAL(sendqueue->next, node[1]); CU_ASSERT_PTR_NOT_NULL(sendqueue->next->next); CU_ASSERT_PTR_EQUAL(sendqueue->next->next, node[4]); CU_ASSERT_PTR_NOT_NULL(sendqueue->next->next->next); CU_ASSERT_PTR_EQUAL(sendqueue->next->next->next, node[2]); CU_ASSERT(sendqueue->next->t == timestamp[1] - timestamp[3]); CU_ASSERT(add_timestamps(sendqueue, 1) == timestamp[3]); CU_ASSERT(add_timestamps(sendqueue, 2) == timestamp[1]); CU_ASSERT(add_timestamps(sendqueue, 3) == timestamp[4]); CU_ASSERT(add_timestamps(sendqueue, 4) == timestamp[2]); }
void t_sendqueue9(void) { coap_queue_t *tmp_node; struct coap_context_t ctx; /* Initialize a fake context that points to our global sendqueue * Note that all changes happen on ctx.sendqueue. */ ctx.sendqueue = sendqueue; tmp_node = coap_peek_next(&ctx); sendqueue = ctx.sendqueue; /* must update global sendqueue for correct result */ CU_ASSERT_PTR_NOT_NULL(tmp_node); CU_ASSERT_PTR_EQUAL(tmp_node, node[1]); CU_ASSERT_PTR_EQUAL(tmp_node, ctx.sendqueue); tmp_node = coap_pop_next(&ctx); sendqueue = ctx.sendqueue; /* must update global sendqueue for correct result */ CU_ASSERT_PTR_NOT_NULL(tmp_node); CU_ASSERT_PTR_EQUAL(tmp_node, node[1]); CU_ASSERT_PTR_NOT_NULL(sendqueue); CU_ASSERT_PTR_EQUAL(sendqueue, node[2]); CU_ASSERT(tmp_node->t == timestamp[1]); CU_ASSERT(sendqueue->t == timestamp[2]); CU_ASSERT_PTR_NULL(sendqueue->next); }
static void testUriHeadersInInvite(void) { belle_sip_request_t* request; belle_sip_stack_t *stack=belle_sip_stack_new(NULL); belle_sip_provider_t *prov=belle_sip_provider_new(stack,NULL); const char* raw_uri="sip:[email protected]" "?header1=blabla" "&header2=blue%3Bweftutu%3Dbla" "&From=toto" "&To=sip%3Atoto%40titi.com" "&Call-ID=asdads" "&CSeq=asdasd" "&Via=asdasd" "&Accept=adsad" "&Accept-Encoding=adsad" "&Accept-Language=adsad" "&Allow=adsad" "&Record-Route=adsad" "&Contact=adsad" "&Organization=adsad" "&Supported=adsad" "&User-Agent=adsad"; belle_sip_header_t* raw_header; request=belle_sip_request_create( belle_sip_uri_parse(raw_uri) ,"INVITE" ,belle_sip_provider_create_call_id(prov) ,belle_sip_header_cseq_create(20,"INVITE") ,belle_sip_header_from_create2("sip:[email protected]","4654") ,NULL ,belle_sip_header_via_new() ,70); CU_ASSERT_PTR_NOT_NULL(request); CU_ASSERT_PTR_NOT_NULL(raw_header=belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"header1")); if (raw_header) { CU_ASSERT_STRING_EQUAL(belle_sip_header_extension_get_value(BELLE_SIP_HEADER_EXTENSION(raw_header)),"blabla"); } CU_ASSERT_PTR_NOT_NULL(raw_header=belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"header2")); if (raw_header) { CU_ASSERT_STRING_EQUAL(belle_sip_header_extension_get_value(BELLE_SIP_HEADER_EXTENSION(raw_header)),"blue;weftutu=bla"); } CU_ASSERT_PTR_NOT_NULL(raw_header=belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"To")); if (raw_header) { CU_ASSERT_STRING_EQUAL(belle_sip_header_extension_get_value(BELLE_SIP_HEADER_EXTENSION(raw_header)),"sip:[email protected]"); } CU_ASSERT_STRING_NOT_EQUAL(belle_sip_header_get_unparsed_value(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"From")),"toto"); CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Record-Route")); CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Accept")); CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Accept-Encoding")); CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Accept-Language")); CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Allow")); CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Contact")); CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Organization")); CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Supported")); CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"User-Agent")); belle_sip_object_unref(request); }
static void test_existance(void) { CU_ASSERT_PTR_NOT_NULL(device); CU_ASSERT_PTR_NOT_NULL(device->open); CU_ASSERT_PTR_NOT_NULL(device->close); CU_ASSERT_PTR_NOT_NULL(device->read); CU_ASSERT_PTR_NOT_NULL(device->write); }
void ASSERT_LIST_EQUAL2(list_t *list, void *exp1, void *exp2) { CU_ASSERT_PTR_NOT_NULL(list->tail); CU_ASSERT_PTR_NOT_NULL(list->head); CU_ASSERT_PTR_EQUAL(list->head->payload,exp1); CU_ASSERT_PTR_EQUAL(list->tail->payload,exp2); CU_ASSERT_PTR_EQUAL(list->tail, list->head->next); CU_ASSERT_PTR_NULL(list->tail->next); }