static void test_compareStrAndNum() {
int32_t num;
CU_ASSERT_TRUE(compareStrAndNum("abcd", 1, "afgh", 1, NULL));
CU_ASSERT_TRUE(compareStrAndNum("ABCD", 4, "abcd", 4, NULL));
CU_ASSERT_TRUE(compareStrAndNum("AbCd", 3, "AbCE", 3, NULL));
CU_ASSERT_TRUE(compareStrAndNum("ABCD", 1, "a", 1, NULL));
CU_ASSERT_FALSE(compareStrAndNum("abcd", 1, "efgh", 1, NULL));
CU_ASSERT_FALSE(compareStrAndNum("ABCD", 4, "abcd", 3, NULL));
CU_ASSERT_TRUE(compareStrAndNum("abcd", 4, "abcd1", 5, NULL));
CU_ASSERT_TRUE(compareStrAndNum("abcd", 4, "abcd123", 7, NULL));
CU_ASSERT_FALSE(compareStrAndNum("abcd", 4, "abcd12A", 7, NULL));
CU_ASSERT_FALSE(compareStrAndNum("abcd", 4, "abcdB12", 7, NULL));
CU_ASSERT_FALSE(compareStrAndNum("abdd", 4, "abcd132", 7, NULL));
#define TEST_COMPARE_STR_AND_NUM(s1, l1, s2, l2, v, r) \
do { \
num = -1; \
CU_ASSERT_EQUAL(compareStrAndNum(s1, l1, s2, l2, &num),r); \
CU_ASSERT_EQUAL(num, v); \
} while(0); \
TEST_COMPARE_STR_AND_NUM("abcd", 4, "abcd", 4, -1, TRUE);
TEST_COMPARE_STR_AND_NUM("abcd", 4, "abcd1", 5, 1, TRUE);
TEST_COMPARE_STR_AND_NUM("abcd", 4, "abcd123", 7, 123, TRUE);
TEST_COMPARE_STR_AND_NUM("abcd", 4, "abcd12A", 7, -1, FALSE);
TEST_COMPARE_STR_AND_NUM("abcd", 4, "abcdB12", 7, -1, FALSE);
TEST_COMPARE_STR_AND_NUM("abdd", 4, "abcd132", 7, -1, FALSE);
}
static void subscribe_failure_handle_by_app(void) {
LinphoneCoreManager* marie = linphone_core_manager_new("marie_rc");
LinphoneCoreManager* pauline = linphone_core_manager_new("pauline_rc");
LinphoneProxyConfig* config;
LinphoneFriend* lf;
char* lf_identity=linphone_address_as_string_uri_only(pauline->identity);
linphone_core_get_default_proxy(marie->lc,&config);
CU_ASSERT_TRUE(subscribe_to_callee_presence(marie,pauline));
wait_for(marie->lc,pauline->lc,&pauline->stat.number_of_NewSubscriptionRequest,1); /*just to wait for unsubscription even if not notified*/
sal_set_recv_error(marie->lc->sal, 0); /*simulate an error*/
CU_ASSERT_TRUE(wait_for(marie->lc,pauline->lc,&marie->stat.number_of_LinphoneRegistrationProgress,2));
CU_ASSERT_EQUAL(linphone_proxy_config_get_error(config),LinphoneReasonIOError);
sal_set_recv_error(marie->lc->sal, 1);
lf = linphone_core_get_friend_by_address(marie->lc,lf_identity);
linphone_friend_edit(lf);
linphone_friend_enable_subscribes(lf,FALSE); /*disable subscription*/
linphone_friend_done(lf);
CU_ASSERT_TRUE(wait_for(marie->lc,pauline->lc,&marie->stat.number_of_LinphoneRegistrationOk,2)); /*wait for register ok*/
linphone_friend_edit(lf);
linphone_friend_enable_subscribes(lf,TRUE);
linphone_friend_done(lf);
CU_ASSERT_FALSE(wait_for(marie->lc,pauline->lc,&pauline->stat.number_of_NewSubscriptionRequest,2)); /*just to wait for unsubscription even if not notified*/
linphone_core_manager_destroy(marie);
CU_ASSERT_FALSE(wait_for(NULL,pauline->lc,&pauline->stat.number_of_NewSubscriptionRequest,3)); /*just to wait for unsubscription even if not notified*/
linphone_core_manager_destroy(pauline);
}
static void change_expires(){
LinphoneCoreManager* lcm = create_lcm();
stats* counters = &lcm->stat;
LinphoneProxyConfig* proxy_config;
register_with_refresh_base(lcm->lc,FALSE,NULL,NULL);
linphone_core_get_default_proxy(lcm->lc,&proxy_config);
linphone_proxy_config_edit(proxy_config);
reset_counters(counters); /*clear stats*/
/*nothing is supposed to arrive until done*/
CU_ASSERT_FALSE(wait_for_until(lcm->lc,lcm->lc,&counters->number_of_LinphoneRegistrationCleared,1,3000));
linphone_proxy_config_set_expires(proxy_config,3);
linphone_proxy_config_done(proxy_config);
CU_ASSERT_TRUE(wait_for(lcm->lc,lcm->lc,&counters->number_of_LinphoneRegistrationOk,1));
/*wait 2s without receive refresh*/
CU_ASSERT_FALSE(wait_for_until(lcm->lc,lcm->lc,&counters->number_of_LinphoneRegistrationOk,2,2000));
/* now, it should be ok*/
CU_ASSERT_TRUE(wait_for(lcm->lc,lcm->lc,&counters->number_of_LinphoneRegistrationOk,2));
linphone_core_manager_destroy(lcm);
}
void nomls_tests()
{
size_t first_diff = 0;
int test_result;
unchanged_users_v = apol_vector_create(free);
changed_users_v = apol_vector_create(free);
apol_vector_t *correct_unchanged_users_v = string_array_to_vector(nomls_unchanged_users);
apol_vector_t *correct_changed_users_v = string_array_to_vector(nomls_changed_users);
build_nomls_vecs();
apol_vector_sort(unchanged_users_v, compare_str, NULL);
apol_vector_sort(correct_unchanged_users_v, compare_str, NULL);
CU_ASSERT_FALSE(test_result =
apol_vector_compare(unchanged_users_v, correct_unchanged_users_v, compare_str, NULL, &first_diff));
if (test_result) {
print_test_failure(unchanged_users_v, correct_unchanged_users_v, first_diff, "Unchanged MLS Users");
}
apol_vector_sort(changed_users_v, compare_str, NULL);
apol_vector_sort(correct_changed_users_v, compare_str, NULL);
CU_ASSERT_FALSE(test_result =
apol_vector_compare(changed_users_v, correct_changed_users_v, compare_str, NULL, &first_diff));
if (test_result) {
print_test_failure(changed_users_v, correct_changed_users_v, first_diff, "Changed MLS Users");
}
apol_vector_destroy(&unchanged_users_v);
apol_vector_destroy(&changed_users_v);
apol_vector_destroy(&correct_unchanged_users_v);
apol_vector_destroy(&correct_changed_users_v);
}
static void test_string_ends_with() {
CU_ASSERT_TRUE(string_ends_with("MiArchivo.txt", "txt"));
CU_ASSERT_TRUE(string_ends_with("MiArchivo.txt", "MiArchivo.txt"));
CU_ASSERT_FALSE(string_ends_with("MiArchivo.doc", "txt"));
CU_ASSERT_FALSE(string_ends_with("MiDoc", "txt"));
CU_ASSERT_FALSE(string_ends_with("", "txt"));
}
void testNTH()
{
list_t *l = list_new();
for (int i = 0; i < 100; ++i)
{
int *x = malloc(sizeof(int));
*x = i;
list_add(l, x);
}
int *x;
for (int i = 0; i < 100; ++i)
{
CU_ASSERT(list_nth(l, i, (void **)&x));
CU_ASSERT_EQUAL(*x, i);
}
CU_ASSERT_FALSE(list_nth(l, -1, (void **)&x));
CU_ASSERT_EQUAL(x, NULL);
CU_ASSERT_FALSE(list_nth(l, 100, (void **)&x));
CU_ASSERT_EQUAL(x, NULL);
list_foreach(l, free);
list_free(l);
}
static void test_string_starts_with() {
CU_ASSERT_TRUE(string_starts_with("#Comentario", "#"));
CU_ASSERT_TRUE(string_starts_with("Comentario", "Comen"));
CU_ASSERT_FALSE(string_starts_with("Comentario", "comen"));
CU_ASSERT_FALSE(string_starts_with("Comentario", "lala"));
CU_ASSERT_FALSE(string_starts_with("", "#"));
}
/*
* From 19.1.1 SIP and SIPS URI Components
* dialog
reg./redir. Contact/
default Req.-URI To From Contact R-R/Route external
user -- o o o o o o
password -- o o o o o o
host -- m m m m m m
port (1) o - - o o o
user-param ip o o o o o o
method INVITE - - - - - o
maddr-param -- o - - o o o
ttl-param 1 o - - o - o
transp.-param (2) o - - o o o
lr-param -- o - - - o o
other-param -- o o o o o o
headers -- - - - o - o*/
void testUriComponentsChecker() {
belle_sip_uri_t* uri = belle_sip_uri_parse("sip:hostonly");
CU_ASSERT_TRUE(belle_sip_uri_check_components_from_request_uri(uri));
belle_sip_object_unref(uri);
{
belle_sip_header_from_t* header = belle_sip_header_from_parse("From: sip:linphone.org:5061");
CU_ASSERT_FALSE(belle_sip_uri_check_components_from_context(belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(header)),NULL,"From"));
belle_sip_object_unref(header);
}
{
belle_sip_header_to_t* header = belle_sip_header_to_parse("To: sip:linphone.org?header=interdit");
CU_ASSERT_FALSE(belle_sip_uri_check_components_from_context(belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(header)),NULL,"To"));
belle_sip_object_unref(header);
}
{
belle_sip_header_contact_t* header = belle_sip_header_contact_parse("Contact: <sip:linphone.org;lr>");
CU_ASSERT_FALSE(belle_sip_uri_check_components_from_context(belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(header)),"REGISTER","Contact"));
CU_ASSERT_TRUE(belle_sip_uri_check_components_from_context(belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(header)),NULL,"Contact"));
belle_sip_object_unref(header);
}
{
belle_sip_header_record_route_t* header = belle_sip_header_record_route_parse("Record-Route: <sip:linphone.org;ttl=interdit>");
CU_ASSERT_FALSE(belle_sip_uri_check_components_from_context(belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(header)),NULL,"Record-Route"));
belle_sip_object_unref(header);
}
{
belle_sip_uri_t* uri = belle_sip_uri_parse("sip:linphone.org:5061?header=toto");
CU_ASSERT_TRUE(belle_sip_uri_check_components_from_context(uri,NULL,"Any"));
belle_sip_object_unref(uri);
}
}
void test_grid_is_row_complete()
{
// Create a grid.
int numberOfRows = 4;
int numberOfColumns = 4;
TrnGrid* grid = trn_grid_new(numberOfRows, numberOfColumns);
// Last row is void only.
CU_ASSERT_FALSE( trn_grid_is_row_complete(grid,numberOfRows) );
// Last row is full.
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);
}
CU_ASSERT_TRUE( trn_grid_is_row_complete(grid,numberOfRows) );
// Last row is full except last element.
pos.rowIndex = numberOfRows-1 ;
pos.columnIndex = numberOfColumns-1 ;
trn_grid_set_cell(grid, pos, TRN_TETROMINO_VOID);
CU_ASSERT_FALSE( trn_grid_is_row_complete(grid,numberOfRows) );
}
void test_hashMap_containsValue(void) {
char * key = "key";
char * value = "value";
char * key2 = "key2";
char * value2 = "value2";
char * neValue = "notExisting";
char * key3 = "key3";
char * value3 = NULL;
hashMap_clear(map, false, false);
// Add one entry
hashMap_put(map, key, value);
// Add second entry
hashMap_put(map, key2, value2);
CU_ASSERT_TRUE(hashMap_containsValue(map, value));
CU_ASSERT_TRUE(hashMap_containsValue(map, value2));
CU_ASSERT_FALSE(hashMap_containsValue(map, neValue));
CU_ASSERT_FALSE(hashMap_containsValue(map, NULL));
// Add third entry with NULL value
hashMap_put(map, key3, value3);
CU_ASSERT_TRUE(hashMap_containsValue(map, value3));
}
static void test_is_multicast(void) {
CU_ASSERT_TRUE(ms_is_multicast("224.1.2.3"));
CU_ASSERT_TRUE(ms_is_multicast("239.0.0.0"));
CU_ASSERT_TRUE(ms_is_multicast("ff02::3:2"));
CU_ASSERT_FALSE(ms_is_multicast("192.68.0.1"));
CU_ASSERT_FALSE(ms_is_multicast("::1"));
}
void test_error_level() {
CU_ASSERT_TRUE(set_log_lvl(ERROR));
char *test_msg = "Test msg";
int deep = 1;
CU_ASSERT_FALSE(debug(deep, test_msg));
CU_ASSERT_FALSE(info(deep, test_msg));
CU_ASSERT_FALSE(warn(deep, test_msg));
CU_ASSERT_TRUE(error(deep, test_msg));
}
static gboolean
xmms_metadata_test_xform_init (xmms_xform_t *xform)
{
const gchar *musicbrainz_va_id = "89ad4ac3-39f7-470e-963a-56509c546377";
const gchar *title, *rpgain;
gint track, totaltracks, compilation;
CU_ASSERT_FALSE (xmms_xform_metadata_mapper_match (xform, "missing", "missing", -1));
/* Basic string mapping */
CU_ASSERT_TRUE (xmms_xform_metadata_mapper_match (xform, "title", "the title", -1));
CU_ASSERT_TRUE (xmms_xform_metadata_get_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_TITLE, &title));
CU_ASSERT_STRING_EQUAL ("the title", title);
/* Mapping track number, without total tracks */
CU_ASSERT_TRUE (xmms_xform_metadata_mapper_match (xform, "tracknr", "1", -1));
CU_ASSERT_TRUE (xmms_xform_metadata_get_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_TRACKNR, &track));
CU_ASSERT_FALSE (xmms_xform_metadata_get_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_TOTALTRACKS, &totaltracks));
CU_ASSERT_EQUAL (1, track);
/* Mapping track number, with total tracks */
CU_ASSERT_TRUE (xmms_xform_metadata_mapper_match (xform, "tracknr", "1/10", -1));
CU_ASSERT_TRUE (xmms_xform_metadata_get_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_TRACKNR, &track));
CU_ASSERT_TRUE (xmms_xform_metadata_get_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_TOTALTRACKS, &totaltracks));
CU_ASSERT_EQUAL (1, track);
CU_ASSERT_EQUAL (10, totaltracks);
/* Broken track number */
CU_ASSERT_FALSE (xmms_xform_metadata_mapper_match (xform, "tracknr", "bad", -1));
/* Mapping compilation indicator to boolean compilation */
CU_ASSERT_TRUE (xmms_xform_metadata_mapper_match (xform, "compilation", "1", -1));
CU_ASSERT_TRUE (xmms_xform_metadata_get_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_COMPILATION, &compilation));
CU_ASSERT_EQUAL (TRUE, compilation);
/* Mapping compilation indicator to boolean compilation */
CU_ASSERT_TRUE (xmms_xform_metadata_mapper_match (xform, "compilation", musicbrainz_va_id, -1));
CU_ASSERT_TRUE (xmms_xform_metadata_get_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_COMPILATION, &compilation));
CU_ASSERT_EQUAL (TRUE, compilation);
/* Mapping replaygain to the format the replaygain xform expects */
CU_ASSERT_TRUE (xmms_xform_metadata_mapper_match (xform, "replaygain_track_gain", "-14.69", -1));
CU_ASSERT_TRUE (xmms_xform_metadata_get_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_GAIN_TRACK, &rpgain));
CU_ASSERT_STRING_EQUAL ("0.18428", rpgain);
CU_ASSERT_TRUE (xmms_xform_metadata_mapper_match (xform, "replaygain_track_gain", "-14.69 dB", -1));
CU_ASSERT_TRUE (xmms_xform_metadata_get_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_GAIN_TRACK, &rpgain));
CU_ASSERT_STRING_EQUAL ("0.18428", rpgain);
CU_ASSERT_TRUE (xmms_xform_metadata_mapper_match (xform, "coverart", "test", 10));
xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "audio/pcm", XMMS_STREAM_TYPE_END);
return TRUE;
}
static void test_compareStr() {
CU_ASSERT_TRUE(compareStr("abcd", 1, "afgh", 1));
CU_ASSERT_TRUE(compareStr("ABCD", 4, "abcd", 4));
CU_ASSERT_TRUE(compareStr("AbCd", 3, "AbCE", 3));
CU_ASSERT_TRUE(compareStr("ABCD", 1, "a", 1));
CU_ASSERT_FALSE(compareStr("abcd", 1, "efgh", 1));
CU_ASSERT_FALSE(compareStr("ABCD", 4, "abcd", 3));
}
static void test_vqec_seq_num_le (void) {
result = vqec_seq_num_le(5,4);
CU_ASSERT_FALSE(result);
result = vqec_seq_num_le(5,5);
CU_ASSERT(result);
result = vqec_seq_num_le(5,6);
CU_ASSERT(result);
result = vqec_seq_num_le(0xb,0x8000000b);
CU_ASSERT(result);
result = vqec_seq_num_le(0xb,0x8000000c);
CU_ASSERT_FALSE(result);
}
static void _dead_thread_two (void)
{
s4_transaction_t *trans = s4_begin (s4, 0);
CU_ASSERT_PTR_NOT_NULL (trans);
g_usleep (G_USEC_PER_SEC / 2);
CU_ASSERT_TRUE (s4_add (trans, "b", val, "a", val, "src"));
g_usleep (G_USEC_PER_SEC);
CU_ASSERT_FALSE (s4_add (trans, "a", val, "b", val, "src"));
CU_ASSERT_FALSE (s4_commit (trans));
CU_ASSERT_EQUAL (s4_errno (), S4E_DEADLOCK);
}
void TestGridCellIsInGrid()
{
// Create a grid.
int numberOfRows = 2;
int numberOfColumns = 3;
TrnGrid* grid = trn_grid_new(numberOfRows, numberOfColumns);
TrnPositionInGrid pos;
int rowIndex;
int columnIndex;
// Check position that are in grid
for (rowIndex = 0 ; rowIndex < numberOfRows; rowIndex++) {
pos.rowIndex = rowIndex;
for (columnIndex = 0 ; columnIndex < numberOfColumns ; columnIndex++) {
pos.columnIndex = columnIndex;
CU_ASSERT_TRUE(trn_grid_cell_is_in_grid(grid, pos));
}
}
// Check row out of grid from top.
pos.rowIndex = -1;
for (columnIndex = 0 ; columnIndex < numberOfColumns ; columnIndex++) {
pos.columnIndex = columnIndex;
CU_ASSERT_FALSE(trn_grid_cell_is_in_grid(grid, pos));
}
// Check row out of grid from bottom.
pos.rowIndex = numberOfRows;
for (columnIndex = 0 ; columnIndex < numberOfColumns ; columnIndex++) {
pos.columnIndex = columnIndex;
CU_ASSERT_FALSE(trn_grid_cell_is_in_grid(grid, pos));
}
// Check column out of grid from left.
pos.columnIndex = -1;
for (rowIndex = 0 ; rowIndex < numberOfRows; rowIndex++) {
pos.rowIndex = rowIndex;
CU_ASSERT_FALSE(trn_grid_cell_is_in_grid(grid, pos));
}
// Check column out of grid from right.
pos.columnIndex = numberOfColumns;
for (rowIndex = 0 ; rowIndex < numberOfRows; rowIndex++) {
pos.rowIndex = rowIndex;
CU_ASSERT_FALSE(trn_grid_cell_is_in_grid(grid, pos));
}
}
void test_singlePattern(void)
{
HObs hObs = NULL;
RU8 pattern[] = { 0x01, 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 };
RU32 context = 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)&pattern, sizeof( pattern ), &context ) );
// 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, &context );
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, &context );
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, &context );
CU_ASSERT_EQUAL( hitLoc, buffer4 + sizeof( buffer4 ) - 10 );
CU_ASSERT_TRUE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) );
CU_ASSERT_EQUAL( hitCtx, &context );
CU_ASSERT_EQUAL( hitLoc, buffer4 + sizeof( buffer4 ) - 4 );
CU_ASSERT_FALSE( obsLib_nextHit( hObs, &hitCtx, &hitLoc ) );
obsLib_free( hObs );
}
static void testSpawnAndConnect (void)
{
char userinfo[MAX_INFO_STRING];
player_t *player;
const char *name = "name";
bool day = true;
byte *buf;
/* this entity string may not contain any inline models, we don't have the bsp tree loaded here */
const int size = FS_LoadFile("game/entity.txt", &buf);
edict_t *e = NULL;
int cnt = 0;
CU_ASSERT_NOT_EQUAL_FATAL(size, -1);
CU_ASSERT_FATAL(size > 0);
SV_InitGameProgs();
/* otherwise we can't link the entities */
SV_ClearWorld();
player = G_PlayerGetNextHuman(0);
svs.ge->SpawnEntities(name, day, (const char *)buf);
CU_ASSERT_TRUE(svs.ge->ClientConnect(player, userinfo, sizeof(userinfo)));
CU_ASSERT_FALSE(svs.ge->RunFrame());
while ((e = G_EdictsGetNextInUse(e))) {
Com_Printf("entity %i: %s\n", cnt, e->classname);
cnt++;
}
CU_ASSERT_EQUAL(cnt, 45);
SV_ShutdownGameProgs();
FS_FreeFile(buf);
}
void test_llist_rm_first(void) {
Llist list = NULL;
Node arc1;
Node arc2;
node_alloc(&arc1);
node_alloc(&arc2);
arc1.score = 150;
arc2.score = 151;
/* See if trying to suppress an element of an empty list works */
CU_ASSERT_TRUE(llist_rm_first(&list));
/* Add something in order to suppress it later */
llist_add(arc1, &list);
llist_add(arc2, &list);
/* Suppress the first element of the list */
llist_rm_first(&list);
/* See if the remaining list have arc2 has its first element */
CU_ASSERT_TRUE(node_is_equal(list->value, arc1));
/* See deleting an element returns 0 */
CU_ASSERT_FALSE(llist_rm_first(&list));
/* Confirm the list is now a NULL pointer */
CU_ASSERT_PTR_NULL(list);
node_free(&arc1);
node_free(&arc2);
}
void test_string_function_registry()
{
function_registry* fr = string_function_registry();
char* tester = "hello";
/* start the tests */
printf("Test string_function_registry: ");
CU_ASSERT_TRUE(!strcmp(fr->name, "string"));
/* test the copy function */
char* cpy = (char*)fr->copy(tester);
CU_ASSERT_TRUE(!strcmp(cpy, tester));
/* test to be sure that it is actually a copy */
tester = "world";
CU_ASSERT_FALSE(!strcmp(cpy, tester));
/* free memory */
fr->destroy(cpy);
free(fr);
/* finish the test */
test_failure();
printf("\n");
}
static void test_cimunit_init_event_with_thread(void)
{
char event_name[] = "test";
char thread_name[] = "thread";
cimunit_event_t event;
cimunit_event_init_with_thread(&event, event_name, thread_name);
/// - Verify the event name is initialized
CU_ASSERT_PTR_NOT_NULL_FATAL(event.event_name);
CU_ASSERT_STRING_EQUAL(event.event_name, event_name);
/// - Verify the thread name is initialized
CU_ASSERT_PTR_NOT_NULL_FATAL(event.thread_name);
CU_ASSERT_STRING_EQUAL(event.thread_name, thread_name);
CU_ASSERT_FALSE(event.is_action);
/// - No cross platform tests for mutex configuration
/// - Verify the dependent events list is empty
CU_ASSERT_PTR_NULL(event.action_events);
cimunit_event_destroy(&event);
}
static void io_recv_error_without_active_register(){
LinphoneCoreManager *mgr;
LinphoneCore* lc;
int register_ok;
stats* counters ;
int number_of_udp_proxy=0;
MSList* proxys;
mgr=configure_lcm();
lc=mgr->lc;
counters = get_stats(lc);
register_ok=counters->number_of_LinphoneRegistrationOk;
number_of_udp_proxy=get_number_of_udp_proxy(lc);
for (proxys=ms_list_copy(linphone_core_get_proxy_config_list(lc));proxys!=NULL;proxys=proxys->next) {
LinphoneProxyConfig* proxy_cfg=(LinphoneProxyConfig*)proxys->data;
linphone_proxy_config_edit(proxy_cfg);
linphone_proxy_config_enable_register(proxy_cfg,FALSE);
linphone_proxy_config_done(proxy_cfg);
}
ms_list_free(proxys);
CU_ASSERT_TRUE(wait_for(lc,lc,&counters->number_of_LinphoneRegistrationCleared,register_ok /*because 1 udp*/));
sal_set_recv_error(lc->sal, 0);
/*nothing should happen because no active registration*/
CU_ASSERT_FALSE(wait_for(lc,lc,&counters->number_of_LinphoneRegistrationProgress,2*(register_ok-number_of_udp_proxy) /*because 1 udp*/));
CU_ASSERT_EQUAL(counters->number_of_LinphoneRegistrationFailed,0)
sal_set_recv_error(lc->sal, 1); /*reset*/
linphone_core_manager_destroy(mgr);
}
static void testItemToHeadgear (void)
{
inventory_t inv;
const objDef_t *od;
const invDef_t *container;
item_t item;
ResetInventoryList();
OBJZERO(inv);
od = INVSH_GetItemByIDSilent("irgoggles");
CU_ASSERT_PTR_NOT_NULL_FATAL(od);
container = INVSH_GetInventoryDefinitionByID("headgear");
CU_ASSERT_PTR_NOT_NULL_FATAL(container);
item.t = od;
item.m = NULL;
item.a = 0;
CU_ASSERT_FALSE(INVSH_ExistsInInventory(&inv, container, &item));
CU_ASSERT_PTR_NOT_NULL(i.AddToInventory(&i, &inv, &item, container, NONE, NONE, 1));
CU_ASSERT_TRUE(INVSH_ExistsInInventory(&inv, container, &item));
CU_ASSERT_PTR_NULL(i.AddToInventory(&i, &inv, &item, container, NONE, NONE, 1));
}
void rer_test_flags()
{
{
RER rer=rer_create("foo", "bar", "");
CU_ASSERT_PTR_NOT_NULL_FATAL(rer);
int flags = rer_getflags(rer);
CU_ASSERT_EQUAL(flags, 0);
flags = rer_setflag(rer, RER_F_GLOBAL);
CU_ASSERT_EQUAL(flags, RER_F_GLOBAL);
flags = rer_setflag(rer, RER_F_DRY_RUN);
CU_ASSERT_EQUAL(flags, RER_F_GLOBAL | RER_F_DRY_RUN);
flags = rer_getflags(rer);
CU_ASSERT_EQUAL(flags, RER_F_GLOBAL | RER_F_DRY_RUN);
flags = rer_clrflag(rer, RER_F_GLOBAL);
CU_ASSERT_EQUAL(flags, RER_F_DRY_RUN);
int ret = rer_chkflag(rer, RER_F_DRY_RUN);
CU_ASSERT_TRUE(ret);
ret = rer_chkflag(rer, RER_F_GLOBAL);
CU_ASSERT_FALSE(ret);
flags = rer_clrflag(rer, RER_F_DRY_RUN);
CU_ASSERT_EQUAL(flags, 0);
rer_destroy(rer);
}
{
RER rer=rer_create("foo", "bar", "g");
CU_ASSERT_PTR_NOT_NULL_FATAL(rer);
int flags = rer_getflags(rer);
CU_ASSERT_EQUAL(flags, RER_F_GLOBAL);
rer_destroy(rer);
}
}
void test_hashMap_remove(void) {
char * key = "key";
char * value = "value";
char * key2 = NULL;
char * value2 = "value2";
char * removeKey;
hashMap_clear(map, false, false);
// Add one entry
hashMap_put(map, key, value);
// Add second entry with null key
hashMap_put(map, key2, value2);
// Remove unexisting entry for map
removeKey = "unexisting";
hashMap_remove(map, removeKey);
CU_ASSERT_EQUAL(map->size, 2);
CU_ASSERT_FALSE(hashMap_isEmpty(map));
hashMap_remove(map, key);
CU_ASSERT_EQUAL(map->size, 1);
hashMap_remove(map, key2);
CU_ASSERT_EQUAL(map->size, 0);
CU_ASSERT_TRUE(hashMap_isEmpty(map));
// Remove unexisting entry for empty map
removeKey = "unexisting";
hashMap_remove(map, removeKey);
CU_ASSERT_EQUAL(map->size, 0);
CU_ASSERT_TRUE(hashMap_isEmpty(map));
}
static void proxy_transport_change_with_wrong_port_givin_up() {
LinphoneCoreManager* lcm = create_lcm();
stats* counters = &lcm->stat;
LinphoneProxyConfig* proxy_config;
LinphoneAuthInfo *info=linphone_auth_info_new(test_username,NULL,test_password,NULL,auth_domain,NULL); /*create authentication structure from identity*/
char route[256];
LCSipTransports transport= {LC_SIP_TRANSPORT_RANDOM,LC_SIP_TRANSPORT_RANDOM,LC_SIP_TRANSPORT_RANDOM,LC_SIP_TRANSPORT_RANDOM};
sprintf(route,"sip:%s",test_route);
linphone_core_add_auth_info(lcm->lc,info); /*add authentication info to LinphoneCore*/
register_with_refresh_base_3(lcm->lc, FALSE, auth_domain, "sip2.linphone.org:5987", 0,transport,LinphoneRegistrationProgress);
linphone_core_get_default_proxy(lcm->lc,&proxy_config);
linphone_proxy_config_edit(proxy_config);
CU_ASSERT_FALSE(wait_for_until(lcm->lc,lcm->lc,&counters->number_of_LinphoneRegistrationCleared,1,3000));
linphone_proxy_config_enableregister(proxy_config,FALSE);
linphone_proxy_config_done(proxy_config);
CU_ASSERT(wait_for(lcm->lc,lcm->lc,&counters->number_of_LinphoneRegistrationCleared,1));
CU_ASSERT_EQUAL(counters->number_of_LinphoneRegistrationOk,0);
CU_ASSERT_EQUAL(counters->number_of_LinphoneRegistrationProgress,1);
CU_ASSERT_EQUAL(counters->number_of_LinphoneRegistrationFailed,0);
linphone_core_manager_destroy(lcm);
}
static void test_set_possible_timeslot(void) {
init_test_exam();
exam *test_exams[] = {exam1, exam2, exam3, exam4,
exam5, exam6, exam7, exam8};
init_test_array_exams(8, test_exams);
preprocess(exams);
/* Timeslots for Exam 1 : same as availabilities (0 exams scheduled) */
bool *timeslots_exam1 = set_possible_timeslot(exams->data[0], exams,
MAX_TIMESLOT);
for(int i = 0; i < MAX_TIMESLOT; i++)
CU_ASSERT_EQUAL(timeslots_exam1[i], exams->data[0]->availabilities[i]);
free(timeslots_exam1);
/* Schedule Exam 1 at timeslot 2 (index 1)*/
exams->data[0]->timeslot = 1;
/* Timeslots for Exam 7 : conflict with Exam 1 */
bool *timeslots_exam7 = set_possible_timeslot(exams->data[6], exams,
MAX_TIMESLOT);
CU_ASSERT_EQUAL(timeslots_exam7[0], exams->data[6]->availabilities[0]);
/* Conflict */
CU_ASSERT_FALSE(timeslots_exam7[1]);
CU_ASSERT_EQUAL(timeslots_exam7[2], exams->data[6]->availabilities[2]);
CU_ASSERT_EQUAL(timeslots_exam7[3], exams->data[6]->availabilities[3]);
CU_ASSERT_EQUAL(timeslots_exam7[4], exams->data[6]->availabilities[4]);
free(timeslots_exam7);
clean_array_exams();
}
/**
* @brief fo_tableExists() tests:
* - Check for an existing table
* - Check for table that does not exist
* - Check for a non table entities (sequence, constraint, ...)
* @return void
*/
void test_fo_tableExists()
{
PGconn* pgConn;
int nonexistant_table;
int existing_table;
char* DBConfFile = dbConf;
char* ErrorBuf;
pgConn = fo_dbconnect(DBConfFile, &ErrorBuf);
CU_ASSERT_PTR_NOT_NULL(pgConn);
nonexistant_table = fo_tableExists(pgConn, "nonexistanttable");
CU_ASSERT_FALSE(nonexistant_table);
PGresult* result = PQexec(pgConn, "CREATE table exists()");
CU_ASSERT_PTR_NOT_NULL_FATAL(result);
CU_ASSERT_FALSE_FATAL(fo_checkPQcommand(pgConn, result, "create", __FILE__, __LINE__));
existing_table = fo_tableExists(pgConn, "exists");
CU_ASSERT_TRUE(existing_table);
PQfinish(pgConn);
return;
}
static void testSchedulerCheck (void)
{
std::string s_one("one");
std::string s_two("two");
std::string s_three("three");
std::string s_four("four");
std::string s_five("five");
ScheduleEventPtr three = Schedule_Event(4, nullptr, nullptr, nullptr, static_cast<void*>(&s_three));
ScheduleEventPtr four = Schedule_Event(4, nullptr, nullptr, nullptr, static_cast<void*>(&s_four));
ScheduleEventPtr five = Schedule_Event(4, nullptr, nullptr, nullptr, static_cast<void*>(&s_five));
ScheduleEventPtr one = Schedule_Event(3, nullptr, delayCheck, nullptr, static_cast<void*>(&s_one));
ScheduleEventPtr two = Schedule_Event(3, nullptr, nullptr, nullptr, static_cast<void*>(&s_two));
ScheduleEventPtr e = Dequeue_Event(1);
CU_ASSERT_FALSE(e);
e = Dequeue_Event(2);
CU_ASSERT_FALSE(e);
/* one is delayed via check function - so we get the 2nd event at the first dequeue here */
e = Dequeue_Event(3);
CU_ASSERT_EQUAL_FATAL(e, two);
/* now we are ready for the 1st event */
e = Dequeue_Event(5);
CU_ASSERT_EQUAL_FATAL(e, one);
/* the remaining events are in order */
e = Dequeue_Event(5);
CU_ASSERT_EQUAL_FATAL(e, three);
e = Dequeue_Event(5);
CU_ASSERT_EQUAL_FATAL(e, four);
e = Dequeue_Event(5);
CU_ASSERT_EQUAL_FATAL(e, five);
}
