void test_can_read_ihex_rs_from_file_1(void)
{
ihex_recordset_t* r = ihex_rs_from_file("res/hex1.dat");
CU_ASSERT_PTR_NOT_NULL_FATAL(r);
CU_ASSERT_EQUAL_FATAL(r->ihrs_count, 6);
IHEX_ASSERT_REC_EQUAL(&(r->ihrs_records[1]), 0x10, 0x0100, IHEX_DATA, 0x21);
}
void test_can_read_ihex_rs_from_file_2(void)
{
ihex_recordset_t* r = ihex_rs_from_file("res/big-a.hex");
CU_ASSERT_PTR_NOT_NULL_FATAL(r);
CU_ASSERT_EQUAL_FATAL(r->ihrs_count, 214);
IHEX_ASSERT_REC_EQUAL(&(r->ihrs_records[2]), 0x10, 0x0400, IHEX_DATA, 0x0B);
}
void test_class_db_object_field(void) {
CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
CU_ASSERT(!db_object_field_set_name(object_field, "field1"));
CU_ASSERT(!db_object_field_set_type(object_field, DB_TYPE_INT32));
CU_ASSERT(!db_object_field_not_empty(object_field));
CU_ASSERT_PTR_NOT_NULL_FATAL(db_object_field_name(object_field));
CU_ASSERT(!strcmp(db_object_field_name(object_field), "field1"));
CU_ASSERT(db_object_field_type(object_field) == DB_TYPE_INT32);
CU_ASSERT_PTR_NOT_NULL_FATAL((object_field2 = db_object_field_new()));
CU_ASSERT(!db_object_field_set_name(object_field2, "field2"));
CU_ASSERT(!db_object_field_set_type(object_field2, DB_TYPE_ENUM));
CU_ASSERT(!db_object_field_set_enum_set(object_field2, (db_enum_t*)&fake_pointer));
CU_ASSERT(!db_object_field_not_empty(object_field2));
CU_ASSERT_PTR_NOT_NULL_FATAL(db_object_field_name(object_field2));
CU_ASSERT(!strcmp(db_object_field_name(object_field2), "field2"));
CU_ASSERT(db_object_field_type(object_field2) == DB_TYPE_ENUM);
CU_ASSERT(db_object_field_enum_set(object_field2) == (db_enum_t*)&fake_pointer);
}
static void parallel_execute(odp_schedule_sync_t sync, int num_queues,
int num_prio, int enable_schd_multi,
int enable_excl_atomic)
{
odp_shm_t shm;
test_globals_t *globals;
thread_args_t *args;
shm = odp_shm_lookup(GLOBALS_SHM_NAME);
CU_ASSERT_FATAL(shm != ODP_SHM_INVALID);
globals = odp_shm_addr(shm);
CU_ASSERT_PTR_NOT_NULL_FATAL(globals);
shm = odp_shm_lookup(SHM_THR_ARGS_NAME);
CU_ASSERT_FATAL(shm != ODP_SHM_INVALID);
args = odp_shm_addr(shm);
CU_ASSERT_PTR_NOT_NULL_FATAL(args);
args->globals = globals;
args->sync = sync;
args->num_queues = num_queues;
args->num_prio = num_prio;
if (enable_excl_atomic)
args->num_bufs = BUFS_PER_QUEUE_EXCL;
else
args->num_bufs = BUFS_PER_QUEUE;
args->num_workers = globals->num_workers;
args->enable_schd_multi = enable_schd_multi;
args->enable_excl_atomic = enable_excl_atomic;
fill_queues(args);
/* Create and launch worker threads */
args->cu_thr.numthrds = globals->num_workers;
odp_cunit_thread_create(schedule_common_, &args->cu_thr);
/* Wait for worker threads to terminate */
odp_cunit_thread_exit(&args->cu_thr);
/* Cleanup ordered queues for next pass */
if (sync == ODP_SCHED_SYNC_ORDERED)
reset_queues(args);
}
static void core_init_test(void) {
LinphoneCoreVTable v_table;
LinphoneCore* lc;
memset (&v_table,0,sizeof(v_table));
lc = linphone_core_new(&v_table,NULL,NULL,NULL);
/* until we have good certificates on our test server... */
linphone_core_verify_server_certificates(lc,FALSE);
CU_ASSERT_PTR_NOT_NULL_FATAL(lc);
linphone_core_destroy(lc);
}
static void testTeamDefsModelScriptData (void)
{
int i;
linkedList_t *armourPaths = NULL;
for (i = 0; i < csi.numTeamDefs; i++) {
int j;
const teamDef_t *teamDef = &csi.teamDef[i];
if (!teamDef->armour)
continue;
for (j = 0; j < csi.numODs; j++) {
const objDef_t *od = INVSH_GetItemByIDX(j);
if (!INV_IsArmour(od))
continue;
/* not for this team */
if (!CHRSH_IsArmourUseableForTeam(od, teamDef))
continue;
if (!LIST_ContainsString(armourPaths, od->armourPath))
LIST_AddString(&armourPaths, od->armourPath);
}
UFO_CU_ASSERT_TRUE_MSG(!LIST_IsEmpty(armourPaths), va("no armour definitions found for team %s - but armour is set to true",
teamDef->id));
LIST_Foreach(armourPaths, char const, armourPath) {
int l;
for (l = NAME_NEUTRAL; l < NAME_LAST; l++) {
/* no models for this gender */
if (!teamDef->numModels[l])
continue;
CU_ASSERT_PTR_NOT_NULL_FATAL(teamDef->models[l]);
for (linkedList_t const* list = teamDef->models[l]; list; list = list->next) {
teamDef_t::model_t const& m = *static_cast<teamDef_t::model_t const*>(list->data);
UFO_CU_ASSERT_TRUE_MSG(TEST_CheckModel(va("%s/%s", m.path, m.body)), va("%s does not exist in models/%s (teamDef: %s)",
m.body, m.path, teamDef->id));
UFO_CU_ASSERT_TRUE_MSG(TEST_CheckModel(va("%s%s/%s", m.path, armourPath, m.body)), va("%s does not exist in models/%s%s (teamDef: %s)",
m.body, m.path, armourPath, teamDef->id));
UFO_CU_ASSERT_TRUE_MSG(TEST_CheckModel(va("%s/%s", m.path, m.head)), va("%s does not exist in models/%s (teamDef: %s)",
m.head, m.path, teamDef->id));
UFO_CU_ASSERT_TRUE_MSG(TEST_CheckModel(va("%s%s/%s", m.path, armourPath, m.head)), va("%s does not exist in models/%s%s (teamDef: %s)",
m.head, m.path, armourPath, teamDef->id));
}
}
}
LIST_Delete(&armourPaths);
}
/* Successful IPv6 AAAA query */
static void ipv6_aaaa_query(void) {
struct addrinfo *ai;
int timeout;
endpoint_t *client;
if (!belle_sip_tester_ipv6_available()){
belle_sip_warning("Test skipped, IPv6 connectivity not available.");
return;
}
client = create_endpoint();
CU_ASSERT_PTR_NOT_NULL_FATAL(client);
timeout = belle_sip_stack_get_dns_timeout(client->stack);
client->resolver_ctx = belle_sip_stack_resolve_a(client->stack, IPV6_SIP_DOMAIN, SIP_PORT, AF_INET6, a_resolve_done, client);
CU_ASSERT_NOT_EQUAL(client->resolver_ctx, NULL);
CU_ASSERT_TRUE(wait_for(client->stack, &client->resolve_done, 1, timeout));
CU_ASSERT_PTR_NOT_EQUAL(client->ai_list, NULL);
if (client->ai_list) {
struct addrinfo *next;
struct sockaddr_in6 *sock_in6 = (struct sockaddr_in6 *)client->ai_list->ai_addr;
CU_ASSERT_EQUAL(ntohs(sock_in6->sin6_port), SIP_PORT);
/*the IPv6 address shall return first, and must be a real ipv6 address*/
CU_ASSERT_TRUE(client->ai_list->ai_family==AF_INET6);
CU_ASSERT_FALSE(IN6_IS_ADDR_V4MAPPED(&sock_in6->sin6_addr));
ai = belle_sip_ip_address_to_addrinfo(AF_INET6, IPV6_SIP_IP, SIP_PORT);
CU_ASSERT_PTR_NOT_NULL(ai);
if (ai) {
struct in6_addr *ipv6_address = &((struct sockaddr_in6 *)ai->ai_addr)->sin6_addr;
int i;
for (i = 0; i < 8; i++) {
CU_ASSERT_EQUAL(sock_in6->sin6_addr.s6_addr[i], ipv6_address->s6_addr[i]);
}
belle_sip_freeaddrinfo(ai);
}
next=client->ai_list->ai_next;
CU_ASSERT_PTR_NOT_NULL(next);
if (next){
sock_in6 = (struct sockaddr_in6 *)next->ai_addr;
CU_ASSERT_TRUE(next->ai_family==AF_INET6);
CU_ASSERT_TRUE(IN6_IS_ADDR_V4MAPPED(&sock_in6->sin6_addr));
CU_ASSERT_EQUAL(ntohs(sock_in6->sin6_port), SIP_PORT);
ai = belle_sip_ip_address_to_addrinfo(AF_INET6, IPV6_SIP_IPV4, SIP_PORT);
CU_ASSERT_PTR_NOT_NULL(ai);
if (ai) {
struct in6_addr *ipv6_address = &((struct sockaddr_in6 *)ai->ai_addr)->sin6_addr;
int i;
for (i = 0; i < 8; i++) {
CU_ASSERT_EQUAL(sock_in6->sin6_addr.s6_addr[i], ipv6_address->s6_addr[i]);
}
belle_sip_freeaddrinfo(ai);
}
}
}
destroy_endpoint(client);
}
void test_class_db_result(void) {
db_value_set_t* local_value_set = value_set;
db_value_set_t* local_value_set2 = value_set2;
db_backend_meta_data_list_t* local_backend_meta_data_list2 = backend_meta_data_list2;
CU_ASSERT_PTR_NOT_NULL_FATAL((result = db_result_new()));
CU_ASSERT(!db_result_set_value_set(result, value_set));
value_set = NULL;
CU_ASSERT(db_result_value_set(result) == local_value_set);
CU_ASSERT(!db_result_set_backend_meta_data_list(result, backend_meta_data_list2));
backend_meta_data_list2 = NULL;
CU_ASSERT(db_result_backend_meta_data_list(result) == local_backend_meta_data_list2);
CU_ASSERT(!db_result_not_empty(result));
CU_ASSERT_PTR_NOT_NULL_FATAL((result2 = db_result_new()));
CU_ASSERT(!db_result_set_value_set(result2, value_set2));
value_set2 = NULL;
CU_ASSERT(db_result_value_set(result2) == local_value_set2);
CU_ASSERT(!db_result_not_empty(result2));
}
/* IPv4 A query send failure */
static void ipv4_a_query_send_failure(void) {
endpoint_t *client = create_endpoint();
CU_ASSERT_PTR_NOT_NULL_FATAL(client);
belle_sip_stack_set_resolver_send_error(client->stack, -1);
client->resolver_ctx = belle_sip_stack_resolve_a(client->stack, IPV4_SIP_DOMAIN, SIP_PORT, AF_INET, a_resolve_done, client);
CU_ASSERT_EQUAL(client->resolver_ctx, NULL);
belle_sip_stack_set_resolver_send_error(client->stack, 0);
destroy_endpoint(client);
}
static void test_escaped_headers(void) {
belle_sip_uri_t * L_uri = belle_sip_uri_parse("sip:[email protected]?User-to-User=323a313030363a3230385a48363039313941364b4342463845495936%3Bencoding%3Dhex");
char* l_raw_uri = belle_sip_object_to_string(BELLE_SIP_OBJECT(L_uri));
belle_sip_object_unref(BELLE_SIP_OBJECT(L_uri));
L_uri = belle_sip_uri_parse(l_raw_uri);
belle_sip_free(l_raw_uri);
CU_ASSERT_PTR_NOT_NULL_FATAL(belle_sip_uri_get_header(L_uri,"User-to-User"));
CU_ASSERT_STRING_EQUAL(belle_sip_uri_get_header(L_uri,"User-to-User"), "323a313030363a3230385a48363039313941364b4342463845495936;encoding=hex");
belle_sip_object_unref(L_uri);
}
static void test_game(void)
{
struct Draughts *game;
game = init_game();
CU_ASSERT_PTR_NOT_NULL_FATAL(game);
free(game);
fake_malloc_params.should_fail = 1;
struct Draughts *game_fail;
game_fail = init_game();
CU_ASSERT_PTR_NULL_FATAL(game_fail);
}
void ms_tester_create_filters(unsigned int filter_mask) {
MSSndCardManager *snd_manager;
MSWebCamManager *cam_manager;
MSSndCard *playcard;
MSSndCard *captcard;
MSWebCam *camera;
CREATE_FILTER(FILTER_MASK_FILEPLAY, ms_tester_fileplay, MS_FILE_PLAYER_ID);
CREATE_FILTER(FILTER_MASK_FILEREC, ms_tester_filerec, MS_FILE_REC_ID);
CREATE_FILTER(FILTER_MASK_DTMFGEN, ms_tester_dtmfgen, MS_DTMF_GEN_ID);
CREATE_FILTER(FILTER_MASK_TONEDET, ms_tester_tonedet, MS_TONE_DETECTOR_ID);
CREATE_FILTER(FILTER_MASK_VOIDSOURCE, ms_tester_voidsource, MS_VOID_SOURCE_ID);
CREATE_FILTER(FILTER_MASK_VOIDSINK, ms_tester_voidsink, MS_VOID_SINK_ID);
if (filter_mask & FILTER_MASK_ENCODER) {
CU_ASSERT_PTR_NULL(ms_tester_encoder);
ms_tester_encoder = ms_filter_create_encoder(ms_tester_codec_mime);
CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_encoder);
}
if (filter_mask & FILTER_MASK_DECODER) {
CU_ASSERT_PTR_NULL(ms_tester_decoder);
ms_tester_decoder = ms_filter_create_decoder(ms_tester_codec_mime);
CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_decoder);
}
CREATE_FILTER(FILTER_MASK_RTPRECV, ms_tester_rtprecv, MS_RTP_RECV_ID);
CREATE_FILTER(FILTER_MASK_RTPSEND, ms_tester_rtpsend, MS_RTP_SEND_ID);
CREATE_FILTER(FILTER_MASK_RESAMPLER, ms_tester_resampler, MS_RESAMPLE_ID);
if (filter_mask & FILTER_MASK_SOUNDWRITE) {
CU_ASSERT_PTR_NULL(ms_tester_soundwrite);
snd_manager = ms_snd_card_manager_get();
playcard = ms_snd_card_manager_get_default_playback_card(snd_manager);
CU_ASSERT_PTR_NOT_NULL_FATAL(playcard);
ms_tester_soundwrite = ms_snd_card_create_writer(playcard);
CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_soundwrite);
}
if (filter_mask & FILTER_MASK_SOUNDREAD) {
CU_ASSERT_PTR_NULL(ms_tester_soundread);
snd_manager = ms_snd_card_manager_get();
captcard = ms_snd_card_manager_get_default_capture_card(snd_manager);
CU_ASSERT_PTR_NOT_NULL_FATAL(captcard);
ms_tester_soundread = ms_snd_card_create_reader(captcard);
CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_soundread);
}
if (filter_mask & FILTER_MASK_VIDEOCAPTURE) {
CU_ASSERT_PTR_NULL(ms_tester_videocapture);
cam_manager = ms_web_cam_manager_get();
camera = ms_web_cam_manager_get_default_cam(cam_manager);
CU_ASSERT_PTR_NOT_NULL_FATAL(camera);
ms_tester_videocapture = ms_web_cam_create_reader(camera);
CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_videocapture);
}
}
static void test_headers(void) {
belle_sip_uri_t * L_uri = belle_sip_uri_parse("sip:192.168.0.1?toto=titi");
char* l_raw_uri = belle_sip_object_to_string(BELLE_SIP_OBJECT(L_uri));
belle_sip_object_unref(BELLE_SIP_OBJECT(L_uri));
L_uri = belle_sip_uri_parse(l_raw_uri);
belle_sip_free(l_raw_uri);
CU_ASSERT_PTR_NOT_NULL_FATAL(belle_sip_uri_get_header(L_uri,"toto"));
CU_ASSERT_STRING_EQUAL(belle_sip_uri_get_header(L_uri,"toto"), "titi");
CU_ASSERT_PTR_NULL(belle_sip_uri_get_header(L_uri,"bla"));
belle_sip_object_unref(BELLE_SIP_OBJECT(L_uri));
L_uri = belle_sip_uri_parse("sip:192.168.0.1?toto=titi&header2=popo&header3=");
l_raw_uri = belle_sip_object_to_string(BELLE_SIP_OBJECT(L_uri));
belle_sip_object_unref(BELLE_SIP_OBJECT(L_uri));
L_uri = belle_sip_uri_parse(l_raw_uri);
belle_sip_free(l_raw_uri);
CU_ASSERT_PTR_NOT_NULL_FATAL(belle_sip_uri_get_header(L_uri,"toto"));
CU_ASSERT_STRING_EQUAL(belle_sip_uri_get_header(L_uri,"header2"), "popo");
belle_sip_object_unref(L_uri);
}
static installation_t* CreateInstallation (const char *name, const vec2_t pos)
{
const installationTemplate_t *installationTemplate = INS_GetInstallationTemplateFromInstallationID("ufoyard");
installation_t *installation = INS_GetFirstUnfoundedInstallation();
CU_ASSERT_PTR_NOT_NULL_FATAL(installationTemplate);
CU_ASSERT_PTR_NOT_NULL_FATAL(installation);
CU_ASSERT_FALSE(installation->founded);
INS_SetUpInstallation(installation, installationTemplate, pos, name);
CU_ASSERT_EQUAL(installation->installationStatus, INSTALLATION_UNDER_CONSTRUCTION);
/* fake the build time */
installation->buildStart = ccs.date.day - installation->installationTemplate->buildTime;
INS_UpdateInstallationData();
CU_ASSERT_EQUAL(installation->installationStatus, INSTALLATION_WORKING);
return installation;
}
static void test_register_channel_inactive(void){
belle_sip_listening_point_t *lp=belle_sip_provider_get_listening_point(prov,"TCP");
CU_ASSERT_PTR_NOT_NULL_FATAL(lp);
belle_sip_stack_set_inactive_transport_timeout(stack,5);
belle_sip_listening_point_clean_channels(lp);
CU_ASSERT_EQUAL(belle_sip_listening_point_get_channel_count(lp),0);
register_test("tcp",1);
CU_ASSERT_EQUAL(belle_sip_listening_point_get_channel_count(lp),1);
belle_sip_stack_sleep(stack,5000);
CU_ASSERT_EQUAL(belle_sip_listening_point_get_channel_count(lp),0);
belle_sip_stack_set_inactive_transport_timeout(stack,3600);
}
static void test_success_with_cookie(void)
{
struct cookie cookie;
struct result* result = 0;
result = success_result(0, 0, 0, &cookie);
CU_ASSERT_PTR_NOT_NULL_FATAL(result);
CU_ASSERT_PTR_EQUAL(result->cookies, &cookie);
free_result(result);
}
void testDAD_create() {
DAD_set *s;
s = dad_create(0, 0, 0);
CU_ASSERT_PTR_NOT_NULL_FATAL(s);
CU_ASSERT_EQUAL(0, ipset_count(s->ip));
CU_ASSERT_EQUAL(0, dad_count(s));
dad_delete(s);
s = dad_create(10, 0, 0);
CU_ASSERT_PTR_NOT_NULL_FATAL(s);
CU_ASSERT_EQUAL(0, ipset_count(s->ip));
CU_ASSERT_EQUAL(0, dad_count(s));
dad_delete(s);
s = dad_create(10240, 0, 0);
CU_ASSERT_PTR_NOT_NULL_FATAL(s);
CU_ASSERT_EQUAL(0, ipset_count(s->ip));
CU_ASSERT_EQUAL(0, dad_count(s));
dad_delete(s);
}
static void test_multi_group(void)
{
struct address *a;
struct address *cur;
a = NULL;
parseaddr_list("group: [email protected], [email protected];, group2: [email protected];", &a);
cur = a;
CU_ASSERT_PTR_NOT_NULL_FATAL(cur);
CU_ASSERT_PTR_NULL(cur->name);
CU_ASSERT_STRING_EQUAL(cur->mailbox, "group");
CU_ASSERT_PTR_NULL(cur->domain);
cur = cur->next;
CU_ASSERT_PTR_NOT_NULL_FATAL(cur);
CU_ASSERT_PTR_NULL(cur->name);
CU_ASSERT_STRING_EQUAL(cur->mailbox, "g1");
CU_ASSERT_STRING_EQUAL(cur->domain, "d1.org");
cur = cur->next;
CU_ASSERT_PTR_NOT_NULL_FATAL(cur);
CU_ASSERT_PTR_NULL(cur->name);
CU_ASSERT_STRING_EQUAL(cur->mailbox, "g2");
CU_ASSERT_STRING_EQUAL(cur->domain, "d2.org");
cur = cur->next;
CU_ASSERT_PTR_NOT_NULL_FATAL(cur);
CU_ASSERT_PTR_NULL(cur->name);
CU_ASSERT_PTR_NULL(cur->mailbox);
CU_ASSERT_PTR_NULL(cur->domain);
cur = cur->next;
CU_ASSERT_PTR_NOT_NULL_FATAL(cur);
CU_ASSERT_PTR_NULL(cur->name);
CU_ASSERT_STRING_EQUAL(cur->mailbox, "group2");
CU_ASSERT_PTR_NULL(cur->domain);
cur = cur->next;
CU_ASSERT_PTR_NOT_NULL_FATAL(cur);
CU_ASSERT_PTR_NULL(cur->name);
CU_ASSERT_STRING_EQUAL(cur->mailbox, "g3");
CU_ASSERT_STRING_EQUAL(cur->domain, "d3.org");
cur = cur->next;
CU_ASSERT_PTR_NOT_NULL_FATAL(cur);
CU_ASSERT_PTR_NULL(cur->name);
CU_ASSERT_PTR_NULL(cur->mailbox);
CU_ASSERT_PTR_NULL(cur->domain);
cur = cur->next;
CU_ASSERT_PTR_NULL(cur);
parseaddr_free(a);
}
void testRace2() {
CU_ASSERT_PTR_NOT_NULL_FATAL(jb);
bool err = false;
TARGRACE targs[tnum];
pthread_t threads[tnum];
ejdbrmcoll(jb, "threadrace1", true);
EJCOLL *coll = ejdbcreatecoll(jb, "threadrace1", NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(coll);
if (!ejdbsetindex(coll, "tid", JBIDXDROPALL)) { //NO INDEX
eprint(jb, __LINE__, "testRace2");
err = true;
}
if (err) {
goto finish;
}
for (int i = 0; i < tnum; i++) {
targs[i].jb = jb;
targs[i].id = i;
if (pthread_create(threads + i, NULL, threadrace1, targs + i) != 0) {
eprint(jb, __LINE__, "pthread_create");
targs[i].id = -1;
err = true;
}
}
for (int i = 0; i < tnum; i++) {
if (targs[i].id == -1) continue;
void *rv;
if (pthread_join(threads[i], &rv) != 0) {
eprint(jb, __LINE__, "pthread_join");
err = true;
} else if (rv) {
err = true;
}
}
finish:
CU_ASSERT_FALSE(err);
}
static void process_message_response_event(void *user_ctx, const belle_sip_response_event_t *event){
int status;
BELLESIP_UNUSED(user_ctx);
CU_ASSERT_PTR_NOT_NULL_FATAL(belle_sip_response_event_get_response(event));
belle_sip_message("process_response_event [%i] [%s]"
,status=belle_sip_response_get_status_code(belle_sip_response_event_get_response(event))
,belle_sip_response_get_reason_phrase(belle_sip_response_event_get_response(event)));
if (status >= 200){
is_register_ok=status;
belle_sip_main_loop_quit(belle_sip_stack_get_main_loop(stack));
}
}
/* Successful SRV + A or AAAA queries */
static void srv_a_query(void) {
int timeout;
endpoint_t *client = create_endpoint();
CU_ASSERT_PTR_NOT_NULL_FATAL(client);
timeout = belle_sip_stack_get_dns_timeout(client->stack);
client->resolver_ctx = belle_sip_stack_resolve(client->stack, "udp", SRV_DOMAIN, SIP_PORT, AF_INET, a_resolve_done, client);
CU_ASSERT_NOT_EQUAL(client->resolver_ctx, NULL);
CU_ASSERT_TRUE(wait_for(client->stack, &client->resolve_done, 1, timeout));
CU_ASSERT_PTR_NOT_EQUAL(client->ai_list, NULL);
destroy_endpoint(client);
}
static void uninit_video_streams(video_stream_tester_t *vst1, video_stream_tester_t *vst2) {
float rtcp_send_bandwidth;
PayloadType *vst1_pt;
PayloadType *vst2_pt;
vst1_pt = rtp_profile_get_payload(&rtp_profile, vst1->payload_type);
CU_ASSERT_PTR_NOT_NULL_FATAL(vst1_pt);
vst2_pt = rtp_profile_get_payload(&rtp_profile, vst2->payload_type);
CU_ASSERT_PTR_NOT_NULL_FATAL(vst2_pt);
rtcp_send_bandwidth = rtp_session_get_rtcp_send_bandwidth(vst1->vs->ms.sessions.rtp_session);
ms_message("vst1: rtcp_send_bandwidth=%f, payload_type_bitrate=%d, rtcp_target_bandwidth=%f",
rtcp_send_bandwidth, payload_type_get_bitrate(vst1_pt), 0.06 * payload_type_get_bitrate(vst1_pt));
CU_ASSERT_TRUE(rtcp_send_bandwidth <= (0.06 * payload_type_get_bitrate(vst1_pt)));
rtcp_send_bandwidth = rtp_session_get_rtcp_send_bandwidth(vst2->vs->ms.sessions.rtp_session);
ms_message("vst2: rtcp_send_bandwidth=%f, payload_type_bitrate=%d, rtcp_target_bandwidth=%f",
rtcp_send_bandwidth, payload_type_get_bitrate(vst2_pt), 0.06 * payload_type_get_bitrate(vst2_pt));
CU_ASSERT_TRUE(rtcp_send_bandwidth <= (0.06 * payload_type_get_bitrate(vst2_pt)));
destroy_video_stream(vst1);
destroy_video_stream(vst2);
}
/* IPv4 A query timeout */
static void ipv4_a_query_timeout(void) {
endpoint_t *client = create_endpoint();
CU_ASSERT_PTR_NOT_NULL_FATAL(client);
belle_sip_stack_set_dns_timeout(client->stack, 0);
client->resolver_ctx = belle_sip_stack_resolve_a(client->stack, "toto.com", SIP_PORT, AF_INET, a_resolve_done, client);
CU_ASSERT_NOT_EQUAL(client->resolver_ctx, NULL);
CU_ASSERT_TRUE(wait_for(client->stack, &client->resolve_done, 1, 2000));
CU_ASSERT_PTR_EQUAL(client->ai_list, NULL);
CU_ASSERT_EQUAL(client->resolve_ko,1);
destroy_endpoint(client);
}
void test_conf_parse_row(void) {
service_t* srv = conf_parse_row("a:b:c");
CU_ASSERT_PTR_NOT_NULL_FATAL(srv);
CU_ASSERT_STRING_EQUAL(srv->serv, "a");
CU_ASSERT_STRING_EQUAL(srv->warn, "b");
CU_ASSERT_STRING_EQUAL(srv->crit, "c");
service_free(srv);
srv = conf_parse_row("abc");
CU_ASSERT_PTR_NULL(srv);
}
/* test object creation and deletion */
void test_om_new_destroy(void) {
MBIt_objmap *mymap = NULL;
mymap = MBI_objmap_new();
CU_ASSERT_PTR_NOT_NULL_FATAL(mymap);
/* CU_ASSERT_PTR_NULL_FATAL(mymap->map); */
CU_ASSERT_EQUAL(mymap->top, 0);
MBI_objmap_destroy(&mymap);
CU_ASSERT_PTR_NULL(mymap);
}
LinphoneAddress * create_linphone_address(const char * domain) {
LinphoneAddress *addr = linphone_address_new(NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(addr);
linphone_address_set_username(addr,test_username);
CU_ASSERT_STRING_EQUAL(test_username,linphone_address_get_username(addr));
if (!domain) domain= test_route;
linphone_address_set_domain(addr,domain);
CU_ASSERT_STRING_EQUAL(domain,linphone_address_get_domain(addr));
linphone_address_set_display_name(addr, NULL);
linphone_address_set_display_name(addr, "Mr Tester");
CU_ASSERT_STRING_EQUAL("Mr Tester",linphone_address_get_display_name(addr));
return addr;
}
void rer_test_callback()
{
RER rer = rer_create("xyz", "123", "");
CU_ASSERT_PTR_NOT_NULL_FATAL(rer);
int res=0;
rer_setcallback(rer, callback1, &res);
rer_addfile(rer, "foo");
rer_addfile(rer, "bar");
rer_addfile(rer, "baz");
rer_exec(rer);
rer_destroy(rer);
CU_ASSERT_EQUAL(res, 7);
}
void rer_test_exec()
{
RER rer = rer_create("\\d+", "abc", "");
CU_ASSERT_PTR_NOT_NULL_FATAL(rer);
int res=0;
rer_setcallback(rer, callback2, &res);
rer_addfile(rer, "foo12");
rer_addfile(rer, "bar123");
rer_addfile(rer, "baz0");
rer_exec(rer);
rer_destroy(rer);
CU_ASSERT_EQUAL(res, 7);
}
static void test_write_then_read(void)
{
fq = NULL;
int status = fq_new(&fq, QUEUE_SIZE);
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_PTR_NOT_NULL_FATAL(fq);
for (int n = 0; n < NUM_FILLS*NUM_QUEUE_FRAMES; ) {
const unsigned nwrite = MAX_FRAME_SIZE*erand48(xsubi) + 0.5;
if (nwrite) {
uint8_t* write_data = NULL;
// log_notice("Writing %u-byte frame", nwrite);
status = fq_reserve(fq, &write_data, nwrite);
CU_ASSERT_EQUAL(status, 0);
CU_ASSERT_PTR_NOT_NULL_FATAL(write_data);
int j;
for (j = 0; j < nwrite; j++)
write_data[j] = n % UCHAR_MAX;
status = fq_release(fq, nwrite);
CU_ASSERT_EQUAL(status, 0);
uint8_t* read_data = NULL;
unsigned nread = 0;
status = fq_peek(fq, &read_data, &nread);
CU_ASSERT_EQUAL(status, 0);
CU_ASSERT_EQUAL(nread, nwrite);
CU_ASSERT_PTR_EQUAL(read_data, write_data);
for (j = 0; j < nread && read_data[j] == n % UCHAR_MAX; j++)
;
CU_ASSERT_EQUAL(j, nread);
status = fq_remove(fq);
CU_ASSERT_EQUAL(status, 0);
n++;
}
}
fq_free(fq);
}
static void test_entity_without_free(void)
{
char data[] = "some entity data";
struct result* result = 0;
free_called_with = 0;
result = success_result((void*)data, 0, 0, 0);
CU_ASSERT_PTR_NOT_NULL_FATAL(result);
free_result(result);
CU_ASSERT_PTR_NULL(free_called_with);
}
