static void small_file_transfer_message(void) { int i; char* to; LinphoneChatRoom* chat_room; LinphoneChatMessage* message; LinphoneChatMessageCbs *cbs; LinphoneContent* content; const char* big_file_content="big file"; /* setting dummy file content to something */ LinphoneCoreManager* marie = linphone_core_manager_new( "marie_rc"); LinphoneCoreManager* pauline = linphone_core_manager_new( "pauline_rc"); reset_counters(&marie->stat); reset_counters(&pauline->stat); for (i=0;i<SMALL_FILE_SIZE;i+=strlen(big_file_content)) memcpy(big_file+i, big_file_content, strlen(big_file_content)); big_file[0]=*"S"; big_file[SMALL_FILE_SIZE - 1]=*"E"; /* Globally configure an http file transfer server. */ linphone_core_set_file_transfer_server(pauline->lc,"https://www.linphone.org:444/lft.php"); /* create a chatroom on pauline's side */ to = linphone_address_as_string(marie->identity); chat_room = linphone_core_create_chat_room(pauline->lc,to); ms_free(to); /* create a file transfer message */ content = linphone_core_create_content(pauline->lc); linphone_content_set_type(content,"text"); linphone_content_set_subtype(content,"plain"); linphone_content_set_size(content,SMALL_FILE_SIZE); /*total size to be transfered*/ linphone_content_set_name(content,"bigfile.txt"); message = linphone_chat_room_create_file_transfer_message(chat_room, content); { int dummy=0; wait_for_until(marie->lc,pauline->lc,&dummy,1,100); /*just to have time to purge message stored in the server*/ reset_counters(&marie->stat); reset_counters(&pauline->stat); } cbs = linphone_chat_message_get_callbacks(message); linphone_chat_message_cbs_set_msg_state_changed(cbs, liblinphone_tester_chat_message_msg_state_changed); linphone_chat_message_cbs_set_file_transfer_send(cbs, memory_file_transfer_send); linphone_chat_room_send_chat_message(chat_room,message); CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&marie->stat.number_of_LinphoneMessageReceivedWithFile,1)); if (marie->stat.last_received_chat_message ) { cbs = linphone_chat_message_get_callbacks(marie->stat.last_received_chat_message); linphone_chat_message_cbs_set_msg_state_changed(cbs, liblinphone_tester_chat_message_msg_state_changed); linphone_chat_message_cbs_set_file_transfer_recv(cbs, file_transfer_received); linphone_chat_message_download_file(marie->stat.last_received_chat_message); } CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&marie->stat.number_of_LinphoneMessageExtBodyReceived,1)); CU_ASSERT_EQUAL(pauline->stat.number_of_LinphoneMessageInProgress,1); CU_ASSERT_EQUAL(pauline->stat.number_of_LinphoneMessageDelivered,1); CU_ASSERT_EQUAL(marie->stat.number_of_LinphoneMessageExtBodyReceived,1); linphone_content_unref(content); linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); }
static void text_message_with_ack(void) { int leaked_objects; int begin; belle_sip_object_enable_leak_detector(TRUE); begin=belle_sip_object_get_object_count(); { LinphoneCoreManager* marie = linphone_core_manager_new( "marie_rc"); LinphoneCoreManager* pauline = linphone_core_manager_new( "pauline_rc"); char* to = linphone_address_as_string(marie->identity); LinphoneChatRoom* chat_room = linphone_core_create_chat_room(pauline->lc,to); LinphoneChatMessage* message = linphone_chat_room_create_message(chat_room,"Bli bli bli \n blu"); LinphoneChatMessageCbs *cbs = linphone_chat_message_get_callbacks(message); int dummy=0; wait_for_until(marie->lc,pauline->lc,&dummy,1,100); /*just to have time to purge message stored in the server*/ reset_counters(&marie->stat); reset_counters(&pauline->stat); linphone_chat_message_cbs_set_msg_state_changed(cbs, liblinphone_tester_chat_message_msg_state_changed); linphone_chat_room_send_chat_message(chat_room,message); CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&marie->stat.number_of_LinphoneMessageReceived,1)); CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&pauline->stat.number_of_LinphoneMessageDelivered,1)); CU_ASSERT_EQUAL(pauline->stat.number_of_LinphoneMessageInProgress,1); linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); } leaked_objects=belle_sip_object_get_object_count()-begin; CU_ASSERT_TRUE(leaked_objects==0); if (leaked_objects>0){ belle_sip_object_dump_active_objects(); } }
static void text_message_with_credential_from_auth_cb(void) { char* to; LinphoneChatRoom* chat_room; LinphoneCoreVTable* vtable = linphone_core_v_table_new(); LinphoneCoreManager* marie = linphone_core_manager_new("marie_rc"); LinphoneCoreManager* pauline = linphone_core_manager_new( "pauline_rc"); text_message_with_credential_from_auth_cb_auth_info=linphone_auth_info_clone((LinphoneAuthInfo*)(linphone_core_get_auth_info_list(marie->lc)->data)); /*to force cb to be called*/ linphone_core_clear_all_auth_info(marie->lc); vtable->auth_info_requested=text_message_with_credential_from_auth_cb_auth_info_requested; linphone_core_add_listener(marie->lc, vtable); to = linphone_address_as_string(marie->identity); chat_room = linphone_core_create_chat_room(pauline->lc,to); ms_free(to); { int dummy=0; wait_for_until(marie->lc,pauline->lc,&dummy,1,100); /*just to have time to purge message stored in the server*/ reset_counters(&marie->stat); reset_counters(&pauline->stat); } linphone_chat_room_send_message(chat_room,"Bla bla bla bla"); CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&marie->stat.number_of_LinphoneMessageReceived,1)); CU_ASSERT_EQUAL(marie->stat.number_of_LinphoneMessageReceivedLegacy,1); CU_ASSERT_PTR_NOT_NULL(linphone_core_get_chat_room(marie->lc,pauline->identity)); linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); }
static void text_message_with_privacy(void) { LinphoneCoreManager* marie = linphone_core_manager_new( "marie_rc"); LinphoneCoreManager* pauline = linphone_core_manager_new( "pauline_rc"); LinphoneProxyConfig* pauline_proxy; char* to = linphone_address_as_string(marie->identity); LinphoneChatRoom* chat_room = linphone_core_create_chat_room(pauline->lc,to); ms_free(to); /*test proxy config privacy*/ linphone_core_get_default_proxy(pauline->lc,&pauline_proxy); linphone_proxy_config_set_privacy(pauline_proxy,LinphonePrivacyId); CU_ASSERT_PTR_NOT_NULL(linphone_core_get_chat_room(marie->lc,pauline->identity)); { int dummy=0; wait_for_until(marie->lc,pauline->lc,&dummy,1,100); /*just to have time to purge message stored in the server*/ reset_counters(&marie->stat); reset_counters(&pauline->stat); } linphone_chat_room_send_message(chat_room,"Bla bla bla bla"); CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&marie->stat.number_of_LinphoneMessageReceived,1)); CU_ASSERT_EQUAL(marie->stat.number_of_LinphoneMessageReceivedLegacy,1); linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); }
static void text_message_denied(void) { LinphoneCoreManager* marie = linphone_core_manager_new("marie_rc"); LinphoneCoreManager* pauline = linphone_core_manager_new( "pauline_rc"); char* to = linphone_address_as_string(pauline->identity); LinphoneChatRoom* chat_room = linphone_core_create_chat_room(marie->lc,to); LinphoneChatMessage* message = linphone_chat_room_create_message(chat_room,"Bli bli bli \n blu"); LinphoneChatMessageCbs *cbs = linphone_chat_message_get_callbacks(message); /*pauline doesn't want to be disturbed*/ linphone_core_disable_chat(pauline->lc,LinphoneReasonDoNotDisturb); { int dummy=0; wait_for_until(marie->lc,pauline->lc,&dummy,1,100); /*just to have time to purge message stored in the server*/ reset_counters(&marie->stat); reset_counters(&pauline->stat); } linphone_chat_message_cbs_set_msg_state_changed(cbs,liblinphone_tester_chat_message_msg_state_changed); linphone_chat_room_send_chat_message(chat_room,message); CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&marie->stat.number_of_LinphoneMessageNotDelivered,1)); CU_ASSERT_EQUAL(pauline->stat.number_of_LinphoneMessageReceived,0); linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); }
static void text_message_within_dialog(void) { char* to; LinphoneChatRoom* chat_room; LinphoneCoreManager* marie = linphone_core_manager_new("marie_rc"); LinphoneCoreManager* pauline = linphone_core_manager_new( "pauline_rc"); lp_config_set_int(pauline->lc->config,"sip","chat_use_call_dialogs",1); to = linphone_address_as_string(marie->identity); chat_room = linphone_core_create_chat_room(pauline->lc,to); ms_free(to); { int dummy=0; wait_for_until(marie->lc,pauline->lc,&dummy,1,100); /*just to have time to purge message stored in the server*/ reset_counters(&marie->stat); reset_counters(&pauline->stat); } CU_ASSERT_TRUE(call(marie,pauline)); linphone_chat_room_send_message(chat_room,"Bla bla bla bla"); CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&marie->stat.number_of_LinphoneMessageReceived,1)); CU_ASSERT_PTR_NOT_NULL(linphone_core_get_chat_room(marie->lc,pauline->identity)); linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); }
static void text_message_with_external_body(void) { LinphoneCoreManager* marie = linphone_core_manager_new( "marie_rc"); LinphoneCoreManager* pauline = linphone_core_manager_new( "pauline_rc"); char* to = linphone_address_as_string(marie->identity); LinphoneChatRoom* chat_room = linphone_core_create_chat_room(pauline->lc,to); LinphoneChatMessage* message = linphone_chat_room_create_message(chat_room,"Bli bli bli \n blu"); LinphoneChatMessageCbs *cbs = linphone_chat_message_get_callbacks(message); linphone_chat_message_set_external_body_url(message,message_external_body_url="http://www.linphone.org"); { int dummy=0; wait_for_until(marie->lc,pauline->lc,&dummy,1,100); /*just to have time to purge message stored in the server*/ reset_counters(&marie->stat); reset_counters(&pauline->stat); } linphone_chat_message_cbs_set_msg_state_changed(cbs,liblinphone_tester_chat_message_msg_state_changed); linphone_chat_room_send_chat_message(chat_room,message); /* check transient message list: the message should be in it, and should be the only one */ CU_ASSERT_EQUAL(ms_list_size(chat_room->transient_messages), 1); CU_ASSERT_EQUAL(ms_list_nth_data(chat_room->transient_messages,0), message); CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&marie->stat.number_of_LinphoneMessageReceived,1)); CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&pauline->stat.number_of_LinphoneMessageDelivered,1)); CU_ASSERT_EQUAL(pauline->stat.number_of_LinphoneMessageInProgress,1); CU_ASSERT_EQUAL(marie->stat.number_of_LinphoneMessageExtBodyReceived,1); CU_ASSERT_EQUAL(ms_list_size(chat_room->transient_messages), 0); linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); }
void test() { { //Single element deleter reset_counters(); bml::default_delete<A> d; A* p = new A; BOOST_TEST(A::count == 1); d(p); BOOST_TEST(A::count == 0); } { //Array element deleter reset_counters(); bml::default_delete<A[]> d; A* p = new A[2]; BOOST_TEST(A::count == 2); d(p); BOOST_TEST(A::count == 0); } { //Bounded Array element deleter reset_counters(); bml::default_delete<A[10]> d; A* p = new A[10]; BOOST_TEST(A::count == 10); d(p); BOOST_TEST(A::count == 0); } }
void test() { //Single unique_ptr reset_counters(); BOOST_STATIC_ASSERT((bmupmu::is_convertible<B, A>::value)); { bml::unique_ptr<B, move_constr_deleter<B> > s(new B); A* p = s.get(); bml::unique_ptr<A, move_constr_deleter<A> > s2(boost::move(s)); BOOST_TEST(s2.get() == p); BOOST_TEST(s.get() == 0); BOOST_TEST(A::count == 1); BOOST_TEST(B::count == 1); BOOST_TEST(s2.get_deleter().state() == 5); BOOST_TEST(s.get_deleter().state() == 0); } BOOST_TEST(A::count == 0); BOOST_TEST(B::count == 0); //Unbounded array unique_ptr reset_counters(); { bml::unique_ptr<const A[], move_constr_deleter<const A[]> > s(new const A[2]); const A* p = s.get(); bml::unique_ptr<const volatile A[], move_constr_deleter<const volatile A[]> > s2(boost::move(s)); BOOST_TEST(s2.get() == p); BOOST_TEST(s.get() == 0); BOOST_TEST(A::count == 2); BOOST_TEST(s2.get_deleter().state() == 5); BOOST_TEST(s.get_deleter().state() == 0); } BOOST_TEST(A::count == 0); BOOST_TEST(B::count == 0); //Bounded array unique_ptr reset_counters(); { bml::unique_ptr<const A[2], move_constr_deleter<const A[2]> > s(new const A[2]); const A* p = s.get(); bml::unique_ptr<const volatile A[2], move_constr_deleter<const volatile A[2]> > s2(boost::move(s)); BOOST_TEST(s2.get() == p); BOOST_TEST(s.get() == 0); BOOST_TEST(A::count == 2); BOOST_TEST(s2.get_deleter().state() == 5); BOOST_TEST(s.get_deleter().state() == 0); } BOOST_TEST(A::count == 0); BOOST_TEST(B::count == 0); { bml::unique_ptr<const A[2], move_constr_deleter<const A[2]> > s(new const A[2]); const A* p = s.get(); bml::unique_ptr<const volatile A[], move_constr_deleter<const volatile A[]> > s2(boost::move(s)); BOOST_TEST(s2.get() == p); BOOST_TEST(s.get() == 0); BOOST_TEST(A::count == 2); BOOST_TEST(s2.get_deleter().state() == 5); BOOST_TEST(s.get_deleter().state() == 0); } BOOST_TEST(A::count == 0); BOOST_TEST(B::count == 0); }
static void file_transfer_message_upload_cancelled(void) { int i; char* to; LinphoneChatRoom* chat_room; LinphoneChatMessage* message; LinphoneChatMessageCbs *cbs; LinphoneContent* content; const char* big_file_content="big file"; /* setting dummy file content to something */ LinphoneCoreManager* marie = linphone_core_manager_new( "marie_rc"); LinphoneCoreManager* pauline = linphone_core_manager_new( "pauline_rc"); reset_counters(&marie->stat); reset_counters(&pauline->stat); /* setting dummy file content to something */ for (i=0;i<sizeof(big_file);i+=strlen(big_file_content)) memcpy(big_file+i, big_file_content, strlen(big_file_content)); big_file[0]=*"S"; big_file[sizeof(big_file)-1]=*"E"; /* Globally configure an http file transfer server. */ linphone_core_set_file_transfer_server(pauline->lc,"https://www.linphone.org:444/lft.php"); /* create a chatroom on pauline's side */ to = linphone_address_as_string(marie->identity); chat_room = linphone_core_create_chat_room(pauline->lc,to); /* create a file transfer message */ content = linphone_core_create_content(pauline->lc); linphone_content_set_type(content,"text"); linphone_content_set_subtype(content,"plain"); linphone_content_set_size(content,sizeof(big_file)); /*total size to be transfered*/ linphone_content_set_name(content,"bigfile.txt"); message = linphone_chat_room_create_file_transfer_message(chat_room, content); { int dummy=0; wait_for_until(marie->lc,pauline->lc,&dummy,1,100); /*just to have time to purge message stored in the server*/ reset_counters(&marie->stat); reset_counters(&pauline->stat); } cbs = linphone_chat_message_get_callbacks(message); linphone_chat_message_cbs_set_msg_state_changed(cbs, liblinphone_tester_chat_message_msg_state_changed); linphone_chat_message_cbs_set_file_transfer_send(cbs, memory_file_transfer_send); linphone_chat_message_cbs_set_file_transfer_progress_indication(cbs, file_transfer_progress_indication); linphone_chat_room_send_chat_message(chat_room,message); /*wait for file to be 50% uploaded and cancel the transfer */ CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&pauline->stat.progress_of_LinphoneFileTransfer, 50)); linphone_chat_message_cancel_file_transfer(message); CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&pauline->stat.number_of_LinphoneMessageNotDelivered,1)); CU_ASSERT_EQUAL(pauline->stat.number_of_LinphoneMessageNotDelivered,1); CU_ASSERT_EQUAL(marie->stat.number_of_LinphoneMessageExtBodyReceived,0); linphone_content_unref(content); linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); }
void test() { //Single unique_ptr reset_counters(); { B* p = new B; BOOST_TEST(A::count == 1); BOOST_TEST(B::count == 1); bml::unique_ptr<A> s(p); BOOST_TEST(s.get() == p); } BOOST_TEST(A::count == 0); BOOST_TEST(B::count == 0); { B* p = new B; BOOST_TEST(A::count == 1); BOOST_TEST(B::count == 1); bml::unique_ptr<A, def_constr_deleter<A> > s(p); BOOST_TEST(s.get() == p); BOOST_TEST(s.get_deleter().state() == 5); } BOOST_TEST(A::count == 0); BOOST_TEST(B::count == 0); //Unbounded array unique_ptr reset_counters(); { A* p = new A[2]; BOOST_TEST(A::count == 2); bml::unique_ptr<const A[]> s(p); BOOST_TEST(s.get() == p); } BOOST_TEST(A::count == 0); { const A* p = new const A[2]; BOOST_TEST(A::count == 2); bml::unique_ptr<const volatile A[], def_constr_deleter<const volatile A[]> > s(p); BOOST_TEST(s.get() == p); BOOST_TEST(s.get_deleter().state() == 5); } BOOST_TEST(A::count == 0); //Bounded array unique_ptr reset_counters(); { A* p = new A[2]; BOOST_TEST(A::count == 2); bml::unique_ptr<const A[2]> s(p); BOOST_TEST(s.get() == p); } BOOST_TEST(A::count == 0); { const A* p = new const A[2]; BOOST_TEST(A::count == 2); bml::unique_ptr<const volatile A[2], def_constr_deleter<const volatile A[2]> > s(p); BOOST_TEST(s.get() == p); BOOST_TEST(s.get_deleter().state() == 5); } BOOST_TEST(A::count == 0); }
void test() { //Single unique_ptr reset_counters(); { I* p = get(); check(1); J<I> s(p); BOOST_TEST(s.get() == p); } check(0); { I* p = get(); check(1); J<I, def_constr_deleter<I> > s(p); BOOST_TEST(s.get() == p); BOOST_TEST(s.get_deleter().state() == 5); } check(0); //Unbounded array unique_ptr reset_counters(); { I* p = get_array(2); check(2); J<I[]> s(p); BOOST_TEST(s.get() == p); } check(0); { I* p = get_array(2); check(2); J<I[], def_constr_deleter<I[]> > s(p); BOOST_TEST(s.get() == p); BOOST_TEST(s.get_deleter().state() == 5); } check(0); //Bounded array unique_ptr reset_counters(); { I* p = get_array(2); check(2); J<I[]> s(p); BOOST_TEST(s.get() == p); } check(0); { I* p = get_array(2); check(2); J<I[2], def_constr_deleter<I[2]> > s(p); BOOST_TEST(s.get() == p); BOOST_TEST(s.get_deleter().state() == 5); } check(0); }
static void info_message_with_args(bool_t with_content) { LinphoneCoreManager* marie = linphone_core_manager_new( "marie_rc"); LinphoneCoreManager* pauline = linphone_core_manager_new( "pauline_rc"); LinphoneInfoMessage *info; const LinphoneContent *content; const char *hvalue; CU_ASSERT_TRUE(call(pauline,marie)); info=linphone_core_create_info_message(marie->lc); linphone_info_message_add_header(info,"Weather","still bad"); if (with_content) { LinphoneContent* ct=linphone_core_create_content(marie->lc); linphone_content_set_type(ct,"application"); linphone_content_set_subtype(ct,"somexml"); linphone_content_set_buffer(ct,info_content,strlen(info_content)); linphone_info_message_set_content(info,ct); linphone_content_unref(ct); } { int dummy=0; wait_for_until(marie->lc,pauline->lc,&dummy,1,100); /*just to have time to purge message stored in the server*/ reset_counters(&marie->stat); reset_counters(&pauline->stat); } linphone_call_send_info_message(linphone_core_get_current_call(marie->lc),info); linphone_info_message_destroy(info); CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&pauline->stat.number_of_inforeceived,1)); CU_ASSERT_PTR_NOT_NULL(pauline->stat.last_received_info_message); hvalue=linphone_info_message_get_header(pauline->stat.last_received_info_message, "Weather"); content=linphone_info_message_get_content(pauline->stat.last_received_info_message); CU_ASSERT_PTR_NOT_NULL(hvalue); if (hvalue) CU_ASSERT_TRUE(strcmp(hvalue,"still bad")==0); if (with_content){ CU_ASSERT_PTR_NOT_NULL(content); if (content) { CU_ASSERT_PTR_NOT_NULL(linphone_content_get_buffer(content)); CU_ASSERT_PTR_NOT_NULL(linphone_content_get_type(content)); CU_ASSERT_PTR_NOT_NULL(linphone_content_get_subtype(content)); if (linphone_content_get_type(content)) CU_ASSERT_TRUE(strcmp(linphone_content_get_type(content),"application")==0); if (linphone_content_get_subtype(content)) CU_ASSERT_TRUE(strcmp(linphone_content_get_subtype(content),"somexml")==0); if (linphone_content_get_buffer(content))CU_ASSERT_TRUE(strcmp((const char*)linphone_content_get_buffer(content),info_content)==0); CU_ASSERT_EQUAL(linphone_content_get_size(content),strlen(info_content)); } } linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); }
void test() { //Single unique_ptr reset_counters(); { def_constr_deleter<A> d; bml::unique_ptr<A, def_constr_deleter<A>&> s(new A, d); A* p = s.get(); bml::unique_ptr<A, def_constr_deleter<A>&> s2 = boost::move(s); BOOST_TEST(s2.get() == p); BOOST_TEST(s.get() == 0); BOOST_TEST(A::count == 1); d.set_state(6); BOOST_TEST(s2.get_deleter().state() == d.state()); BOOST_TEST(s.get_deleter().state() == d.state()); } BOOST_TEST(A::count == 0); //Unbounded array unique_ptr reset_counters(); { def_constr_deleter<A[]> d; bml::unique_ptr<A[], def_constr_deleter<A[]>&> s(new A[2], d); A* p = s.get(); bml::unique_ptr<A[], def_constr_deleter<A[]>&> s2 = boost::move(s); BOOST_TEST(s2.get() == p); BOOST_TEST(s.get() == 0); BOOST_TEST(A::count == 2); d.set_state(6); BOOST_TEST(s2.get_deleter().state() == d.state()); BOOST_TEST(s.get_deleter().state() == d.state()); } BOOST_TEST(A::count == 0); //Bounded array unique_ptr reset_counters(); { def_constr_deleter<A[2]> d; bml::unique_ptr<A[2], def_constr_deleter<A[2]>&> s(new A[2], d); A* p = s.get(); bml::unique_ptr<A[2], def_constr_deleter<A[2]>&> s2(boost::move(s)); BOOST_TEST(s2.get() == p); BOOST_TEST(s.get() == 0); BOOST_TEST(A::count == 2); d.set_state(6); BOOST_TEST(s2.get_deleter().state() == d.state()); BOOST_TEST(s.get_deleter().state() == d.state()); } BOOST_TEST(A::count == 0); }
void test() { //Single unique_ptr reset_counters(); { bml::unique_ptr<B> s(new B); A* p = s.get(); bml::unique_ptr<A> s2(boost::move(s)); BOOST_TEST(s2.get() == p); BOOST_TEST(s.get() == 0); BOOST_TEST(A::count == 1); BOOST_TEST(B::count == 1); } BOOST_TEST(A::count == 0); BOOST_TEST(B::count == 0); //Unbounded array unique_ptr reset_counters(); { bml::unique_ptr<A[]> s(new A[2]); A* p = s.get(); bml::unique_ptr<const volatile A[]> s2(boost::move(s)); BOOST_TEST(s2.get() == p); BOOST_TEST(s.get() == 0); BOOST_TEST(A::count == 2); } BOOST_TEST(A::count == 0); //Bounded array unique_ptr reset_counters(); { bml::unique_ptr<A[2]> s(new A[2]); A* p = s.get(); bml::unique_ptr<const volatile A[2]> s2(boost::move(s)); BOOST_TEST(s2.get() == p); BOOST_TEST(s.get() == 0); BOOST_TEST(A::count == 2); } BOOST_TEST(A::count == 0); { bml::unique_ptr<A[2]> s(new A[2]); A* p = s.get(); bml::unique_ptr<const volatile A[]> s2(boost::move(s)); BOOST_TEST(s2.get() == p); BOOST_TEST(s.get() == 0); BOOST_TEST(A::count == 2); } BOOST_TEST(A::count == 0); }
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); }
static void proxy_transport_change(){ LinphoneCoreManager* lcm = create_lcm(); stats* counters = &lcm->stat; LinphoneProxyConfig* proxy_config; LinphoneAddress* addr; char* addr_as_string; LinphoneAuthInfo *info=linphone_auth_info_new(test_username,NULL,test_password,NULL,auth_domain,NULL); /*create authentication structure from identity*/ linphone_core_add_auth_info(lcm->lc,info); /*add authentication info to LinphoneCore*/ register_with_refresh_base(lcm->lc,FALSE,auth_domain,NULL); linphone_core_get_default_proxy(lcm->lc,&proxy_config); reset_counters(counters); /*clear stats*/ linphone_proxy_config_edit(proxy_config); CU_ASSERT_FALSE(wait_for_until(lcm->lc,lcm->lc,&counters->number_of_LinphoneRegistrationCleared,1,3000)); addr = linphone_address_new(linphone_proxy_config_get_addr(proxy_config)); if (LinphoneTransportTcp == linphone_address_get_transport(addr)) { linphone_address_set_transport(addr,LinphoneTransportUdp); } else { linphone_address_set_transport(addr,LinphoneTransportTcp); } linphone_proxy_config_set_server_addr(proxy_config,addr_as_string=linphone_address_as_string(addr)); linphone_proxy_config_done(proxy_config); CU_ASSERT(wait_for(lcm->lc,lcm->lc,&counters->number_of_LinphoneRegistrationOk,1)); /*as we change p[roxy server destination, we should'nt be notified about the clear*/ CU_ASSERT_EQUAL(counters->number_of_LinphoneRegistrationCleared,0); ms_free(addr_as_string); linphone_address_destroy(addr); linphone_core_manager_destroy(lcm); }
midpoint_eval_data_d(int mp) : SolverDoublePrecision(mp){ this->MPType = mp; reset_counters(); init(); }
midpoint_eval_data_mp(int mp) : SolverMultiplePrecision(mp){ this->MPType = mp; reset_counters(); init(); }
int reset_for_samplerate (REAL new_samplerate) { unsigned int thread; for(thread=0; thread<3; thread++) { safefree ((char *) top[thread].hold.buf.r); safefree ((char *) top[thread].hold.buf.l); safefree ((char *) top[thread].hold.aux.r); safefree ((char *) top[thread].hold.aux.l); destroy_workspace (thread); loc[thread].def.rate = uni[thread].samplerate = new_samplerate; top[thread].swch.env.fall.size = (int)(loc[thread].def.rate * 0.005); top[thread].swch.env.stdy.size = (int)(loc[thread].def.rate * 0.050); top[thread].swch.env.rise.size = (int)(loc[thread].def.rate * 0.005); top[thread].swch.env.curr.val = 0.0; top[thread].swch.env.curr.cnt = 0; top[thread].swch.env.fall.incr = 1.0f/(float)top[thread].swch.env.fall.size; top[thread].swch.env.rise.incr = 1.0f/(float)top[thread].swch.env.rise.size; setup_workspace (loc[thread].def.rate, loc[thread].def.size, loc[thread].def.mode, loc[thread].path.wisdom, loc[thread].def.spec, loc[thread].def.nrx, loc[thread].def.size,thread); setup_local_audio (thread); reset_meters (thread); reset_spectrum (thread); reset_counters (thread); } return 0; }
int reset_for_buflen (unsigned int thread, int new_buflen) { // make sure new size is power of 2 if (popcnt (new_buflen) != 1) return -1; reset_buflen = TRUE; uni[thread].buflen = new_buflen; top[thread].jack.reset_size = new_buflen; safefree ((char *) top[thread].hold.buf.r); safefree ((char *) top[thread].hold.buf.l); safefree ((char *) top[thread].hold.aux.r); safefree ((char *) top[thread].hold.aux.l); destroy_workspace (thread); reset_buflen = FALSE; loc[thread].def.size = new_buflen; setup_workspace (loc[thread].def.rate, loc[thread].def.size, loc[thread].def.mode, loc[thread].path.wisdom, loc[thread].def.spec, loc[thread].def.nrx, loc[thread].def.size, thread); setup_local_audio (thread); reset_meters (thread); reset_spectrum (thread); reset_counters (thread); return 0; }
int sysctl_coverage_op(xen_sysctl_coverage_op_t *op) { int ret = -EINVAL; write_iter_t iter; switch ( op->cmd ) { case XEN_SYSCTL_COVERAGE_get_total_size: iter.real = 0; write_gcov(&iter); op->u.total_size = iter.write_offset; ret = 0; break; case XEN_SYSCTL_COVERAGE_read_and_reset: case XEN_SYSCTL_COVERAGE_read: iter.ptr = op->u.raw_info; iter.real = 1; ret = write_gcov(&iter); if ( ret || op->cmd != XEN_SYSCTL_COVERAGE_read_and_reset ) break; /* fall through */ case XEN_SYSCTL_COVERAGE_reset: ret = reset_counters(); break; } return ret; }
/** * Description not yet available. * \param */ void local_init_var::end_local_calculations(void) { local_dep_var::deallocate_all(); reset_counters(); f1b2gradlist=globalf1b2gradlist; df1b2_gradlist::set_yes_derivatives(); df1b2variable::restore_adpool_pointer(); }
nullspacejac_eval_data_d & operator=(const nullspacejac_eval_data_d & other) { clear(); // this is wasteful, but safe for now reset_counters();// this is wasteful, but safe for now copy(other); return *this; }
static void register_with_refresh_base_3(LinphoneCore* lc , bool_t refresh ,const char* domain ,const char* route ,bool_t late_auth_info ,LCSipTransports transport ,LinphoneRegistrationState expected_final_state) { int retry=0; char* addr; LinphoneProxyConfig* proxy_cfg; stats* counters; LinphoneAddress *from; const char* server_addr; LinphoneAuthInfo *info; BC_ASSERT_PTR_NOT_NULL(lc); if (!lc) return; counters = get_stats(lc); reset_counters(counters); linphone_core_set_sip_transports(lc,&transport); proxy_cfg = linphone_proxy_config_new(); from = create_linphone_address(domain); linphone_proxy_config_set_identity(proxy_cfg,addr=linphone_address_as_string(from)); ms_free(addr); server_addr = linphone_address_get_domain(from); linphone_proxy_config_enable_register(proxy_cfg,TRUE); linphone_proxy_config_set_expires(proxy_cfg,1); if (route) { linphone_proxy_config_set_route(proxy_cfg,route); linphone_proxy_config_set_server_addr(proxy_cfg,route); } else { linphone_proxy_config_set_server_addr(proxy_cfg,server_addr); } linphone_address_destroy(from); linphone_core_add_proxy_config(lc,proxy_cfg); linphone_core_set_default_proxy(lc,proxy_cfg); while (counters->number_of_LinphoneRegistrationOk<1+(refresh!=0) && retry++ <(1100 /*only wait 11 s if final state is progress*/+(expected_final_state==LinphoneRegistrationProgress?0:2000))) { linphone_core_iterate(lc); if (counters->number_of_auth_info_requested>0 && linphone_proxy_config_get_state(proxy_cfg) == LinphoneRegistrationFailed && late_auth_info) { if (!linphone_core_get_auth_info_list(lc)) { BC_ASSERT_EQUAL(linphone_proxy_config_get_error(proxy_cfg),LinphoneReasonUnauthorized, int, "%d"); info=linphone_auth_info_new(test_username,NULL,test_password,NULL,auth_domain,NULL); /*create authentication structure from identity*/ linphone_core_add_auth_info(lc,info); /*add authentication info to LinphoneCore*/ } } if (linphone_proxy_config_get_error(proxy_cfg) == LinphoneReasonBadCredentials || (counters->number_of_auth_info_requested>2 &&linphone_proxy_config_get_error(proxy_cfg) == LinphoneReasonUnauthorized)) /*no need to continue if auth cannot be found*/ break; /*no need to continue*/ ms_usleep(10000); }
void test() { //Single unique_ptr reset_counters(); { A* p = new A; BOOST_TEST(A::count == 1); move_constr_deleter<A> d; bml::unique_ptr<A, move_constr_deleter<A> > s(p, ::boost::move(d)); BOOST_TEST(s.get() == p); BOOST_TEST(s.get_deleter().state() == 5); bml::unique_ptr<A, move_constr_deleter<A> > s2(s.release(), move_constr_deleter<A>(6)); BOOST_TEST(s2.get() == p); BOOST_TEST(s2.get_deleter().state() == 6); } BOOST_TEST(A::count == 0); //Unbounded array unique_ptr reset_counters(); { A* p = new A[2]; BOOST_TEST(A::count == 2); move_constr_deleter<A[]> d; bml::unique_ptr<A[], move_constr_deleter<A[]> > s(p, ::boost::move(d)); BOOST_TEST(s.get() == p); BOOST_TEST(s.get_deleter().state() == 5); bml::unique_ptr<A[], move_constr_deleter<A[]> > s2(s.release(), move_constr_deleter<A[]>(6)); BOOST_TEST(s2.get() == p); BOOST_TEST(s2.get_deleter().state() == 6); } BOOST_TEST(A::count == 0); //Bounded array unique_ptr reset_counters(); { A* p = new A[2]; BOOST_TEST(A::count == 2); move_constr_deleter<A[2]> d; bml::unique_ptr<A[2], move_constr_deleter<A[2]> > s(p, ::boost::move(d)); BOOST_TEST(s.get() == p); BOOST_TEST(s.get_deleter().state() == 5); bml::unique_ptr<A[2], move_constr_deleter<A[2]> > s2(s.release(), move_constr_deleter<A[2]>(6)); BOOST_TEST(s2.get() == p); BOOST_TEST(s2.get_deleter().state() == 6); } BOOST_TEST(A::count == 0); }
//======================================================================== void setup () { unsigned int thread; //fprintf(stderr,"I am inside setup\n"),fflush(stderr); for (thread=0;thread<3;thread++) { top[thread].pid = GetCurrentThreadId (); top[thread].uid = 0L; top[thread].start_tv = now_tv (); top[thread].running = TRUE; top[thread].verbose = FALSE; if (thread != 1) top[thread].state = RUN_PLAY; else top[thread].state = RUN_PASS; top[thread].offset = 0; top[thread].jack.reset_size = 2048; reset_em =TRUE; setup_defaults (thread); //fprintf(stderr,"setup: defaults done thread %u\n", thread),fflush(stderr); uni[thread].meter.flag = TRUE; uni[thread].spec.flag = TRUE; top[thread].swch.env.fall.size = (int)(loc[thread].def.rate * 0.005); top[thread].swch.env.stdy.size = (int)(loc[thread].def.rate * 0.050); top[thread].swch.env.rise.size = (int)(loc[thread].def.rate * 0.005); top[thread].swch.env.curr.val = 0.0; top[thread].swch.env.curr.cnt = 0; top[thread].swch.env.rise.incr = 1.0f/(float)top[thread].swch.env.rise.size; top[thread].swch.env.fall.incr = 1.0f/(float)top[thread].swch.env.fall.size; //fprintf(stderr,"setup: switch done\n"),fflush(stderr); //fprintf(stderr,"setup: Entering workspace setup, thread %u\n", thread),fflush(stderr); setup_workspace (loc[thread].def.rate, loc[thread].def.size, loc[thread].def.mode, loc[thread].path.wisdom, loc[thread].def.spec, loc[thread].def.nrx, loc[thread].def.comp, thread); //fprintf(stderr,"setup: workspace done thread %u\n", thread),fflush(stderr); setup_local_audio (thread); //fprintf(stderr,"setup: setup_local_audio done\n"),fflush(stderr); setup_system_audio (thread); //fprintf(stderr,"setup: setup_system_audio done\n"),fflush(stderr); setup_threading (thread); //fprintf(stderr,"setup: threading done\n"),fflush(stderr); // setup_switching (); uni[thread].spec.flag = TRUE; uni[thread].spec.type = SPEC_POST_FILT; uni[thread].spec.scale = SPEC_PWR; uni[thread].spec.rxk = 0; reset_meters (thread); reset_spectrum (thread); reset_counters (thread); //fprintf(stderr,"setup sdr thread %0u: done\n",thread),fflush(stderr); } }
/* * print_reset_counters -- print and then zero all counters */ static void print_reset_counters(const char *task) { UT_OUT("%d\t;%d\t;%d\t;%d\t;%s", ops_counter.n_persist, ops_counter.n_msync, ops_counter.n_flush, ops_counter.n_drain, task); reset_counters(); }
static void text_message_compatibility_mode(void) { char route[256]; LinphoneCoreManager* marie = linphone_core_manager_new( "marie_rc"); LinphoneCoreManager* pauline = linphone_core_manager_new( "pauline_rc"); LinphoneProxyConfig* proxy; LinphoneAddress* proxy_address; char*tmp; LCSipTransports transport; char* to = linphone_address_as_string(pauline->identity); LinphoneChatRoom* chat_room; linphone_core_get_default_proxy(marie->lc,&proxy); CU_ASSERT_PTR_NOT_NULL (proxy); proxy_address=linphone_address_new(linphone_proxy_config_get_addr(proxy)); linphone_address_clean(proxy_address); tmp=linphone_address_as_string_uri_only(proxy_address); linphone_proxy_config_set_server_addr(proxy,tmp); sprintf(route,"sip:%s",test_route); linphone_proxy_config_set_route(proxy,route); ms_free(tmp); linphone_address_destroy(proxy_address); linphone_core_get_sip_transports(marie->lc,&transport); transport.udp_port=0; transport.tls_port=0; transport.dtls_port=0; /*only keep tcp*/ linphone_core_set_sip_transports(marie->lc,&transport); marie->stat.number_of_LinphoneRegistrationOk=0; CU_ASSERT_TRUE (wait_for(marie->lc,marie->lc,&marie->stat.number_of_LinphoneRegistrationOk,1)); chat_room = linphone_core_create_chat_room(marie->lc,to); { int dummy=0; wait_for_until(marie->lc,pauline->lc,&dummy,1,100); /*just to have time to purge message stored in the server*/ reset_counters(&marie->stat); reset_counters(&pauline->stat); } linphone_chat_room_send_message(chat_room,"Bla bla bla bla"); CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&pauline->stat.number_of_LinphoneMessageReceived,1)); CU_ASSERT_EQUAL(pauline->stat.number_of_LinphoneMessageReceivedLegacy,1); linphone_core_manager_destroy(marie); linphone_core_manager_destroy(pauline); }
LinphoneCoreManager* linphone_core_manager_new2(const char* rc_file, int check_for_proxies) { LinphoneCoreManager* mgr= ms_new0(LinphoneCoreManager,1); LinphoneProxyConfig* proxy; char *rc_path = NULL; int proxy_count; mgr->v_table.registration_state_changed=registration_state_changed; mgr->v_table.auth_info_requested=auth_info_requested; mgr->v_table.call_state_changed=call_state_changed; mgr->v_table.text_received=text_message_received; mgr->v_table.message_received=message_received; mgr->v_table.file_transfer_recv=file_transfer_received; mgr->v_table.file_transfer_send=file_transfer_send; mgr->v_table.file_transfer_progress_indication=file_transfer_progress_indication; mgr->v_table.is_composing_received=is_composing_received; mgr->v_table.new_subscription_requested=new_subscription_requested; mgr->v_table.notify_presence_received=notify_presence_received; mgr->v_table.transfer_state_changed=linphone_transfer_state_changed; mgr->v_table.info_received=info_message_received; mgr->v_table.subscription_state_changed=linphone_subscription_state_change; mgr->v_table.notify_received=linphone_notify_received; mgr->v_table.publish_state_changed=linphone_publish_state_changed; mgr->v_table.configuring_status=linphone_configuration_status; mgr->v_table.call_encryption_changed=linphone_call_encryption_changed; mgr->v_table.network_reachable=network_reachable; reset_counters(&mgr->stat); if (rc_file) rc_path = ms_strdup_printf("rcfiles/%s", rc_file); mgr->lc=configure_lc_from(&mgr->v_table, liblinphone_tester_file_prefix, rc_path, mgr); /*CU_ASSERT_EQUAL(ms_list_size(linphone_core_get_proxy_config_list(lc)),proxy_count);*/ if (check_for_proxies && rc_file) /**/ proxy_count=ms_list_size(linphone_core_get_proxy_config_list(mgr->lc)); else proxy_count=0; #if TARGET_OS_IPHONE linphone_core_set_playback_device( mgr->lc, "AU: Audio Unit Tester"); linphone_core_set_capture_device( mgr->lc, "AU: Audio Unit Tester"); linphone_core_set_ringer_device( mgr->lc, "AQ: Audio Queue Device"); linphone_core_set_ringback(mgr->lc, NULL); #endif if (proxy_count) wait_for_until(mgr->lc,NULL,&mgr->stat.number_of_LinphoneRegistrationOk,proxy_count,5000*proxy_count); CU_ASSERT_EQUAL(mgr->stat.number_of_LinphoneRegistrationOk,proxy_count); enable_codec(mgr->lc,"PCMU",8000); linphone_core_get_default_proxy(mgr->lc,&proxy); if (proxy) { mgr->identity = linphone_address_new(linphone_proxy_config_get_identity(proxy)); linphone_address_clean(mgr->identity); } if (rc_path) ms_free(rc_path); return mgr; }