static void test_loop(int is_epoll) { int res = 0; int tfd1 = -1, tfd2 = -1, tfd3 = -1; int fd = -1; struct test_data data; struct pomp_loop *loop = NULL; memset(&data, 0, sizeof(data)); /* Create loop */ loop = pomp_loop_new(); CU_ASSERT_PTR_NOT_NULL_FATAL(loop); /* Create timers for testing */ tfd1 = setup_timerfd(100, 500); CU_ASSERT_TRUE_FATAL(tfd1 >= 0); tfd2 = setup_timerfd(50, 500); CU_ASSERT_TRUE_FATAL(tfd2 >= 0); tfd3 = setup_timerfd(150, 500); CU_ASSERT_TRUE_FATAL(tfd3 >= 0); /* Add timer in loop */ res = pomp_loop_add(loop, tfd1, POMP_FD_EVENT_IN, &timerfd_cb, &data); CU_ASSERT_EQUAL(res, 0); res = pomp_loop_has_fd(loop, tfd1); CU_ASSERT_EQUAL(res, 1); res = pomp_loop_has_fd(loop, tfd2); CU_ASSERT_EQUAL(res, 0); /* Invalid add (already in loop) */ res = pomp_loop_add(loop, tfd1, POMP_FD_EVENT_IN, &timerfd_cb, &data); CU_ASSERT_EQUAL(res, -EEXIST); /* Invalid add (NULL param) */ res = pomp_loop_add(NULL, tfd1, POMP_FD_EVENT_IN, &timerfd_cb, &data); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_loop_add(loop, tfd1, POMP_FD_EVENT_IN, NULL, &data); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid add (invalid events) */ res = pomp_loop_add(loop, tfd1, 0, &timerfd_cb, &data); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid add (invalid fd) */ res = pomp_loop_add(loop, -1, POMP_FD_EVENT_IN, &timerfd_cb, &data); CU_ASSERT_EQUAL(res, -EINVAL); /* Update events */ res = pomp_loop_update(loop, tfd1, POMP_FD_EVENT_IN | POMP_FD_EVENT_OUT); CU_ASSERT_EQUAL(res, 0); /* Invalid update (NULL param) */ res = pomp_loop_update(NULL, tfd1, POMP_FD_EVENT_IN | POMP_FD_EVENT_OUT); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid update (invalid events) */ res = pomp_loop_update(loop, tfd1, 0); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid update (invalid fd) */ res = pomp_loop_update(loop, -1, POMP_FD_EVENT_IN | POMP_FD_EVENT_OUT); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid remove (fd not registered) */ res = pomp_loop_update(loop, 2, POMP_FD_EVENT_IN | POMP_FD_EVENT_OUT); CU_ASSERT_EQUAL(res, -ENOENT); /* Update again events */ res = pomp_loop_update(loop, tfd1, POMP_FD_EVENT_IN); CU_ASSERT_EQUAL(res, 0); /* Add 2nd and 3rd timer in loop */ res = pomp_loop_add(loop, tfd2, POMP_FD_EVENT_IN, &timerfd_cb, &data); CU_ASSERT_EQUAL(res, 0); res = pomp_loop_add(loop, tfd3, POMP_FD_EVENT_IN, &timerfd_cb, &data); CU_ASSERT_EQUAL(res, 0); /* Get loop fd */ fd = pomp_loop_get_fd(loop); CU_ASSERT_TRUE((is_epoll && fd >= 0) || (!is_epoll && fd == -ENOSYS)); fd = pomp_loop_get_fd(NULL); CU_ASSERT_EQUAL(fd, -EINVAL); /* Run loop with different timeout first one should have all timers) */ res = pomp_loop_wait_and_process(loop, 500); CU_ASSERT_EQUAL(res, 0); res = pomp_loop_wait_and_process(loop, 0); CU_ASSERT_TRUE(res == -ETIMEDOUT || res == 0); res = pomp_loop_wait_and_process(loop, -1); CU_ASSERT_EQUAL(res, 0); /* Invalid run (NULL param) */ res = pomp_loop_wait_and_process(NULL, 0); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid destroy (NULL param) */ res = pomp_loop_destroy(NULL); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid destroy (busy) */ res = pomp_loop_destroy(loop); CU_ASSERT_EQUAL(res, -EBUSY); /* Invalid remove (NULL param) */ res = pomp_loop_remove(NULL, tfd1); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid remove (invalid fd) */ res = pomp_loop_remove(loop, -1); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid remove (fd not registered) */ res = pomp_loop_remove(loop, 2); CU_ASSERT_EQUAL(res, -ENOENT); /* Remove timers */ res = pomp_loop_remove(loop, tfd1); CU_ASSERT_EQUAL(res, 0); res = pomp_loop_remove(loop, tfd2); CU_ASSERT_EQUAL(res, 0); res = pomp_loop_remove(loop, tfd3); CU_ASSERT_EQUAL(res, 0); /* Close timers */ res = close(tfd1); CU_ASSERT_EQUAL(res, 0); res = close(tfd2); CU_ASSERT_EQUAL(res, 0); res = close(tfd3); CU_ASSERT_EQUAL(res, 0); /* Destroy loop */ res = pomp_loop_destroy(loop); CU_ASSERT_EQUAL(res, 0); }
void test_modesense6_residuals(void) { struct scsi_task *ms_task = NULL; logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Test of MODESENSE6 Residuals"); logging(LOG_VERBOSE, "MODESENSE6 command should not result in any " "residuals"); logging(LOG_VERBOSE, "Try a MODESENSE6 command with 4 bytes of " "transfer length and verify that we don't get residuals."); MODESENSE6(sd, &ms_task, 0, SCSI_MODESENSE_PC_CURRENT, SCSI_MODEPAGE_RETURN_ALL_PAGES, 0, 4, EXPECT_STATUS_GOOD); logging(LOG_VERBOSE, "[SUCCESS] All Pages fetched."); logging(LOG_VERBOSE, "Verify that we got at most 4 bytes of DATA-IN"); if (ms_task->datain.size > 4) { logging(LOG_NORMAL, "[FAILED] got more than 4 bytes of " "DATA-IN."); } else { logging(LOG_VERBOSE, "[SUCCESS] <= 4 bytes of DATA-IN " "received."); } CU_ASSERT_TRUE(ms_task->datain.size <= 4); logging(LOG_VERBOSE, "Verify residual overflow flag not set"); if (ms_task->residual_status == SCSI_RESIDUAL_OVERFLOW) { logging(LOG_VERBOSE, "[FAILED] Target set residual " "overflow flag"); } CU_ASSERT_NOT_EQUAL(ms_task->residual_status, SCSI_RESIDUAL_OVERFLOW); logging(LOG_VERBOSE, "Try a MODESENSE6 command with 255 bytes of " "transfer length and verify that we get residuals if the target returns less than the requested amount of data."); scsi_free_scsi_task(ms_task); MODESENSE6(sd, &ms_task, 0, SCSI_MODESENSE_PC_CURRENT, SCSI_MODEPAGE_RETURN_ALL_PAGES, 0, 255, EXPECT_STATUS_GOOD); logging(LOG_VERBOSE, "[SUCCESS] All Pages fetched."); if (ms_task->datain.size == 255) { logging(LOG_VERBOSE, "We got all 255 bytes of data back " "from the target. Verify that underflow is not set."); if (ms_task->residual_status == SCSI_RESIDUAL_UNDERFLOW) { logging(LOG_VERBOSE, "[FAILED] Target set residual " "underflow flag"); } else { logging(LOG_VERBOSE, "[SUCCESS] Residual underflow " "is not set"); } CU_ASSERT_NOT_EQUAL(ms_task->residual_status, SCSI_RESIDUAL_UNDERFLOW); } else { logging(LOG_VERBOSE, "We got less than the requested 255 bytes " "from the target. Verify that underflow is set."); if (ms_task->residual_status != SCSI_RESIDUAL_UNDERFLOW) { logging(LOG_VERBOSE, "[FAILED] Target did not set " "residual underflow flag"); } else { logging(LOG_VERBOSE, "[SUCCESS] Residual underflow " "is set"); } CU_ASSERT_EQUAL(ms_task->residual_status, SCSI_RESIDUAL_UNDERFLOW); } scsi_free_scsi_task(ms_task); }
void test_arrayList_isEmpty(void) { arrayList_clear(list); CU_ASSERT_EQUAL(list->size, 0); CU_ASSERT_TRUE(arrayList_isEmpty(list)); }
static void test_event_cb_t(struct pomp_ctx *ctx, enum pomp_event event, struct pomp_conn *conn, const struct pomp_msg *msg, void *userdata) { int fd; int res = 0; struct test_data *data = userdata; const char *eventstr = pomp_event_str(event); const struct sockaddr *addr = NULL; uint32_t addrlen = 0; const struct pomp_cred *cred = NULL; int isunix = 0; switch (event) { case POMP_EVENT_CONNECTED: data->connection++; /* Invalid get fd (NULL param) */ fd = pomp_conn_get_fd(NULL); CU_ASSERT_EQUAL(fd, -EINVAL); fd = pomp_conn_get_fd(conn); CU_ASSERT_TRUE(fd >= 0); addr = pomp_conn_get_local_addr(conn, &addrlen); CU_ASSERT_TRUE(addr != NULL); addr = pomp_conn_get_peer_addr(conn, &addrlen); CU_ASSERT_TRUE(addr != NULL); isunix = addr->sa_family == AF_UNIX; /* Invalid get addr (NULL param) */ addr = pomp_conn_get_local_addr(NULL, &addrlen); CU_ASSERT_TRUE(addr == NULL); addr = pomp_conn_get_local_addr(conn, NULL); CU_ASSERT_TRUE(addr == NULL); addr = pomp_conn_get_peer_addr(NULL, &addrlen); CU_ASSERT_TRUE(addr == NULL); addr = pomp_conn_get_peer_addr(conn, NULL); CU_ASSERT_TRUE(addr == NULL); if (!isunix) { /* Invalid get credentials (bad type or NULL param) */ cred = pomp_conn_get_peer_cred(conn); CU_ASSERT_TRUE(cred == NULL); cred = pomp_conn_get_peer_cred(NULL); CU_ASSERT_TRUE(cred == NULL); } else { cred = pomp_conn_get_peer_cred(conn); CU_ASSERT_TRUE(cred != NULL); } break; case POMP_EVENT_DISCONNECTED: data->disconnection++; break; case POMP_EVENT_MSG: data->msg++; if (pomp_msg_get_id(msg) == 1) { res = pomp_conn_send(conn, 2, "%s", eventstr); CU_ASSERT_EQUAL(res, 0); } if (data->isdgram) { res = pomp_conn_disconnect(conn); CU_ASSERT_EQUAL(res, -ENOTCONN); /* Internal function invalid arguments checks */ res = pomp_conn_send_msg_to(NULL, msg, NULL, 0); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_conn_send_msg_to(conn, NULL, NULL, 0); CU_ASSERT_EQUAL(res, -EINVAL); } else { /* Internal function invalid arguments checks */ res = pomp_conn_send_msg(NULL, msg); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_conn_send_msg(conn, NULL); CU_ASSERT_EQUAL(res, -EINVAL); } /* Internal function invalid arguments checks */ res = pomp_ctx_notify_event(NULL, POMP_EVENT_CONNECTED, conn); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_notify_event(ctx, POMP_EVENT_MSG, conn); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_notify_event(ctx, POMP_EVENT_CONNECTED, NULL); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_notify_msg(NULL, conn, msg); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_notify_msg(ctx, NULL, msg); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_notify_msg(ctx, conn, NULL); CU_ASSERT_EQUAL(res, -EINVAL); break; default: CU_ASSERT_TRUE_FATAL(0); break; } }
void teste_DT_verificaNovaTela_Y () { Tela teste; teste = nova_tela(); CU_ASSERT_TRUE(teste.y); }
void test_linkedlist_addremove() { CPLinkedListRef list; CPLinkedListItemRef item0; CPLinkedListItemRef item1; CPLinkedListItemRef item2; // Add retains/remove releases _test_linkedlist_total_item_count = 0; list = CPLinkedListCreate(offsetof(CPLinkedListItem, prevItem), offsetof(CPLinkedListItem, nextItem)); CU_ASSERT(list != NULL); item0 = CPLinkedListItemCreate(); CU_ASSERT(item0 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 1); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item0)); CPRelease(item0); CU_ASSERT(_test_linkedlist_total_item_count == 1); CPLinkedListRemoveItem(list, CPLinkedListGetHead(list)); CU_ASSERT(_test_linkedlist_total_item_count == 0); CPRelease(list); _test_linkedlist_total_item_count = 0; // Adding multiple times _test_linkedlist_total_item_count = 0; list = CPLinkedListCreate(offsetof(CPLinkedListItem, prevItem), offsetof(CPLinkedListItem, nextItem)); CU_ASSERT(list != NULL); item0 = CPLinkedListItemCreate(); CU_ASSERT(item0 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 1); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item0)); CU_ASSERT_FALSE(CPLinkedListAddItem(list, item0)); CU_ASSERT(_test_linkedlist_total_item_count == 1); CPLinkedListRemoveItem(list, item0); CPRelease(item0); CU_ASSERT(_test_linkedlist_total_item_count == 0); CPRelease(list); _test_linkedlist_total_item_count = 0; // Removing multiple times _test_linkedlist_total_item_count = 0; list = CPLinkedListCreate(offsetof(CPLinkedListItem, prevItem), offsetof(CPLinkedListItem, nextItem)); CU_ASSERT(list != NULL); item0 = CPLinkedListItemCreate(); CU_ASSERT(item0 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 1); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item0)); CPLinkedListRemoveItem(list, item0); CPLinkedListRemoveItem(list, item0); CPRelease(item0); CU_ASSERT(_test_linkedlist_total_item_count == 0); CPRelease(list); _test_linkedlist_total_item_count = 0; // Remove all _test_linkedlist_total_item_count = 0; list = CPLinkedListCreate(offsetof(CPLinkedListItem, prevItem), offsetof(CPLinkedListItem, nextItem)); CU_ASSERT(list != NULL); item0 = CPLinkedListItemCreate(); CU_ASSERT(item0 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 1); item1 = CPLinkedListItemCreate(); CU_ASSERT(item1 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 2); item2 = CPLinkedListItemCreate(); CU_ASSERT(item2 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 3); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item0)); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item1)); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item2)); CU_ASSERT(CPLinkedListGetCount(list) == 3); CU_ASSERT(CPLinkedListGetHead(list) != NULL); CU_ASSERT(CPLinkedListGetTail(list) != NULL); CPLinkedListRemoveAllItems(list); CU_ASSERT(CPLinkedListGetCount(list) == 0); CU_ASSERT(CPLinkedListGetHead(list) == NULL); CU_ASSERT(CPLinkedListGetTail(list) == NULL); CPRelease(item2); CPRelease(item1); CPRelease(item0); CU_ASSERT(_test_linkedlist_total_item_count == 0); CPRelease(list); _test_linkedlist_total_item_count = 0; // Remove all releases _test_linkedlist_total_item_count = 0; list = CPLinkedListCreate(offsetof(CPLinkedListItem, prevItem), offsetof(CPLinkedListItem, nextItem)); CU_ASSERT(list != NULL); item0 = CPLinkedListItemCreate(); CU_ASSERT(item0 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 1); item1 = CPLinkedListItemCreate(); CU_ASSERT(item1 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 2); item2 = CPLinkedListItemCreate(); CU_ASSERT(item2 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 3); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item0)); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item1)); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item2)); CU_ASSERT(CPLinkedListGetCount(list) == 3); CU_ASSERT(CPLinkedListGetHead(list) != NULL); CU_ASSERT(CPLinkedListGetTail(list) != NULL); CPRelease(item2); CPRelease(item1); CPRelease(item0); CU_ASSERT(_test_linkedlist_total_item_count == 3); CPLinkedListRemoveAllItems(list); CU_ASSERT(CPLinkedListGetCount(list) == 0); CU_ASSERT(CPLinkedListGetHead(list) == NULL); CU_ASSERT(CPLinkedListGetTail(list) == NULL); CU_ASSERT(_test_linkedlist_total_item_count == 0); CPRelease(list); _test_linkedlist_total_item_count = 0; }
void test_prin_report_caps_simple(void) { int ret = 0; const unsigned long long key = rand_key(); struct scsi_task *tsk; struct scsi_persistent_reserve_in_report_capabilities *rcaps; struct test_prin_report_caps_types *type; CHECK_FOR_DATALOSS; logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Test Persistent Reserve In REPORT CAPABILITIES works."); /* register our reservation key with the target */ ret = prout_register_and_ignore(sd, key); if (ret == -2) { logging(LOG_NORMAL, "[SKIPPED] PERSISTENT RESERVE OUT is not implemented."); CU_PASS("PERSISTENT RESERVE OUT is not implemented."); return; } CU_ASSERT_EQUAL(ret, 0); ret = prin_report_caps(sd, &tsk, &rcaps); CU_ASSERT_EQUAL(ret, 0); logging(LOG_VERBOSE, "Checking PERSISTENT RESERVE IN REPORT CAPABILITIES fields."); CU_ASSERT_EQUAL(rcaps->length, 8); CU_ASSERT_TRUE(rcaps->allow_commands <= 5); CU_ASSERT_EQUAL(rcaps->persistent_reservation_type_mask & ~SCSI_PR_TYPE_MASK_ALL, 0); for (type = &report_caps_types_array[0]; type->mask != 0; type++) { if (!(rcaps->persistent_reservation_type_mask & type->mask)) { logging(LOG_NORMAL, "PERSISTENT RESERVE op 0x%x not supported", type->op); continue; } logging(LOG_VERBOSE, "PERSISTENT RESERVE OUT op 0x%x supported, testing", type->op); /* reserve the target */ ret = prout_reserve(sd, key, type->op); CU_ASSERT_EQUAL(ret, 0); /* verify target reservation */ ret = prin_verify_reserved_as(sd, pr_type_is_all_registrants(type->op) ? 0 : key, type->op); CU_ASSERT_EQUAL(0, ret); /* release the target */ ret = prout_release(sd, key, type->op); CU_ASSERT_EQUAL(ret, 0); } scsi_free_scsi_task(tsk); rcaps = NULL; /* freed with tsk */ /* drop registration */ ret = prout_register_key(sd, 0, key); CU_ASSERT_EQUAL(ret, 0); }
void stack_some_pieces() { int numberOfRows = 20; int numberOfColumns = 10; int delay = 500; int imove; TrnGame* game = trn_game_new(numberOfRows, numberOfColumns, delay); // TrnPiece 0. While the piece is falling: // Rotate it 3 times. for (imove = 0; imove < 3; imove++) { CU_ASSERT_TRUE( trn_game_try_to_move_down(game) ); CU_ASSERT_TRUE( trn_game_try_to_rotate_clockwise(game) ); } // Move piece to left. CU_ASSERT_TRUE( trn_game_try_to_move_down(game) ); CU_ASSERT_TRUE( trn_game_try_to_move_left(game) ); // Reach bottom. while (true) { if (! trn_game_try_to_move_down(game)) break; } // TrnPiece 1. While the piece is falling: // Rotate it 1 times. CU_ASSERT_TRUE( trn_game_try_to_move_down(game) ); CU_ASSERT_TRUE( trn_game_try_to_rotate_clockwise(game) ); // Move piece to left. for (imove = 0; imove < 4; imove++) { CU_ASSERT_TRUE( trn_game_try_to_move_down(game) ); CU_ASSERT_TRUE( trn_game_try_to_move_left(game) ); } // Reach bottom. while (true) { if (! trn_game_try_to_move_down(game)) break; } // TrnPiece 2. While the piece is falling: // Rotate it 1 times. CU_ASSERT_TRUE( trn_game_try_to_move_down(game) ); CU_ASSERT_TRUE( trn_game_try_to_rotate_clockwise(game) ); // Move piece to left. for (imove = 0; imove < 2; imove++) { CU_ASSERT_TRUE( trn_game_try_to_move_down(game) ); CU_ASSERT_TRUE( trn_game_try_to_move_left(game) ); } // Reach bottom. while (true) { if (! trn_game_try_to_move_down(game)) break; } // TrnPiece 3. While the piece is falling: // Rotate it 3 times. for (imove = 0; imove < 3; imove++) { CU_ASSERT_TRUE( trn_game_try_to_move_down(game) ); CU_ASSERT_TRUE( trn_game_try_to_rotate_clockwise(game) ); } // Move piece to left. for (imove = 0; imove < 3; imove++) { CU_ASSERT_TRUE( trn_game_try_to_move_down(game) ); CU_ASSERT_TRUE( trn_game_try_to_move_left(game) ); } // Reach bottom. while (true) { if (! trn_game_try_to_move_down(game)) break; } TrnGrid* expected_grid = trn_grid_new(numberOfRows, numberOfColumns); int rowIndex; int columnIndex; TrnPositionInGrid pos; // Expected expected_grid type for pieces 0 and 2 for (rowIndex = numberOfRows-4 ; rowIndex < numberOfRows ; rowIndex++) { pos.rowIndex = rowIndex; for (columnIndex = 2 ; columnIndex < 4 ; columnIndex++) { pos.columnIndex = columnIndex; trn_grid_set_cell(expected_grid, pos, TRN_TETROMINO_J); } } // Expected expected_grid type for pieces 1 and 3 for (rowIndex = numberOfRows-4 ; rowIndex < numberOfRows ; rowIndex++) { pos.rowIndex = rowIndex; for (columnIndex = 0 ; columnIndex < 2 ; columnIndex++) { pos.columnIndex = columnIndex; trn_grid_set_cell(expected_grid, pos, TRN_TETROMINO_L); } } // Expected next piece pos.rowIndex = 0; pos.columnIndex = 3; trn_grid_set_cell(expected_grid, pos, TRN_TETROMINO_J); pos.rowIndex = 1; for (columnIndex = 3 ; columnIndex < 6 ; columnIndex++) { pos.columnIndex = columnIndex; trn_grid_set_cell(expected_grid, pos, TRN_TETROMINO_J); } CU_ASSERT_TRUE( trn_grid_equal(game->grid, expected_grid) ); trn_game_destroy(game); }
//-------------------------------------------------------------------------------------------------- void Testle_sms_ReceivedList() { le_result_t res; le_sms_MsgRef_t myMsg; le_sms_MsgRef_t lMsg1, lMsg2; le_sms_MsgListRef_t receivedList; le_sms_Status_t mystatus; myMsg = le_sms_Create(); CU_ASSERT_PTR_NOT_NULL(myMsg); res=le_sms_SetDestination(myMsg, DEST_TEST_PATTERN); CU_ASSERT_EQUAL(res, LE_OK); res=le_sms_SetText(myMsg, TEXT_TEST_PATTERN); CU_ASSERT_EQUAL(res, LE_OK); res=le_sms_Send(myMsg); CU_ASSERT_NOT_EQUAL(res, LE_FAULT); CU_ASSERT_NOT_EQUAL(res, LE_FORMAT_ERROR); res=le_sms_Send(myMsg); CU_ASSERT_NOT_EQUAL(res, LE_FAULT); CU_ASSERT_NOT_EQUAL(res, LE_FORMAT_ERROR); if (res == LE_OK) { uint32_t i=0; fprintf(stderr, "\nPlease ensure that the device has received at least 2 messages, then press enter\n"); while ( getchar() != '\n' ); if ((res == LE_OK) && (i<10)) { // List Received messages receivedList=le_sms_CreateRxMsgList(); CU_ASSERT_PTR_NOT_NULL(receivedList); lMsg1=le_sms_GetFirst(receivedList); CU_ASSERT_PTR_NOT_NULL(lMsg1); if (lMsg1 != NULL) { mystatus=le_sms_GetStatus(lMsg1); CU_ASSERT_TRUE((mystatus==LE_SMS_RX_READ)||(mystatus==LE_SMS_RX_UNREAD)); LE_INFO("-TEST- Delete Rx message 1.%p", lMsg1); le_sms_Delete(lMsg1); } lMsg2=le_sms_GetNext(receivedList); CU_ASSERT_PTR_NOT_NULL(lMsg2); if (lMsg2 != NULL) { mystatus=le_sms_GetStatus(lMsg2); CU_ASSERT_TRUE((mystatus==LE_SMS_RX_READ)||(mystatus==LE_SMS_RX_UNREAD)); LE_INFO("-TEST- Delete Rx message 2.%p", lMsg2); le_sms_Delete(lMsg2); } LE_INFO("-TEST- Delete the ReceivedList"); le_sms_DeleteList(receivedList); } else { LE_ERROR("-TEST- Unable to complete Testle_sms_ReceivedList Test"); } } else { LE_ERROR("-TEST- Unable to complete Testle_sms_ReceivedList Test"); } // Delete sent message le_sms_Delete(myMsg); }
static void presence_information(void) { const char *bike_description = "Riding my bike"; const char *vacation_note = "I'm on vacation until July 4th"; const char *vacation_lang = "en"; const char *contact = "sip:[email protected]"; LinphoneCoreManager *marie = presence_linphone_core_manager_new("marie"); LinphoneCoreManager *pauline = presence_linphone_core_manager_new("pauline"); LinphonePresenceModel *presence; LinphonePresenceActivity *activity = NULL; LinphonePresenceNote *note = NULL; const char *description = NULL; const char *note_content = NULL; char *contact2; time_t current_timestamp, presence_timestamp; CU_ASSERT_TRUE(subscribe_to_callee_presence(marie, pauline)); /* Presence activity without description. */ presence = linphone_presence_model_new_with_activity(LinphonePresenceActivityDinner, NULL); linphone_core_set_presence_model(pauline->lc, presence); wait_for(marie->lc,pauline->lc,&marie->stat.number_of_LinphonePresenceActivityDinner,1); CU_ASSERT_EQUAL(marie->stat.number_of_LinphonePresenceActivityDinner, 1); activity = linphone_presence_model_get_activity(marie->stat.last_received_presence); CU_ASSERT_PTR_NOT_NULL(activity); CU_ASSERT_EQUAL(linphone_presence_activity_get_type(activity), LinphonePresenceActivityDinner); description = linphone_presence_activity_get_description(activity); CU_ASSERT_PTR_NULL(description); /* Presence activity with description. */ presence = linphone_presence_model_new_with_activity(LinphonePresenceActivitySteering, bike_description); linphone_core_set_presence_model(pauline->lc, presence); wait_for(marie->lc,pauline->lc,&marie->stat.number_of_LinphonePresenceActivitySteering,1); CU_ASSERT_EQUAL(marie->stat.number_of_LinphonePresenceActivitySteering, 1); activity = linphone_presence_model_get_activity(marie->stat.last_received_presence); CU_ASSERT_PTR_NOT_NULL(activity); CU_ASSERT_EQUAL(linphone_presence_activity_get_type(activity), LinphonePresenceActivitySteering); description = linphone_presence_activity_get_description(activity); CU_ASSERT_PTR_NOT_NULL(description); if (description != NULL) CU_ASSERT_EQUAL(strcmp(description, bike_description), 0); /* Presence activity with description and note. */ presence = linphone_presence_model_new_with_activity_and_note(LinphonePresenceActivityVacation, NULL, vacation_note, vacation_lang); linphone_core_set_presence_model(pauline->lc, presence); wait_for(marie->lc,pauline->lc,&marie->stat.number_of_LinphonePresenceActivityVacation,1); CU_ASSERT_EQUAL(marie->stat.number_of_LinphonePresenceActivityVacation, 1); activity = linphone_presence_model_get_activity(marie->stat.last_received_presence); CU_ASSERT_PTR_NOT_NULL(activity); CU_ASSERT_EQUAL(linphone_presence_activity_get_type(activity), LinphonePresenceActivityVacation); description = linphone_presence_activity_get_description(activity); CU_ASSERT_PTR_NULL(description); note = linphone_presence_model_get_note(marie->stat.last_received_presence, NULL); CU_ASSERT_PTR_NOT_NULL(note); if (note != NULL) { note_content = linphone_presence_note_get_content(note); CU_ASSERT_PTR_NOT_NULL(note_content); if (note_content != NULL) { CU_ASSERT_EQUAL(strcmp(note_content, vacation_note), 0); } } /* Presence contact. */ presence = linphone_presence_model_new_with_activity(LinphonePresenceActivityOnThePhone, NULL); linphone_presence_model_set_contact(presence, contact); linphone_core_set_presence_model(pauline->lc, presence); wait_for(marie->lc,pauline->lc,&marie->stat.number_of_LinphonePresenceActivityOnThePhone,1); CU_ASSERT_EQUAL(marie->stat.number_of_LinphonePresenceActivityOnThePhone, 1); contact2 = linphone_presence_model_get_contact(presence); CU_ASSERT_PTR_NOT_NULL(contact2); if (contact2 != NULL) { CU_ASSERT_EQUAL(strcmp(contact, contact2), 0); ms_free(contact2); } /* Presence timestamp. */ current_timestamp = ms_time(NULL); presence = linphone_presence_model_new_with_activity(LinphonePresenceActivityShopping, NULL); linphone_core_set_presence_model(pauline->lc, presence); wait_for(marie->lc,pauline->lc,&marie->stat.number_of_LinphonePresenceActivityShopping,1); CU_ASSERT_EQUAL(marie->stat.number_of_LinphonePresenceActivityShopping, 1); presence_timestamp = linphone_presence_model_get_timestamp(presence); CU_ASSERT_TRUE(presence_timestamp >= current_timestamp); linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); }
void TestGridCanSetCellsWithPiece() { /* Reminder on tetromino_srs_i at TRN_ANGLE_0 and TRN_ANGLE_90: T---+---+---+---+ | | | 9| | T: topLeftCorner position in grid +---+---+---+---+ 0: tetromino cells a TRN_ANGLE_0 | 0 | 0 | 01| 0 | 9: tetromino cells a TRN_ANGLE_90 +---+---+---+---+ | | | 9| | +---+---+---+---+ | | | 9| | +---+---+---+---+ */ // Create a grid. int numberOfRows = 10; int numberOfColumns = 10; TrnGrid* grid = trn_grid_new(numberOfRows, numberOfColumns); // For now, the grid has only void cells. // Ok, in grid and void. TrnPiece piece0 = trn_piece_create(TRN_TETROMINO_I,0,0,TRN_ANGLE_0); CU_ASSERT_TRUE( trn_grid_can_set_cells_with_piece(grid, &piece0) ) // Ok, still in grid (in the first row). TrnPiece piece1 = trn_piece_create(TRN_TETROMINO_I,-1,0,TRN_ANGLE_0); CU_ASSERT_TRUE( trn_grid_can_set_cells_with_piece(grid, &piece1) ) // No more in grid. TrnPiece piece2 = trn_piece_create(TRN_TETROMINO_I,-2,0,TRN_ANGLE_0); CU_ASSERT_FALSE( trn_grid_can_set_cells_with_piece(grid, &piece2) ) // Ok, in grid and void. TrnPiece piece3 = trn_piece_create(TRN_TETROMINO_I,5,0,TRN_ANGLE_90); CU_ASSERT_TRUE( trn_grid_can_set_cells_with_piece(grid, &piece3) ) // Ok, still in grid (in the first column). TrnPiece piece4 = trn_piece_create(TRN_TETROMINO_I,5,-2,TRN_ANGLE_90); CU_ASSERT_TRUE( trn_grid_can_set_cells_with_piece(grid, &piece4) ) // No more in grid. TrnPiece piece5 = trn_piece_create(TRN_TETROMINO_I,5,-3,TRN_ANGLE_90); CU_ASSERT_FALSE( trn_grid_can_set_cells_with_piece(grid, &piece5) ) // Now, fill the last grid row with non-void tetrominos. TrnPositionInGrid pos; int columnIndex; pos.rowIndex = numberOfRows-1 ; for (columnIndex = 0 ; columnIndex < grid->numberOfColumns ; columnIndex++) { pos.columnIndex = columnIndex; trn_grid_set_cell(grid, pos, TRN_TETROMINO_I); } // Ok, in grid and void. TrnPiece piece6 = trn_piece_create(TRN_TETROMINO_I,0,0,TRN_ANGLE_90); CU_ASSERT_TRUE( trn_grid_can_set_cells_with_piece(grid, &piece6) ) // Still in grid and void, just above the non-void row. TrnPiece piece7 = trn_piece_create(TRN_TETROMINO_I,numberOfRows-5,0,TRN_ANGLE_90); CU_ASSERT_TRUE( trn_grid_can_set_cells_with_piece(grid, &piece7) ) // In grid, but last cell of piece overlap a non-void cell of the grid. TrnPiece piece8 = trn_piece_create(TRN_TETROMINO_I,numberOfRows-4,0,TRN_ANGLE_90); CU_ASSERT_FALSE( trn_grid_can_set_cells_with_piece(grid, &piece8) ) }
void teste_DT_Novo_Bloco_Y(void) { Bloco resultado; resultado = novo_bloco(2,3, INVISIVEL); CU_ASSERT_TRUE (resultado.y == 3); }
void teste_DT_Novo_Bloco_Tipo_Quadrado(void) { Bloco resultado; resultado = novo_bloco(2,3, QUADRADO); CU_ASSERT_TRUE (resultado.tipo == QUADRADO); }
void teste_DT_Novo_Bloco_Tipo_Invisivel(void) { Bloco resultado; resultado = novo_bloco(2,3, INVISIVEL); CU_ASSERT_TRUE (resultado.tipo == INVISIVEL); }
/* Teste letra maiuscula */ void teste_DT_ProximaLetra_Z(void) { char resultado; resultado = ProximaLetra('Z'); CU_ASSERT_TRUE( resultado == 'A' ); }
static void testRange (void) { CU_ASSERT_TRUE(EV_NUM_EVENTS < EVENT_INSTANTLY); }
//-------------------------------------------------------------------------------------------------- void TestInteractivele_sim_Authentication() { le_result_t res; bool ready=false; int32_t initTries=0; int32_t tries=0; le_sim_ObjRef_t simRef; uint32_t i=1; bool pinReq=true; char internalPin[2][16]; le_sim_States_t state; getCodes(); do { fprintf(stderr, "\nTake off, then insert SIM card.%d, wait for +WIND:1 (approx. 2s) and then press enter \n", i); while ( getchar() != '\n' ); simRef = le_sim_Create(i); CU_ASSERT_PTR_NOT_NULL(simRef); state = le_sim_GetState(simRef); displaySIMState(state, i); fprintf(stderr, "\nPress enter to continue...\n"); while ( getchar() != '\n' ); strcpy((char*)&internalPin[i-1][0], (char*)&PIN_TEST[i-1][0]); // Enter PIN if(state == LE_SIM_READY) { pinReq=false; // Lock PIN res = le_sim_Lock(simRef, PIN_TOO_LONG_TEST); CU_ASSERT_EQUAL(res, LE_OVERFLOW); res = le_sim_Lock(simRef, PIN_TOO_SHORT_TEST); CU_ASSERT_EQUAL(res, LE_UNDERFLOW); res = le_sim_Lock(simRef, FAIL_PIN_TEST); CU_ASSERT_EQUAL(res, LE_NOT_POSSIBLE); res = le_sim_Lock(simRef, (char*)&internalPin[i-1][0]); CU_ASSERT_EQUAL(res, LE_OK); fprintf(stderr, "\nle_sim_Lock, res.%d (should be LE_OK=0)\n", res); fprintf(stderr, "\nTake off, then insert SIM card.%d, wait for +WIND:1 (approx. 2s) and then press enter \n", i); while ( getchar() != '\n' ); } initTries=le_sim_GetRemainingPINTries(simRef); res = le_sim_EnterPIN(simRef, PIN_TOO_LONG_TEST); CU_ASSERT_EQUAL(res, LE_OVERFLOW); res = le_sim_EnterPIN(simRef, PIN_TOO_SHORT_TEST); CU_ASSERT_EQUAL(res, LE_UNDERFLOW); res = le_sim_EnterPIN(simRef, FAIL_PIN_TEST); CU_ASSERT_EQUAL(res, LE_NOT_POSSIBLE); tries=le_sim_GetRemainingPINTries(simRef); CU_ASSERT_TRUE((initTries-tries == 1)); ready=le_sim_IsReady(simRef); CU_ASSERT_FALSE(ready); res = le_sim_EnterPIN(simRef, (char*)&internalPin[i-1][0]); CU_ASSERT_EQUAL(res, LE_OK); ready=le_sim_IsReady(simRef); CU_ASSERT_TRUE(ready); #if 0 if (ready != true) { LE_FATAL("SIM card.%d NOT READY ! check it, test exits !", i); } #endif fprintf(stderr, "\nle_sim_EnterPIN, res.%d (should be LE_OK=0) \n", res); fprintf(stderr, "\nWait for SIM card.%d answer (+CREG: 1, approx. 2s) and then press enter \n", i); while ( getchar() != '\n' ); // Change PIN res = le_sim_ChangePIN(simRef, PIN_TOO_LONG_TEST, NEW_PIN_TEST); CU_ASSERT_EQUAL(res, LE_OVERFLOW); res = le_sim_ChangePIN(simRef, (char*)&internalPin[i-1][0], PIN_TOO_LONG_TEST); CU_ASSERT_EQUAL(res, LE_OVERFLOW); res = le_sim_ChangePIN(simRef, PIN_TOO_SHORT_TEST, NEW_PIN_TEST); CU_ASSERT_EQUAL(res, LE_UNDERFLOW); res = le_sim_ChangePIN(simRef, (char*)&internalPin[i-1][0], PIN_TOO_SHORT_TEST); CU_ASSERT_EQUAL(res, LE_UNDERFLOW); res = le_sim_ChangePIN(simRef, FAIL_PIN_TEST, NEW_PIN_TEST); CU_ASSERT_EQUAL(res, LE_NOT_POSSIBLE); res = le_sim_ChangePIN(simRef, (char*)&internalPin[i-1][0], NEW_PIN_TEST); CU_ASSERT_EQUAL(res, LE_OK); fprintf(stderr, "\nle_sim_ChangePIN, res.%d (should be LE_OK=0)\n", res); fprintf(stderr, "\nTake off, then insert SIM card.%d, wait for +WIND:1 (approx. 2s) and then press enter \n", i); while ( getchar() != '\n' ); // Unblock PIN while((initTries=le_sim_GetRemainingPINTries(simRef))>0) { res = le_sim_EnterPIN(simRef, FAIL_PIN_TEST); } if(initTries < 0) { fprintf(stderr, "\nle_sim_GetRemainingPINTries error, res.%d (should be >=0)\n", initTries); } res = le_sim_Unblock(simRef, (char*)&PUK_TEST[i-1][0], PIN_TOO_LONG_TEST); CU_ASSERT_EQUAL(res, LE_OVERFLOW); res = le_sim_Unblock(simRef, (char*)&PUK_TEST[i-1][0], PIN_TOO_SHORT_TEST); CU_ASSERT_EQUAL(res, LE_UNDERFLOW); res = le_sim_Unblock(simRef, PUK_BAD_LENGTH_TEST, NEW_PIN_TEST); CU_ASSERT_EQUAL(res, LE_OUT_OF_RANGE); res = le_sim_Unblock(simRef, FAIL_PUK_TEST, NEW_PIN_TEST); CU_ASSERT_EQUAL(res, LE_NOT_POSSIBLE); res = le_sim_Unblock(simRef, (char*)&PUK_TEST[i-1][0], (char*)&internalPin[i-1][0]); CU_ASSERT_EQUAL(res, LE_OK); fprintf(stderr, "\nle_sim_Unblock, res.%d (should be LE_OK=0), press enter to continue \n", res); while ( getchar() != '\n' ); // Unlock PIN res = le_sim_Unlock(simRef, PIN_TOO_LONG_TEST); CU_ASSERT_EQUAL(res, LE_OVERFLOW); res = le_sim_Unlock(simRef, PIN_TOO_SHORT_TEST); CU_ASSERT_EQUAL(res, LE_UNDERFLOW); res = le_sim_Unlock(simRef, FAIL_PIN_TEST); CU_ASSERT_EQUAL(res, LE_NOT_POSSIBLE); res = le_sim_Unlock(simRef, (char*)&internalPin[i-1][0]); CU_ASSERT_EQUAL(res, LE_OK); fprintf(stderr, "\nle_sim_Unlock, res.%d (should be LE_OK=0), press enter to continue \n", res); while ( getchar() != '\n' ); // Re-lock the SIM card if (pinReq) { res = le_sim_Lock(simRef, (char*)&internalPin[i-1][0]); CU_ASSERT_EQUAL(res, LE_OK); } le_sim_Delete(simRef); i++; } while (i<=le_sim_CountSlots()); // Test case for SIM card absent: executed only on first slot simRef = le_sim_Create(1); CU_ASSERT_PTR_NOT_NULL(simRef); fprintf(stderr, "Take off SIM card.1 and then press enter \n"); while ( getchar() != '\n' ); // Enter PIN initTries=le_sim_GetRemainingPINTries(simRef); CU_ASSERT_TRUE((initTries == LE_NOT_FOUND) || (initTries == LE_NOT_POSSIBLE)); res = le_sim_EnterPIN(simRef, PIN_TEMP); CU_ASSERT_TRUE((res == LE_NOT_FOUND) || (res == LE_NOT_POSSIBLE)); ready=le_sim_IsReady(simRef); CU_ASSERT_FALSE(ready); // Change PIN res = le_sim_ChangePIN(simRef, PIN_TEMP, NEW_PIN_TEST); CU_ASSERT_TRUE((res == LE_NOT_FOUND) || (res == LE_NOT_POSSIBLE)); // Unblock PIN res = le_sim_Unblock(simRef, (char*)&PUK_TEST[0][0], PIN_TEMP); CU_ASSERT_TRUE((res == LE_NOT_FOUND) || (res == LE_NOT_POSSIBLE)); // Unlock PIN res = le_sim_Unlock(simRef, PIN_TEMP); CU_ASSERT_TRUE((res == LE_NOT_FOUND) || (res == LE_NOT_POSSIBLE)); le_sim_Delete(simRef); fprintf(stderr, "Insert SIM card.1, wait for +WIND:1 (approx. 2s) and then press enter \n"); while ( getchar() != '\n' ); }
static void early_media_with_multicast_base(bool_t video) { LinphoneCoreManager *marie, *pauline, *pauline2; MSList* lcs = NULL; int dummy=0; int leaked_objects; int begin; LinphoneVideoPolicy marie_policy, pauline_policy; LpConfig *marie_lp; belle_sip_object_enable_leak_detector(TRUE); begin=belle_sip_object_get_object_count(); marie = linphone_core_manager_new("marie_rc"); pauline = linphone_core_manager_new("pauline_rc"); pauline2 = linphone_core_manager_new("pauline_rc"); marie_lp=linphone_core_get_config(marie->lc); lp_config_set_int(marie_lp,"misc","real_early_media",1); if (video) { linphone_core_enable_video_capture(pauline->lc, FALSE); linphone_core_enable_video_display(pauline->lc, TRUE); linphone_core_enable_video_capture(pauline2->lc, FALSE); linphone_core_enable_video_display(pauline2->lc, TRUE); linphone_core_enable_video_capture(marie->lc, TRUE); linphone_core_enable_video_display(marie->lc, FALSE); marie_policy.automatically_initiate=TRUE; marie_policy.automatically_accept=TRUE; pauline_policy.automatically_initiate=TRUE; pauline_policy.automatically_accept=TRUE; linphone_core_set_video_policy(marie->lc,&marie_policy); linphone_core_set_video_policy(pauline->lc,&pauline_policy); linphone_core_set_video_policy(pauline2->lc,&pauline_policy); linphone_core_set_video_multicast_addr(marie->lc,"224.1.2.3"); linphone_core_enable_video_multicast(marie->lc,TRUE); } linphone_core_set_audio_multicast_addr(marie->lc,"224.1.2.3"); linphone_core_enable_audio_multicast(marie->lc,TRUE); lcs = ms_list_append(lcs,marie->lc); lcs = ms_list_append(lcs,pauline->lc); lcs = ms_list_append(lcs,pauline2->lc); /* Marie calls Pauline, and after the call has rung, transitions to an early_media session */ linphone_core_invite_address(marie->lc, pauline->identity); CU_ASSERT_TRUE(wait_for_list(lcs, &pauline->stat.number_of_LinphoneCallIncomingReceived,1,3000)); CU_ASSERT_TRUE(wait_for_list(lcs, &marie->stat.number_of_LinphoneCallOutgoingRinging,1,1000)); if (linphone_core_inc_invite_pending(pauline->lc)) { /* send a 183 to initiate the early media */ if (video) { /*check video path*/ linphone_call_set_next_video_frame_decoded_callback(linphone_core_get_current_call(pauline->lc),linphone_call_cb,pauline->lc); } linphone_core_accept_early_media(pauline->lc, linphone_core_get_current_call(pauline->lc)); CU_ASSERT_TRUE( wait_for_list(lcs, &pauline->stat.number_of_LinphoneCallIncomingEarlyMedia,1,2000) ); CU_ASSERT_TRUE( wait_for_list(lcs, &marie->stat.number_of_LinphoneCallOutgoingEarlyMedia,1,2000) ); if (linphone_core_inc_invite_pending(pauline2->lc)) { /* send a 183 to initiate the early media */ if (video) { /*check video path*/ linphone_call_set_next_video_frame_decoded_callback(linphone_core_get_current_call(pauline2->lc),linphone_call_cb,pauline2->lc); } linphone_core_accept_early_media(pauline2->lc, linphone_core_get_current_call(pauline2->lc)); CU_ASSERT_TRUE( wait_for_list(lcs, &pauline2->stat.number_of_LinphoneCallIncomingEarlyMedia,1,2000) ); } wait_for_list(lcs, &dummy, 1, 3000); CU_ASSERT_TRUE(linphone_call_get_audio_stats(linphone_core_get_current_call(pauline->lc))->download_bandwidth>70); CU_ASSERT_TRUE(linphone_call_get_audio_stats(linphone_core_get_current_call(pauline->lc))->download_bandwidth<90); CU_ASSERT_TRUE(linphone_call_get_audio_stats(linphone_core_get_current_call(pauline2->lc))->download_bandwidth>70); CU_ASSERT_TRUE(linphone_call_get_audio_stats(linphone_core_get_current_call(pauline2->lc))->download_bandwidth<90); if (video) { CU_ASSERT_TRUE( wait_for_list(lcs,&pauline->stat.number_of_IframeDecoded,1,2000)); CU_ASSERT_TRUE( wait_for_list(lcs,&pauline2->stat.number_of_IframeDecoded,1,2000)); } linphone_core_accept_call(pauline->lc, linphone_core_get_current_call(pauline->lc)); CU_ASSERT_TRUE(wait_for_list(lcs, &marie->stat.number_of_LinphoneCallConnected, 1,1000)); CU_ASSERT_TRUE(wait_for_list(lcs, &marie->stat.number_of_LinphoneCallStreamsRunning, 1,1000)); linphone_core_update_call( pauline->lc , linphone_core_get_current_call(pauline->lc) , linphone_call_get_current_params(linphone_core_get_current_call(pauline->lc))); CU_ASSERT_TRUE(wait_for_list(lcs, &marie->stat.number_of_LinphoneCallStreamsRunning, 2,1000)); end_call(marie,pauline); } ms_free(lcs); linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); linphone_core_manager_destroy(pauline2); leaked_objects=belle_sip_object_get_object_count()-begin; CU_ASSERT_EQUAL(leaked_objects,0); if (leaked_objects>0){ belle_sip_object_dump_active_objects(); } belle_sip_object_enable_leak_detector(FALSE); }
void test_linkedlist_gets() { CPLinkedListRef list; CPLinkedListItemRef item0; CPLinkedListItemRef item1; CPLinkedListItemRef item2; // Add 1 item _test_linkedlist_total_item_count = 0; list = CPLinkedListCreate(offsetof(CPLinkedListItem, prevItem), offsetof(CPLinkedListItem, nextItem)); CU_ASSERT(list != NULL); CU_ASSERT(CPLinkedListGetCount(list) == 0); CU_ASSERT(CPLinkedListGetHead(list) == NULL); CU_ASSERT(CPLinkedListGetTail(list) == NULL); item0 = CPLinkedListItemCreate(); CU_ASSERT(item0 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 1); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item0)); CU_ASSERT(CPLinkedListPrevItem(list, item0) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item0) == NULL); CU_ASSERT(CPLinkedListGetCount(list) == 1); CU_ASSERT(CPLinkedListGetHead(list) == item0); CU_ASSERT(CPLinkedListGetTail(list) == item0); CPLinkedListRemoveItem(list, item0); CU_ASSERT(CPLinkedListPrevItem(list, item0) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item0) == NULL); CU_ASSERT(CPLinkedListGetCount(list) == 0); CU_ASSERT(CPLinkedListGetHead(list) == NULL); CU_ASSERT(CPLinkedListGetTail(list) == NULL); CPRelease(item0); CPRelease(list); CU_ASSERT(_test_linkedlist_total_item_count == 0); _test_linkedlist_total_item_count = 0; // Add 2 items _test_linkedlist_total_item_count = 0; list = CPLinkedListCreate(offsetof(CPLinkedListItem, prevItem), offsetof(CPLinkedListItem, nextItem)); CU_ASSERT(list != NULL); CU_ASSERT(CPLinkedListGetCount(list) == 0); CU_ASSERT(CPLinkedListGetHead(list) == NULL); CU_ASSERT(CPLinkedListGetTail(list) == NULL); item0 = CPLinkedListItemCreate(); CU_ASSERT(item0 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 1); item1 = CPLinkedListItemCreate(); CU_ASSERT(item1 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 2); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item0)); CU_ASSERT(CPLinkedListPrevItem(list, item0) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item0) == NULL); CU_ASSERT(CPLinkedListPrevItem(list, item1) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item1) == NULL); CU_ASSERT(CPLinkedListGetCount(list) == 1); CU_ASSERT(CPLinkedListGetHead(list) == item0); CU_ASSERT(CPLinkedListGetTail(list) == item0); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item1)); CU_ASSERT(CPLinkedListPrevItem(list, item0) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item0) == item1); CU_ASSERT(CPLinkedListPrevItem(list, item1) == item0); CU_ASSERT(CPLinkedListNextItem(list, item1) == NULL); CU_ASSERT(CPLinkedListGetCount(list) == 2); CU_ASSERT(CPLinkedListGetHead(list) == item0); CU_ASSERT(CPLinkedListGetTail(list) == item1); CPLinkedListRemoveItem(list, item1); CU_ASSERT(CPLinkedListPrevItem(list, item0) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item0) == NULL); CU_ASSERT(CPLinkedListPrevItem(list, item1) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item1) == NULL); CU_ASSERT(CPLinkedListGetCount(list) == 1); CU_ASSERT(CPLinkedListGetHead(list) == item0); CU_ASSERT(CPLinkedListGetTail(list) == item0); CPLinkedListRemoveItem(list, item0); CU_ASSERT(CPLinkedListPrevItem(list, item0) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item0) == NULL); CU_ASSERT(CPLinkedListGetCount(list) == 0); CU_ASSERT(CPLinkedListGetHead(list) == NULL); CU_ASSERT(CPLinkedListGetTail(list) == NULL); CPRelease(item1); CPRelease(item0); CPRelease(list); CU_ASSERT(_test_linkedlist_total_item_count == 0); _test_linkedlist_total_item_count = 0; // Add 3 and remove out of order _test_linkedlist_total_item_count = 0; list = CPLinkedListCreate(offsetof(CPLinkedListItem, prevItem), offsetof(CPLinkedListItem, nextItem)); CU_ASSERT(list != NULL); CU_ASSERT(CPLinkedListGetCount(list) == 0); CU_ASSERT(CPLinkedListGetHead(list) == NULL); CU_ASSERT(CPLinkedListGetTail(list) == NULL); item0 = CPLinkedListItemCreate(); CU_ASSERT(item0 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 1); item1 = CPLinkedListItemCreate(); CU_ASSERT(item1 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 2); item2 = CPLinkedListItemCreate(); CU_ASSERT(item2 != NULL); CU_ASSERT(_test_linkedlist_total_item_count == 3); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item0)); CU_ASSERT(CPLinkedListPrevItem(list, item0) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item0) == NULL); CU_ASSERT(CPLinkedListPrevItem(list, item1) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item1) == NULL); CU_ASSERT(CPLinkedListPrevItem(list, item2) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item2) == NULL); CU_ASSERT(CPLinkedListGetCount(list) == 1); CU_ASSERT(CPLinkedListGetHead(list) == item0); CU_ASSERT(CPLinkedListGetTail(list) == item0); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item1)); CU_ASSERT(CPLinkedListPrevItem(list, item0) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item0) == item1); CU_ASSERT(CPLinkedListPrevItem(list, item1) == item0); CU_ASSERT(CPLinkedListNextItem(list, item1) == NULL); CU_ASSERT(CPLinkedListPrevItem(list, item2) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item2) == NULL); CU_ASSERT(CPLinkedListGetCount(list) == 2); CU_ASSERT(CPLinkedListGetHead(list) == item0); CU_ASSERT(CPLinkedListGetTail(list) == item1); CU_ASSERT_TRUE(CPLinkedListAddItem(list, item2)); CU_ASSERT(CPLinkedListPrevItem(list, item0) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item0) == item1); CU_ASSERT(CPLinkedListPrevItem(list, item1) == item0); CU_ASSERT(CPLinkedListNextItem(list, item1) == item2); CU_ASSERT(CPLinkedListPrevItem(list, item2) == item1); CU_ASSERT(CPLinkedListNextItem(list, item2) == NULL); CU_ASSERT(CPLinkedListGetCount(list) == 3); CU_ASSERT(CPLinkedListGetHead(list) == item0); CU_ASSERT(CPLinkedListGetTail(list) == item2); CPLinkedListRemoveItem(list, item1); CU_ASSERT(CPLinkedListPrevItem(list, item0) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item0) == item2); CU_ASSERT(CPLinkedListPrevItem(list, item1) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item1) == NULL); CU_ASSERT(CPLinkedListPrevItem(list, item2) == item0); CU_ASSERT(CPLinkedListNextItem(list, item2) == NULL); CU_ASSERT(CPLinkedListGetCount(list) == 2); CU_ASSERT(CPLinkedListGetHead(list) == item0); CU_ASSERT(CPLinkedListGetTail(list) == item2); CPLinkedListRemoveItem(list, item0); CU_ASSERT(CPLinkedListPrevItem(list, item0) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item0) == NULL); CU_ASSERT(CPLinkedListPrevItem(list, item2) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item2) == NULL); CU_ASSERT(CPLinkedListGetCount(list) == 1); CU_ASSERT(CPLinkedListGetHead(list) == item2); CU_ASSERT(CPLinkedListGetTail(list) == item2); CPLinkedListRemoveItem(list, item2); CU_ASSERT(CPLinkedListPrevItem(list, item2) == NULL); CU_ASSERT(CPLinkedListNextItem(list, item2) == NULL); CU_ASSERT(CPLinkedListGetCount(list) == 0); CU_ASSERT(CPLinkedListGetHead(list) == NULL); CU_ASSERT(CPLinkedListGetTail(list) == NULL); CPRelease(item2); CPRelease(item1); CPRelease(item0); CPRelease(list); CU_ASSERT(_test_linkedlist_total_item_count == 0); _test_linkedlist_total_item_count = 0; }
void test_Empty(void) { CU_ASSERT_TRUE(Empty(getEmptyString())); CU_ASSERT_FALSE(Empty(getTestString())); }
static void test_ctx(const struct sockaddr *addr1, uint32_t addrlen1, const struct sockaddr *addr2, uint32_t addrlen2, int isdgram, int israw, int withsockcb, int withsendcb) { int res = 0; struct test_data data; struct pomp_loop *loop = NULL; struct pomp_conn *conn = NULL; struct pomp_msg *msg = NULL; int fd = -1; uint32_t i = 0, j = 0; struct pomp_buffer *buf = NULL; memset(&data, 0, sizeof(data)); data.isdgram = isdgram; data.israw = israw; data.srv.addr = addr1; data.srv.addrlen = addrlen1; data.cli.addr = addr2; data.cli.addrlen = addrlen2; msg = pomp_msg_new(); CU_ASSERT_PTR_NOT_NULL_FATAL(msg); /* Create context */ data.srv.ctx = pomp_ctx_new(&test_event_cb_t, &data); CU_ASSERT_PTR_NOT_NULL_FATAL(data.srv.ctx); if (israw) { res = pomp_ctx_set_raw(data.srv.ctx, &test_ctx_raw_cb); CU_ASSERT_EQUAL(res, 0); } if (withsockcb) { res = pomp_ctx_set_socket_cb(data.srv.ctx, &test_ctx_socket_cb); CU_ASSERT_EQUAL(res, 0); } if (withsendcb) { res = pomp_ctx_set_send_cb(data.srv.ctx, &test_ctx_send_cb); CU_ASSERT_EQUAL(res, 0); } /* Create context without callback */ data.cli.ctx = pomp_ctx_new(NULL, &data); CU_ASSERT_PTR_NOT_NULL_FATAL(data.cli.ctx); res = pomp_ctx_destroy(data.cli.ctx); CU_ASSERT_EQUAL(res, 0); /* Invalid create (NULL 3nd arg) */ data.cli.ctx = pomp_ctx_new_with_loop(NULL, &data, NULL); CU_ASSERT_PTR_NULL(data.cli.ctx); data.cli.ctx = pomp_ctx_new_with_loop(&test_event_cb_t, &data, NULL); CU_ASSERT_PTR_NULL(data.cli.ctx); /* Create 2nd context */ data.cli.ctx = pomp_ctx_new(&test_event_cb_t, &data); CU_ASSERT_PTR_NOT_NULL_FATAL(data.cli.ctx); if (israw) { res = pomp_ctx_set_raw(data.cli.ctx, &test_ctx_raw_cb); CU_ASSERT_EQUAL(res, 0); } if (withsockcb) { res = pomp_ctx_set_socket_cb(data.cli.ctx, &test_ctx_socket_cb); CU_ASSERT_EQUAL(res, 0); } if (withsendcb) { res = pomp_ctx_set_send_cb(data.cli.ctx, &test_ctx_send_cb); CU_ASSERT_EQUAL(res, 0); } if (!isdgram) { /* Invalid start server (NULL param) */ res = pomp_ctx_listen(NULL, addr1, addrlen1); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_listen(data.srv.ctx, NULL, addrlen1); CU_ASSERT_EQUAL(res, -EINVAL); /* Start as server 1st context */ res = pomp_ctx_listen(data.srv.ctx, addr1, addrlen1); CU_ASSERT_EQUAL(res, 0); /* Invalid start server (busy) */ res = pomp_ctx_listen(data.srv.ctx, addr1, addrlen1); CU_ASSERT_EQUAL(res, -EBUSY); } else { /* Invalid bind (NULL param) */ res = pomp_ctx_bind(NULL, addr1, addrlen1); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_bind(data.srv.ctx, NULL, addrlen1); CU_ASSERT_EQUAL(res, -EINVAL); /* Bind 1st context */ res = pomp_ctx_bind(data.srv.ctx, addr1, addrlen1); CU_ASSERT_EQUAL(res, 0); /* Invalid bind (busy) */ res = pomp_ctx_bind(data.srv.ctx, addr1, addrlen1); CU_ASSERT_EQUAL(res, -EBUSY); } if (!isdgram) { /* Invalid start client (NULL param) */ res = pomp_ctx_connect(NULL, addr2, addrlen2); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_connect(data.cli.ctx, NULL, addrlen2); CU_ASSERT_EQUAL(res, -EINVAL); /* Start as client 2nd context */ res = pomp_ctx_connect(data.cli.ctx, addr2, addrlen2); CU_ASSERT_EQUAL(res, 0); /* Invalid start client (busy) */ res = pomp_ctx_connect(data.cli.ctx, addr2, addrlen2); CU_ASSERT_EQUAL(res, -EBUSY); } else { /* Invalid bind (NULL param) */ res = pomp_ctx_bind(NULL, addr2, addrlen2); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_bind(data.cli.ctx, NULL, addrlen2); CU_ASSERT_EQUAL(res, -EINVAL); /* Bind 2nd context */ res = pomp_ctx_bind(data.cli.ctx, addr2, addrlen2); CU_ASSERT_EQUAL(res, 0); /* Invalid bind (busy) */ res = pomp_ctx_bind(data.cli.ctx, addr2, addrlen2); CU_ASSERT_EQUAL(res, -EBUSY); } /* Invalid set raw */ res = pomp_ctx_set_raw(NULL, &test_ctx_raw_cb); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_set_raw(data.srv.ctx, NULL); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_set_raw(data.srv.ctx, &test_ctx_raw_cb); CU_ASSERT_EQUAL(res, -EBUSY); /* Invalid set socket cb */ res = pomp_ctx_set_socket_cb(NULL, &test_ctx_socket_cb); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_set_socket_cb(data.srv.ctx, NULL); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_set_socket_cb(data.srv.ctx, &test_ctx_socket_cb); CU_ASSERT_EQUAL(res, -EBUSY); /* Invalid set send cb */ res = pomp_ctx_set_send_cb(NULL, &test_ctx_send_cb); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_set_send_cb(data.srv.ctx, NULL); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_set_send_cb(data.srv.ctx, &test_ctx_send_cb); CU_ASSERT_EQUAL(res, -EBUSY); /* Invalid get loop (NULL param) */ loop = pomp_ctx_get_loop(NULL); CU_ASSERT_PTR_NULL(loop); /* Invalid get fd (NULL param) */ fd = pomp_ctx_get_fd(NULL); CU_ASSERT_EQUAL(fd, -EINVAL); /* Get loop and fd */ loop = pomp_ctx_get_loop(data.srv.ctx); CU_ASSERT_PTR_NOT_NULL(loop); fd = pomp_ctx_get_fd(data.srv.ctx); #ifdef POMP_HAVE_LOOP_EPOLL CU_ASSERT_TRUE(fd >= 0); #else CU_ASSERT_EQUAL(fd, -ENOSYS); #endif /* Invalid process fd (NULL param) */ res = pomp_ctx_process_fd(NULL); CU_ASSERT_EQUAL(res, -EINVAL); /* Keepalive settings */ if (!isdgram) { /* TODO: check that it actually does something */ res = pomp_ctx_setup_keepalive(data.srv.ctx, 0, 0, 0, 0); CU_ASSERT_EQUAL(res, 0); res = pomp_ctx_setup_keepalive(data.srv.ctx, 1, 5, 2, 1); CU_ASSERT_EQUAL(res, 0); res = pomp_ctx_setup_keepalive(NULL, 0, 0, 0, 0); CU_ASSERT_EQUAL(res, -EINVAL); } /* Run contexts (they shall connect each other) */ run_ctx(data.srv.ctx, data.cli.ctx, 100); if (!isdgram) { CU_ASSERT_EQUAL(data.connection, 2); /* Get remote connections */ conn = pomp_ctx_get_next_conn(data.srv.ctx, NULL); CU_ASSERT_PTR_NOT_NULL(conn); conn = pomp_ctx_get_next_conn(data.srv.ctx, conn); CU_ASSERT_PTR_NULL(conn); conn = pomp_ctx_get_conn(data.cli.ctx); CU_ASSERT_PTR_NOT_NULL(conn); /* Invalid get remote connections */ conn = pomp_ctx_get_next_conn(data.cli.ctx, NULL); CU_ASSERT_PTR_NULL(conn); conn = pomp_ctx_get_conn(data.srv.ctx); CU_ASSERT_PTR_NULL(conn); conn = pomp_ctx_get_next_conn(NULL, NULL); CU_ASSERT_PTR_NULL(conn); conn = pomp_ctx_get_conn(NULL); CU_ASSERT_PTR_NULL(conn); } /* Exchange some message */ if (!isdgram) { if (!israw) { res = pomp_ctx_send(data.srv.ctx, 1, "%s", "hello1->2"); CU_ASSERT_EQUAL(res, 0); res = pomp_ctx_send(data.cli.ctx, 1, "%s", "hello2->1"); CU_ASSERT_EQUAL(res, 0); /* Invalid send (NULL param) */ res = pomp_ctx_send(NULL, 1, "%s", "hello1->2"); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_send_msg(data.srv.ctx, NULL); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid send (bad format) */ res = pomp_ctx_send(data.srv.ctx, 1, "%o", 1); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_conn_send(pomp_ctx_get_conn(data.cli.ctx), 1, "%o", 1); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid send to (bad type) */ res = pomp_ctx_send_msg_to(data.cli.ctx, msg, addr1, addrlen1); CU_ASSERT_EQUAL(res, -EINVAL); } else { buf = pomp_buffer_new(32); CU_ASSERT_PTR_NOT_NULL_FATAL(buf); memcpy(buf->data, "Hello World !!!", 15); buf->len = 15; res = pomp_ctx_send_raw_buf(data.srv.ctx, buf); data.datasent += 15; CU_ASSERT_EQUAL(res, 0); res = pomp_ctx_send_raw_buf(data.cli.ctx, buf); data.datasent += 15; CU_ASSERT_EQUAL(res, 0); /* Invalid send (NULL param) */ res = pomp_ctx_send_raw_buf(NULL, buf); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_send_raw_buf(data.srv.ctx, NULL); CU_ASSERT_EQUAL(res, -EINVAL); pomp_buffer_unref(buf); buf = NULL; } } else { if (!israw) { res = pomp_msg_clear(msg); CU_ASSERT_EQUAL(res, 0); res = pomp_msg_write(msg, 1, "%s", "hello1->2"); CU_ASSERT_EQUAL(res, 0); res = pomp_ctx_send_msg_to(data.srv.ctx, msg, addr2, addrlen2); CU_ASSERT_EQUAL(res, 0); res = pomp_msg_clear(msg); CU_ASSERT_EQUAL(res, 0); res = pomp_msg_write(msg, 1, "%s", "hello2->1"); CU_ASSERT_EQUAL(res, 0); res = pomp_ctx_send_msg_to(data.cli.ctx, msg, addr1, addrlen1); CU_ASSERT_EQUAL(res, 0); /* Invalid send (not connected) */ res = pomp_ctx_send_msg(data.cli.ctx, msg); CU_ASSERT_EQUAL(res, -ENOTCONN); /* Invalid send to (NULL param) */ res = pomp_ctx_send_msg_to(NULL, msg, addr1, addrlen1); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_send_msg_to(data.cli.ctx, NULL, addr1, addrlen1); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_send_msg_to(data.cli.ctx, msg, NULL, addrlen1); CU_ASSERT_EQUAL(res, -EINVAL); } else { buf = pomp_buffer_new(32); CU_ASSERT_PTR_NOT_NULL_FATAL(buf); memcpy(buf->data, "Hello World !!!", 15); buf->len = 15; res = pomp_ctx_send_raw_buf_to(data.srv.ctx, buf, addr2, addrlen2); CU_ASSERT_EQUAL(res, 0); data.datasent += 15; res = pomp_ctx_send_raw_buf_to(data.cli.ctx, buf, addr1, addrlen1); CU_ASSERT_EQUAL(res, 0); data.datasent += 15; /* Invalid send (not connected) */ res = pomp_ctx_send_raw_buf(data.cli.ctx, buf); CU_ASSERT_EQUAL(res, -ENOTCONN); /* Invalid send to (NULL param) */ res = pomp_ctx_send_raw_buf_to(NULL, buf, addr1, addrlen1); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_send_raw_buf_to(data.cli.ctx, NULL, addr1, addrlen1); CU_ASSERT_EQUAL(res, -EINVAL); res = pomp_ctx_send_raw_buf_to(data.cli.ctx, buf, NULL, addrlen1); CU_ASSERT_EQUAL(res, -EINVAL); pomp_buffer_unref(buf); buf = NULL; } } /* Check no send callback directly called by the sending function. */ CU_ASSERT_EQUAL(data.sendcount, 0); /* Run contexts (they shall have answered each other) */ run_ctx(data.srv.ctx, data.cli.ctx, 100); if (!israw) { CU_ASSERT_EQUAL(data.msg, 4); if (withsendcb) CU_ASSERT_EQUAL(data.sendcount, 4); } else { if (data.isdgram) CU_ASSERT_EQUAL(data.buf, 2); CU_ASSERT_EQUAL(data.dataread, data.datasent); if (withsendcb) CU_ASSERT_EQUAL(data.sendcount, 2); } /* Dummy run */ res = pomp_ctx_wait_and_process(data.srv.ctx, 100); CU_ASSERT_EQUAL(res, -ETIMEDOUT); res = pomp_ctx_wait_and_process(NULL, 100); CU_ASSERT_EQUAL(res, -EINVAL); /* Wakeup */ res = pomp_ctx_wakeup(data.srv.ctx); CU_ASSERT_EQUAL(res, 0); res = pomp_ctx_wait_and_process(data.srv.ctx, 100); CU_ASSERT_EQUAL(res, 0); /* Invalid wakeup (NULL param) */ res = pomp_ctx_wakeup(NULL); CU_ASSERT_EQUAL(res, -EINVAL); /* Overflow server by writing on client side without running loop */ if (!isdgram) { for (i = 0; i < 1024; i++) { if (buf == NULL) buf = pomp_buffer_new(1024); CU_ASSERT_PTR_NOT_NULL_FATAL(buf); for (j = 0; j < 1024; j++) buf->data[j] = rand() % 255; buf->len = 1024; if (!israw) { res = pomp_ctx_send(data.cli.ctx, 3, "%p%u", buf->data, 1024); CU_ASSERT_EQUAL(res, 0); } else { res = pomp_ctx_send_raw_buf(data.cli.ctx, buf); CU_ASSERT_EQUAL(res, 0); } if (buf->refcount > 1) { pomp_buffer_unref(buf); buf = NULL; } } if (buf != NULL) { pomp_buffer_unref(buf); buf = NULL; } /* Run contexts (to unlock writes) */ run_ctx(data.srv.ctx, data.cli.ctx, 100); if (!israw) CU_ASSERT_EQUAL(data.msg, 4 + 1024); } /* Recursive send */ if (withsendcb) { /* reset counts */ data.buf = 0; data.msg = 0; data.sendcount = 0; data.datasent = 0; data.dataread = 0; /* Enable recursive send. */ data.srv.recurs_send_enabled = 1; send_msg(&data, &data.srv, &data.cli, "srv_to_cli"); /* Check no send callback directly called by the sending function. */ CU_ASSERT_EQUAL(data.sendcount, 0); run_ctx(data.srv.ctx, data.cli.ctx, 100); if (!israw) { CU_ASSERT_EQUAL(data.msg, 2); CU_ASSERT_EQUAL(data.sendcount, 2); } else { if (data.isdgram) CU_ASSERT_EQUAL(data.buf, 2); CU_ASSERT_EQUAL(data.dataread, data.datasent); CU_ASSERT_EQUAL(data.sendcount, 2); } /* Check client recursive send during server disconnection */ data.cli.recurs_send_enabled = 1; send_msg(&data, &data.cli, &data.srv, "cli_to_srv"); } /* Disconnect client from server */ if (!isdgram) { if (withsendcb) { /* Check recursive write during disconnection */ data.srv.recurs_send_enabled = 1; data.isdisconnecting = 1; } res = pomp_conn_disconnect(pomp_ctx_get_next_conn(data.srv.ctx, NULL)); CU_ASSERT_EQUAL(res, 0); /* Check recursive send callback by disconnection */ if (withsendcb) CU_ASSERT_EQUAL(data.sendcount, 2); } /* Run contexts (they shall disconnect each other) */ run_ctx(data.srv.ctx, data.cli.ctx, 100); pomp_ctx_process_fd(data.cli.ctx); if (!isdgram) { CU_ASSERT_EQUAL(data.disconnection, 2); if (!israw) { /* Invalid send (client not connected) */ res = pomp_ctx_send(data.cli.ctx, 1, "%s", "hello2->1"); CU_ASSERT_EQUAL(res, -ENOTCONN); } else { /* TODO */ } } /* Invalid destroy (NULL param) */ res = pomp_ctx_destroy(NULL); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid destroy (busy) */ res = pomp_ctx_destroy(data.srv.ctx); CU_ASSERT_EQUAL(res, -EBUSY); /* Stop server */ res = pomp_ctx_stop(data.srv.ctx); CU_ASSERT_EQUAL(res, 0); /* Stop client */ res = pomp_ctx_stop(data.cli.ctx); CU_ASSERT_EQUAL(res, 0); /* Invalid stop (NULL param) */ res = pomp_ctx_stop(NULL); CU_ASSERT_EQUAL(res, -EINVAL); /* Stop when already done */ res = pomp_ctx_stop(data.srv.ctx); CU_ASSERT_EQUAL(res, 0); /* Destroy contexts */ res = pomp_ctx_destroy(data.srv.ctx); CU_ASSERT_EQUAL(res, 0); res = pomp_ctx_destroy(data.cli.ctx); CU_ASSERT_EQUAL(res, 0); res = pomp_msg_destroy(msg); CU_ASSERT_EQUAL(res, 0); }
/* Teste numero impar */ void teste_DT_VerificaParidade_Impar(void) { int resultado; resultado = VerificaParidade(3); CU_ASSERT_TRUE( resultado ); }
static LinphoneCoreManager* configure_lcm(void) { LinphoneCoreManager *mgr=linphone_core_manager_new( "multi_account_lrc"); stats *counters=&mgr->stat; CU_ASSERT_TRUE(wait_for(mgr->lc,mgr->lc,&counters->number_of_LinphoneRegistrationOk,ms_list_size(linphone_core_get_proxy_config_list(mgr->lc)))); return mgr; }
/* Teste numero zero */ void teste_DT_VerificaParidade_Zero(void) { int resultado; resultado = VerificaParidade(0); CU_ASSERT_TRUE( !resultado ); }
void teste_DT_verificaNovaTela_invis () { Tela teste; teste = nova_tela(); CU_ASSERT_TRUE(!teste->bloco[15][8].tipo); }
/* Teste letra maiuscula */ void teste_DT_ProximaLetra_Maiuscula(void){ char resultado; resultado = ProximaLetra('A'); CU_ASSERT_TRUE( resultado == 'B' ); }
void testDstLen() { CU_ASSERT_EQUAL(dstlen(0), 1); CU_ASSERT_TRUE(dstlen(strlen("a ab ab")) > strlen("aab aab")); }
/* Teste letra maiuscula */ void teste_DT_ProximaLetra_Minuscula(void) { char resultado; resultado = ProximaLetra('d'); CU_ASSERT_TRUE( resultado == 'e' ); }
void test_multiPattern(void) { HObs hObs = NULL; RU8 pattern1[] = { 0x01, 0x02, 0x03, 0x04 }; RU8 pattern2[] = { 0x01, 0x02, 0x03, 0x06 }; RU8 pattern3[] = { 0x01, 0x02, 0x06, 0x04 }; RU8 pattern4[] = { 0xEF, 0x02, 0x03, 0x04 }; RU8 buffer1[] = { 0x02, 0x04, 0xFF, 0xEF, 0x01, 0x02, 0x03, 0x04 }; RU8 buffer2[] = { 0x02, 0x04, 0xFF, 0xEF, 0x01, 0x02, 0x03, 0x04, 0xEE, 0x6F }; RU8 buffer3[] = { 0x02, 0x04, 0xFF, 0xEF, 0x01, 0x02, 0x01, 0x04, 0xEE, 0x6F }; RU8 buffer4[] = { 0x02, 0x04, 0xFF, 0xEF, 0x01, 0x02, 0x03, 0x04, 0xEE, 0x6F, 0x01, 0x02, 0x03, 0x04 }; RU8 buffer5[] = { 0x02, 0x04, 0xFF, 0xEF, 0x02, 0x03, 0x04, 0x04, 0xEE, 0x6F, 0x01, 0x02, 0x03, 0x04 }; RU8 buffer6[] = { 0x02, 0x04, 0xFF, 0xEF, 0x02, 0x03, 0x04, 0x04, 0xEE, 0x6F, 0x01, 0x02, 0x03, 0x04, 0x01, 0x02, 0x06, 0x04 }; RU32 context1 = 0; RU32 context2 = 0; RU32 context3 = 0; RU32 context4 = 0; PVOID hitCtx = NULL; RU8* hitLoc = NULL; hObs = obsLib_new( 0, 0 ); CU_ASSERT_TRUE_FATAL( rpal_memory_isValid( hObs ) ); CU_ASSERT_TRUE_FATAL( obsLib_addPattern( hObs, (RPU8)&pattern1, sizeof( pattern1 ), &context1 ) ); CU_ASSERT_TRUE_FATAL( obsLib_addPattern( hObs, (RPU8)&pattern2, sizeof( pattern2 ), &context2 ) ); CU_ASSERT_TRUE_FATAL( obsLib_addPattern( hObs, (RPU8)&pattern3, sizeof( pattern3 ), &context3 ) ); CU_ASSERT_TRUE_FATAL( obsLib_addPattern( hObs, (RPU8)&pattern4, sizeof( pattern4 ), &context4 ) ); // 1 pattern found end of buffer CU_ASSERT_TRUE_FATAL( obsLib_setTargetBuffer( hObs, buffer1, sizeof( buffer1 ) ) ); CU_ASSERT_TRUE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); CU_ASSERT_EQUAL( hitCtx, &context1 ); CU_ASSERT_EQUAL( hitLoc, buffer1 + sizeof( buffer1 ) - 4 ); CU_ASSERT_FALSE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); // 1 pattern found middle of buffer CU_ASSERT_TRUE_FATAL( obsLib_setTargetBuffer( hObs, buffer2, sizeof( buffer2 ) ) ); CU_ASSERT_TRUE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); CU_ASSERT_EQUAL( hitCtx, &context1 ); CU_ASSERT_EQUAL( hitLoc, buffer2 + sizeof( buffer2 ) - 6 ); CU_ASSERT_FALSE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); // 0 pattern found CU_ASSERT_TRUE_FATAL( obsLib_setTargetBuffer( hObs, buffer3, sizeof( buffer3 ) ) ); CU_ASSERT_FALSE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); // 2 pattern found end and middle of buffer CU_ASSERT_TRUE_FATAL( obsLib_setTargetBuffer( hObs, buffer4, sizeof( buffer4 ) ) ); CU_ASSERT_TRUE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); CU_ASSERT_EQUAL( hitCtx, &context1 ); CU_ASSERT_EQUAL( hitLoc, buffer4 + sizeof( buffer4 ) - 10 ); CU_ASSERT_TRUE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); CU_ASSERT_EQUAL( hitCtx, &context1 ); CU_ASSERT_EQUAL( hitLoc, buffer4 + sizeof( buffer4 ) - 4 ); CU_ASSERT_FALSE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); // Multi 1 CU_ASSERT_TRUE_FATAL( obsLib_setTargetBuffer( hObs, buffer5, sizeof( buffer5 ) ) ); CU_ASSERT_TRUE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); CU_ASSERT_EQUAL( hitCtx, &context4 ); CU_ASSERT_EQUAL( hitLoc, buffer5 + 3 ); CU_ASSERT_TRUE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); CU_ASSERT_EQUAL( hitCtx, &context1 ); CU_ASSERT_EQUAL( hitLoc, buffer5 + sizeof( buffer5 ) - 4 ); CU_ASSERT_FALSE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); // Multi 2 CU_ASSERT_TRUE_FATAL( obsLib_setTargetBuffer( hObs, buffer6, sizeof( buffer6 ) ) ); CU_ASSERT_TRUE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); CU_ASSERT_EQUAL( hitCtx, &context4 ); CU_ASSERT_EQUAL( hitLoc, buffer6 + 3 ); CU_ASSERT_TRUE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); CU_ASSERT_EQUAL( hitCtx, &context1 ); CU_ASSERT_EQUAL( hitLoc, buffer6 + sizeof( buffer6 ) - 8 ); CU_ASSERT_TRUE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); CU_ASSERT_EQUAL( hitCtx, &context3 ); CU_ASSERT_EQUAL( hitLoc, buffer6 + sizeof( buffer6 ) - 4 ); CU_ASSERT_FALSE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) ); obsLib_free( hObs ); }
static void test_loop(void) { int res = 0; HANDLE htimer1 = NULL, htimer2 = NULL, htimer3 = NULL; struct test_data data; struct pomp_loop *loop = NULL; struct pomp_fd *pfd = NULL; memset(&data, 0, sizeof(data)); /* Create loop */ loop = pomp_loop_new(); CU_ASSERT_PTR_NOT_NULL_FATAL(loop); /* Create timers for testing */ htimer1 = setup_timer_win32(100, 500); CU_ASSERT_PTR_NOT_NULL_FATAL(htimer1); htimer2 = setup_timer_win32(50, 500); CU_ASSERT_PTR_NOT_NULL_FATAL(htimer2); htimer3 = setup_timer_win32(150, 500); CU_ASSERT_PTR_NOT_NULL_FATAL(htimer3); /* Add timer in loop */ pfd = pomp_loop_win32_add_pfd_with_hevt(loop, htimer1, &timer_win32_cb, &data); CU_ASSERT_PTR_NOT_NULL(pfd); /* Add 2nd and 3rd timer in loop */ pfd = pomp_loop_win32_add_pfd_with_hevt(loop, htimer2, &timer_win32_cb, &data); CU_ASSERT_PTR_NOT_NULL(pfd); pfd = pomp_loop_win32_add_pfd_with_hevt(loop, htimer3, &timer_win32_cb, &data); CU_ASSERT_PTR_NOT_NULL(pfd); /* Run loop with different timeout first one should have all timers) */ res = pomp_loop_wait_and_process(loop, 500); CU_ASSERT_EQUAL(res, 0); res = pomp_loop_wait_and_process(loop, 0); CU_ASSERT_TRUE(res == -ETIMEDOUT || res == 0); res = pomp_loop_wait_and_process(loop, -1); CU_ASSERT_EQUAL(res, 0); /* Invalid run (NULL param) */ res = pomp_loop_wait_and_process(NULL, 0); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid destroy (NULL param) */ res = pomp_loop_destroy(NULL); CU_ASSERT_EQUAL(res, -EINVAL); /* Invalid destroy (busy) */ res = pomp_loop_destroy(loop); CU_ASSERT_EQUAL(res, -EBUSY); /* Remove timers */ pfd = pomp_loop_win32_find_pfd_by_hevt(loop, htimer1); CU_ASSERT_PTR_NOT_NULL(pfd); res = pomp_loop_remove_pfd(loop, pfd); CU_ASSERT_EQUAL(res, 0); free(pfd); pfd = pomp_loop_win32_find_pfd_by_hevt(loop, htimer2); CU_ASSERT_PTR_NOT_NULL(pfd); res = pomp_loop_remove_pfd(loop, pfd); CU_ASSERT_EQUAL(res, 0); free(pfd); pfd = pomp_loop_win32_find_pfd_by_hevt(loop, htimer3); CU_ASSERT_PTR_NOT_NULL(pfd); res = pomp_loop_remove_pfd(loop, pfd); CU_ASSERT_EQUAL(res, 0); free(pfd); /* Close timers */ res = CloseHandle(htimer1); CU_ASSERT_EQUAL(res, 1); res = CloseHandle(htimer2); CU_ASSERT_EQUAL(res, 1); res = CloseHandle(htimer3); CU_ASSERT_EQUAL(res, 1); /* Destroy loop */ res = pomp_loop_destroy(loop); CU_ASSERT_EQUAL(res, 0); }