自学教程：C++ test_print函数代码示例

static void bmk7_execute(void) {  uint32_t n;  threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriority()+5, thread3, NULL);  threads[1] = chThdCreateStatic(wa[1], WA_SIZE, chThdGetPriority()+4, thread3, NULL);  threads[2] = chThdCreateStatic(wa[2], WA_SIZE, chThdGetPriority()+3, thread3, NULL);  threads[3] = chThdCreateStatic(wa[3], WA_SIZE, chThdGetPriority()+2, thread3, NULL);  threads[4] = chThdCreateStatic(wa[4], WA_SIZE, chThdGetPriority()+1, thread3, NULL);  n = 0;  test_wait_tick();  test_start_timer(1000);  do {    chSemReset(&sem1, 0);    n++;#if defined(SIMULATOR)    ChkIntSources();#endif  } while (!test_timer_done);  test_terminate_threads();  chSemReset(&sem1, 0);  test_wait_threads();  test_print("--- Score : ");  test_printn(n);  test_print(" reschedules/S, ");  test_printn(n * 6);  test_println(" ctxswc/S");}

static void bmk2_execute(void) {  uint32_t n;  threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriority()+1, thread1, NULL);  n = msg_loop_test(threads[0]);  test_wait_threads();  test_print("--- Score : ");  test_printn(n);  test_print(" msgs/S, ");  test_printn(n << 1);  test_println(" ctxswc/S");}

static FlowPacket *write_to_shunt (FlowShunt *shunt, gpointer data){  FlowPacket *packet;  guint       pause_ms;  if (writes_are_blocked)    test_end (TEST_RESULT_FAILED, "got write while blocked");  if (data != shunt)    test_end (TEST_RESULT_FAILED, "write callback user_data does not match");  if (finished_writing)    test_end (TEST_RESULT_FAILED, "got write callback after sending end-of-stream");  if (src_index == BUFFER_SIZE)  {    packet = flow_create_simple_event_packet (FLOW_STREAM_DOMAIN, FLOW_STREAM_END);    finished_writing = TRUE;    flow_shunt_block_writes (shunt);    test_print ("Write: End of stream marker/n");  }  else  {    guint len;    len = g_random_int_range (PACKET_MIN_SIZE, PACKET_MAX_SIZE + 1);    if (src_index + len > BUFFER_SIZE)      len = BUFFER_SIZE - src_index;    packet = flow_packet_new (FLOW_PACKET_FORMAT_BUFFER, buffer + src_index, len);    test_print ("Write: %d byte packet at offset %d/n", len, src_index);    src_index += len;  }  if (!packet)    test_end (TEST_RESULT_FAILED, "failed to create a packet");  pause_ms = get_pause_interval_ms ();  if (pause_ms > 0)  {    test_print ("Blocking writes for %.2fs/n", (float) pause_ms / 1000.0);    writes_are_blocked = TRUE;    flow_shunt_block_writes (shunt);    g_timeout_add (pause_ms, (GSourceFunc) write_pause_ended, shunt);  }  return packet;}

static voidresolved (GList *addr_list, GList *name_list, FlowIPResolver *ip_resolver){  GList *l;  if (!name_list && addr_list)  {    for (l = addr_list; l; l = g_list_next (l))    {      FlowIPAddr *ip_addr     = l->data;      gchar      *ip_addr_str = flow_ip_addr_get_string (ip_addr);      test_print ("%-20.20s -> %s/n", "[NULL]", ip_addr_str);      g_free (ip_addr_str);    }  }  else if (name_list && !addr_list)  {    for (l = name_list; l; l = g_list_next (l))    {      gchar *name = l->data;      test_print ("%-20.20s -> %s/n", name, "[NULL]");    }  }  else if (!name_list && !addr_list)  {    test_end (TEST_RESULT_FAILED, "none-to-none resolution");  }  else  /* name_list && addr_list */  {    for ( ; name_list; name_list = g_list_next (name_list))    {      gchar *name = name_list->data;      for (l = addr_list; l; l = g_list_next (l))      {        FlowIPAddr *ip_addr     = l->data;        gchar      *ip_addr_str = flow_ip_addr_get_string (ip_addr);        test_print ("%-20.20s -> %s/n", name, ip_addr_str);        g_free (ip_addr_str);      }    }  }  to_resolve--;  if (!to_resolve)    test_quit_main_loop ();}

