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