static void do_test(char *buf, size_t len){    int i, j;    char *code;    protect_mem(buf, len, ALLOW_READ|ALLOW_WRITE);    for (i = 0; i < 7; i++) {        for (j = 0; j < 7; j++) {            code = copy_to_buf(buf, len, NULL, CODE_INC, COPY_NORMAL);             protect_mem_check(buf, len, prot_codes[i], ALLOW_READ|ALLOW_WRITE);            protect_mem_check(buf, len, prot_codes[j], prot_codes[i]);            test_print(code, 5);            test_print(code, 2);            if (j > 1 && j < 6) {                code = copy_to_buf(buf, len, NULL, CODE_DEC, COPY_NORMAL);                test_print(code, 3);                test_print(code, 1);                code = copy_to_buf(buf, len, NULL, CODE_SELF_MOD, COPY_NORMAL);                test_print(code, 43981);                test_print(code, 4660);            }            buf++;            len--;            if (j > 1 && j < 6) {                protect_mem_check(buf, len, ALLOW_READ|ALLOW_WRITE, prot_codes[j]);                code = copy_to_buf(buf, len, NULL, CODE_SELF_MOD, COPY_NORMAL);                protect_mem_check(buf, len, prot_codes[i], ALLOW_READ|ALLOW_WRITE);                protect_mem_check(buf, len, prot_codes[j], prot_codes[i]);                test_print(code, 4660);                test_print(code, 43981);            }            protect_mem_check(buf, len, ALLOW_READ|ALLOW_WRITE, prot_codes[j]);        }    }}

static void bmk13_execute(void) {  test_print("--- System: ");  test_printn(sizeof(ReadyList) + sizeof(VTList) +              PORT_IDLE_THREAD_STACK_SIZE +              (sizeof(Thread) + sizeof(struct intctx) +               sizeof(struct extctx) +               PORT_INT_REQUIRED_STACK) * 2);  test_println(" bytes");  test_print("--- Thread: ");  test_printn(sizeof(Thread));  test_println(" bytes");  test_print("--- Timer : ");  test_printn(sizeof(VirtualTimer));  test_println(" bytes");#if CH_USE_SEMAPHORES || defined(__DOXYGEN__)  test_print("--- Semaph: ");  test_printn(sizeof(Semaphore));  test_println(" bytes");#endif#if CH_USE_EVENTS || defined(__DOXYGEN__)  test_print("--- EventS: ");  test_printn(sizeof(EventSource));  test_println(" bytes");  test_print("--- EventL: ");  test_printn(sizeof(EventListener));  test_println(" bytes");#endif#if CH_USE_MUTEXES || defined(__DOXYGEN__)  test_print("--- Mutex : ");  test_printn(sizeof(Mutex));  test_println(" bytes");#endif#if CH_USE_CONDVARS || defined(__DOXYGEN__)  test_print("--- CondV.: ");  test_printn(sizeof(CondVar));  test_println(" bytes");#endif#if CH_USE_QUEUES || defined(__DOXYGEN__)  test_print("--- Queue : ");  test_printn(sizeof(GenericQueue));  test_println(" bytes");#endif#if CH_USE_MAILBOXES || defined(__DOXYGEN__)  test_print("--- MailB.: ");  test_printn(sizeof(Mailbox));  test_println(" bytes");#endif}

intmain(int argc, char **argv){	unif01_Gen *gen;	int rc;	gen = unif01_CreateExternGenBits("arc4random", arc4random);	/* XXX: The following battery does not set pVal, so we cannot check	 * the results. */	bbattery_FIPS_140_2(gen);	/* XXX: The following battery fails one test. */	bbattery_pseudoDIEHARD(gen);	test_battery_result();	bbattery_Rabbit(gen, 33554432);	test_battery_result();	bbattery_SmallCrush(gen);	test_battery_result();	unif01_DeleteExternGenBits(gen);	if (test_failed) {		test_print("failed tests = %d", test_failed);		/* XXX: We should probably FAIL the test, but we currently		 * have one test always failing. */		rc = TEST_SKIP;	} else {		rc = TEST_OK;	}	return rc;}

static voidtest_battery_result(void){	char **testNames = bbattery_TestNames;	double *pVal = bbattery_pVal;	double pSuspect = 0.001;	test_print("bbattery_NTests = %d", bbattery_NTests);	for (int i = 0; i < bbattery_NTests; i++) {		/* That test was not done: pVal = -1. */		if (pVal[i] < 0.0) {			test_res(i, testNames, pVal, "SKIP");			continue;		}		/* That test passed or failed. */		if ((pVal[i] >= pSuspect) &&		    (pVal[i] <= 1.0 - pSuspect)) {			test_res(i, testNames, pVal, "PASS");		} else {			test_res(i, testNames, pVal, "FAIL");			test_failed++;		}	}}

static void bmk9_execute(void) {  uint32_t n;  static uint8_t ib[16];  static InputQueue iq;  chIQInit(&iq, ib, sizeof(ib), NULL);  n = 0;  test_wait_tick();  test_start_timer(1000);  do {    chIQPutI(&iq, 0);    chIQPutI(&iq, 1);    chIQPutI(&iq, 2);    chIQPutI(&iq, 3);    (void)chIQGet(&iq);    (void)chIQGet(&iq);    (void)chIQGet(&iq);    (void)chIQGet(&iq);    n++;#if defined(SIMULATOR)    ChkIntSources();#endif  } while (!test_timer_done);  test_print("--- Score : ");  test_printn(n * 4);  test_println(" bytes/S");}

static void bmk4_execute(void) {  Thread *tp;  uint32_t n;  tp = threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriority()+1, thread4, NULL);  n = 0;  test_wait_tick();  test_start_timer(1000);  do {    chSysLock();    chSchWakeupS(tp, RDY_OK);    chSchWakeupS(tp, RDY_OK);    chSchWakeupS(tp, RDY_OK);    chSchWakeupS(tp, RDY_OK);    chSysUnlock();    n += 4;#if defined(SIMULATOR)    ChkIntSources();#endif  } while (!test_timer_done);  chSysLock();  chSchWakeupS(tp, RDY_TIMEOUT);  chSysUnlock();  test_wait_threads();  test_print("--- Score : ");  test_printn(n * 2);  test_println(" ctxswc/S");}

void test_print(MdsObject* r){	if (!r)	{		cout << "something error" << endl;		return;	}	switch (r->obj_type)	{		case Type_Int:{					  MdsIntObject* res1 = (MdsIntObject*)r;					  cout << res1->get_value() << endl;					  break;		}		case Type_String:{						 MdsStringObject* res2 = (MdsStringObject*)r;						 cout << res2->get_value() << endl;						 break;		}		case Type_List:{					   MdsListObject* res3 = (MdsListObject*)r;					   vector<MdsObject*> vec = res3->get_value();					   cout << "[" << endl;					   for (size_t i = 0; i < vec.size(); i++)					   {						   cout << '/t';						   test_print(vec[i]);					   }					   cout << "]" << endl;					   break;		}	}}

static voidlist_member_print_and_free (gchar *member,                            gpointer user_data){	test_print ("    %s/n", member);	g_free (member);}

static voidtest_get_supported_fields_sync (ETestServerFixture *fixture,                                gconstpointer user_data){	EBook *book;	GList *fields;	book = E_TEST_SERVER_UTILS_SERVICE (fixture, EBook);	fields = ebook_test_utils_book_get_supported_fields (book);	test_print ("successfully retrieved supported fields:/n");	g_list_foreach (fields, (GFunc) list_member_print_and_free, NULL);	test_print ("----------------/n");	g_list_free (fields);}

/* performance test */static void BM_sprintf_overhead(benchmark::State& state) {  while (state.KeepRunning()) {    test_print("BM_sprintf_overhead:%zu", state.iterations());    state.PauseTiming();    logd_yield();    state.ResumeTiming();  }}

void test_print_port_info(void) {#ifdef PORT_COMPILER_NAME  test_print("*** Compiler:     ");  test_println(PORT_COMPILER_NAME);#endif  test_print("*** Architecture: ");  test_println(PORT_ARCHITECTURE_NAME);#ifdef PORT_CORE_VARIANT_NAME  test_print("*** Core Variant: ");  test_println(PORT_CORE_VARIANT_NAME);#endif#ifdef PORT_INFO  test_print("*** Port Info:    ");  test_println(PORT_INFO);#endif}

int main(int argc, char **argv){	test_init();	test_print();	return 0;}

static gbooleanread_pause_ended (FlowShunt *shunt){  test_print ("Resuming reads/n");  reads_are_blocked = FALSE;  flow_shunt_unblock_reads (shunt);  return FALSE;}

static gbooleanwrite_pause_ended (FlowShunt *shunt){  test_print ("Resuming writes/n");  writes_are_blocked = FALSE;  flow_shunt_unblock_writes (shunt);  return FALSE;}

static voidcontacts_removed (EBookView *book_view, const GList *ids){	GList *l;	for (l = (GList*)ids; l; l = l->next) {		test_print ("Removed contact: %s/n", (gchar *)l->data);	}}

static voidprint_contact (EContact *contact){	GList *emails, *e;	test_print ("Contact: %s/n", (gchar *)e_contact_get_const (contact, E_CONTACT_FULL_NAME));	test_print ("UID: %s/n", (gchar *)e_contact_get_const (contact, E_CONTACT_UID));	test_print ("Email addresses:/n");	emails = e_contact_get (contact, E_CONTACT_EMAIL);	for (e = emails; e; e = e->next) {		test_print ("/t%s/n",  (gchar *)e->data);	}	g_list_foreach (emails, (GFunc) g_free, NULL);	g_list_free (emails);	test_print ("/n");}

void	test_exec(t_lst_elem *elem){	t_test	*test;	test = elem->data;	test_exec_do(test);	test_print(elem);  	// usleep(300 * 1000);}

int main(){	char str[3][20] = {{"a"}, {"b"}, {"c"}};	int i = 0;	for (; i < 3; i++)	{		printf("i=%d, str_len = %d/n", i, strlen(str[i]));		test_print(str[i], strlen(str[i]));	}	return 0;}

int main() {  test_create(1);  test_add(2);  test_print(3);  test_remove(4);  test_remove_last_node();  test_remove_first_node();  test_add_with_index(0);  test_add_with_index(1);  test_add_with_index(2);  return 0;}

int main() {	struct tnode *root;	char node_urls[10][MAX_URL_LENGTH];	int url_frequency[10]; 	root = NULL;	root = add_to_tree(root, "google.com");	root = add_to_tree(root, "google.com");	assert( root->count == 2);	root = add_to_tree(root, "amazon.com"); 	assert(treeprint(0,root,node_urls, url_frequency) == 2);	       	populate_tree("small_url", &root);	test_print(root, 7, Expected_URLs_small, Expected_Url_Freq_small);       	populate_tree("long_url", &root);	assert( lookup(root, "vonage.com") == 2323);	test_print(root, 10, Expected_URLs, Expected_Url_Freq);		return 0; }

static voidtest_get_static_capabilities_sync (ETestServerFixture *fixture,                                   gconstpointer user_data){	EBook *book;	const gchar *caps;	book = E_TEST_SERVER_UTILS_SERVICE (fixture, EBook);	caps = ebook_test_utils_book_get_static_capabilities (book);	test_print ("successfully retrieved static capabilities: '%s'/n", caps);}

int main(){  test_print();  test_memory();  test_metrics();  test_find();  test_locate();  fputs("All tests passed/n", stdout);  return 0;}

static voidget_supported_fields_cb (EBookTestClosure *closure){	/* XXX: assuming an empty list is valid, we'll just print out anything	 * we do get */	if (closure->list) {		EIterator *iter;		const gchar *field;		test_print ("supported fields:/n");		iter = e_list_get_iterator (closure->list);		while ((field = e_iterator_get (iter))) {			test_print ("    %s/n", field);			e_iterator_next (iter);		}		test_print ("----------------/n");		g_object_unref (closure->list);	}	g_main_loop_quit ((GMainLoop *) (closure->user_data));}

static voidtest_get_alarm_email_address (ETestServerFixture *fixture,                              gconstpointer user_data){	ECal *cal;	gchar *address;	cal = E_TEST_SERVER_UTILS_SERVICE (fixture, ECal);	address = ecal_test_utils_cal_get_alarm_email_address (cal);	test_print ("alarm email address: '%s'/n", address);	g_free (address);}

//void test_print (int * A, int size); int main (int argc, char *argv[]) { 	if (argc !=2) { 		printf("pass the array size as argument /n"); 		exit (EXIT_FAILURE);	}	int size = atoi (argv[1]); 	int * A = new int [size];	for (int i = 0; i < size; i++) {	 	A[i] = rand()%size;	 }	 	//test initial array	Quicksort * sort = new Quicksort ();	test_print (A, 0, size-1);	//delare an object of class quicksort 	sort->Sort(A, 0, size-1);	//test final array	test_print (A, 0, size-1);}