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

voidtests_quiet( int argc, char **argv ){	if ( ( argc > 1 )		 && ( ( strcasecmp( argv[1], "TESTS_QUIET" ) == 0 )			  || ( strcasecmp( argv[1], "-q" ) == 0 ) ) ) {		TESTS_QUIET = 1;	} else {		int retval;		retval = PAPI_set_debug( PAPI_VERB_ECONT );		if ( retval != PAPI_OK )			test_fail( __FILE__, __LINE__, "PAPI_set_debug", retval );	}   if (getenv("TESTS_COLOR")!=NULL) {      TESTS_COLOR=1;   }   }

int main(){	bert_encoder_t *encoder = test_encoder(output,OUTPUT_SIZE);	bert_data_t *data;	if (!(data = bert_data_create_int(0x00ffffff)))	{		test_fail("malloc failed");	}	test_encoder_push(encoder,data);	bert_data_destroy(data);	bert_encoder_destroy(encoder);	test_output();	return 0;}

char *stringify_granularity( int granularity ){	switch ( granularity ) {	case PAPI_GRN_THR:		return ( "PAPI_GRN_THR" );	case PAPI_GRN_PROC:		return ( "PAPI_GRN_PROC" );	case PAPI_GRN_PROCG:		return ( "PAPI_GRN_PROCG" );	case PAPI_GRN_SYS_CPU:		return ( "PAPI_GRN_SYS_CPU" );	case PAPI_GRN_SYS:		return ( "PAPI_GRN_SYS" );	default:		test_fail( __FILE__, __LINE__, "Unrecognized granularity!", 0 );	}	return ( NULL );}

char *stringify_domain( int domain ){	switch ( domain ) {	case PAPI_DOM_SUPERVISOR:		return ( "PAPI_DOM_SUPERVISOR" );	case PAPI_DOM_USER:		return ( "PAPI_DOM_USER" );	case PAPI_DOM_KERNEL:		return ( "PAPI_DOM_KERNEL" );	case PAPI_DOM_OTHER:		return ( "PAPI_DOM_OTHER" );	case PAPI_DOM_ALL:		return ( "PAPI_DOM_ALL" );	default:		test_fail( __FILE__, __LINE__, "Unrecognized domains!", 0 );	}	return ( NULL );}

void event_create_eventList(int *eventSet, int eventCodeSetSize, int *eventCodeSet, int threadID) {    int retval, i, maxNumberHwCounters, eventCodeSetMaxSize;    PAPI_event_info_t info;    maxNumberHwCounters = PAPI_get_opt( PAPI_MAX_HWCTRS, NULL );    printf("Max number of hardware counters = %d /n", maxNumberHwCounters);    eventCodeSetMaxSize = PAPI_get_opt( PAPI_MAX_MPX_CTRS, NULL );    printf("Max number of multiplexed counters = %d /n", eventCodeSetMaxSize);    if ( eventCodeSetMaxSize < eventCodeSetSize)        test_fail( __FILE__, __LINE__, "eventCodeSetMaxSize < eventCodeSetSize, too many performance events defined! ", retval );    retval = PAPI_register_thread();    if ( retval != PAPI_OK )        test_fail( __FILE__, __LINE__, "PAPI_register_thread", retval );    retval = PAPI_create_eventset( eventSet );    if ( retval != PAPI_OK )        test_fail( __FILE__, __LINE__, "PAPI_create_eventset", retval );    retval = PAPI_assign_eventset_component( *eventSet, 0 );    if ( retval != PAPI_OK )        test_fail( __FILE__, __LINE__, "PAPI_assign_eventset_component", retval );    retval = PAPI_set_multiplex( *eventSet );    if ( retval != PAPI_OK )        test_fail( __FILE__, __LINE__, "PAPI_set_multiplex", retval );    for (i = 0; i < eventCodeSetSize; i++) {        retval = PAPI_get_event_info(eventCodeSet[i], &info);        if ( retval != PAPI_OK )            test_fail( __FILE__, __LINE__, "PAPI_get_event_info", retval );        retval = PAPI_add_event( *eventSet, info.event_code);        if ( retval != PAPI_OK )            test_fail( __FILE__, __LINE__, "PAPI_add_event", retval );        else            printf("Adding %s /n", info.symbol);    }    printf("event_create_eventList done /n");}

void polybench_papi_close(){# ifdef _OPENMP#pragma omp parallel  {    if (omp_get_thread_num () == polybench_papi_counters_threadid)      {# endif	int retval;	if ((retval = PAPI_destroy_eventset (&polybench_papi_eventset))	    != PAPI_OK)	  test_fail (__FILE__, __LINE__, "PAPI_destroy_eventset", retval);	if (PAPI_is_initialized ())	  PAPI_shutdown ();# ifdef _OPENMP      }  }#pragma omp barrier# endif}

TEST_ENDstatic boolvalidate_fill(const void *p, uint8_t c, size_t offset, size_t len){	bool ret = false;	const uint8_t *buf = (const uint8_t *)p;	size_t i;	for (i = 0; i < len; i++) {		uint8_t b = buf[offset+i];		if (b != c) {			test_fail("Allocation at %p contains %#x rather than "			    "%#x at offset %zu", p, b, c, offset+i);			ret = true;		}	}	return (ret);}

char *stringify_all_granularities( int granularities ){	static char buf[PAPI_HUGE_STR_LEN];	int i, did = 0;	buf[0] = '/0';	for ( i = PAPI_GRN_MIN; i <= PAPI_GRN_MAX; i = i << 1 )		if ( granularities & i ) {			if ( did )				strcpy( buf + strlen( buf ), "|" );			strcpy( buf + strlen( buf ),					stringify_granularity( granularities & i ) );			did++;		}	if ( did == 0 )		test_fail( __FILE__, __LINE__, "Unrecognized granularity!", 0 );	return ( buf );}

void check_values(int eventset, int *events, int nevents, long long *values, long long *refvalues){  double spread[MAXEVENTS];  int i = nevents, j = 0;   if (!TESTS_QUIET) {      printf("/nRelative accuracy:/n");      for (j = 0; j < nevents; j++)         printf("   Event %.2d", j+1);      printf("/n");   }   for (j = 0; j < nevents; j++) {      spread[j] = abs((int)(refvalues[j] - values[j]));      if (values[j])         spread[j] /= (double) values[j];      if (!TESTS_QUIET)         printf("%10.3g ", spread[j]);      /* Make sure that NaN get counted as errors */      if (spread[j] < MPX_TOLERANCE)         i--;      else if (refvalues[j] < MINCOUNTS)        /* Neglect inprecise results with low counts */         i--;   }      printf("/n/n");#if 0   if (!TESTS_QUIET) {      for (j = 0; j < nevents; j++) {         PAPI_get_event_info(events[j], &info);         printf("Event %.2d: ref=", j);         printf(LLDFMT10, refvalues[j]);         printf(", diff/ref=%7.2g  -- %s/n", spread[j], info.short_descr);         printf("/n");      }      printf("/n");   }#endif   if (i)      test_fail(__FILE__, __LINE__, "Values outside threshold", i);}

int main (int argc, char ** argv){	printf ("LUA         TESTS/n");	printf ("==================/n/n");	init (argc, argv);	test_variable_passing ();	test_two_scripts ();	printf ("/n");	printf ("========================================================================/n");	printf ("NOTE: The following errors are intended. We're testing error conditions!/n");	printf ("========================================================================/n");	test_fail ();	test_wrong ();	printf ("/ntest_lua RESULTS: %d test(s) done. %d error(s)./n", nbTest, nbError);	return nbError;}

static voidtest(void){	test_pass(1);	test_fail(0);	test_str("aaa", ==, "aaa");	test_str("aaa", <, "bbb");	test_str("ccc", >, "bbb");	test_str("ccc", !=, "bbb");	test_mem("aaa", ==, "aaa", 3);	test_mem("aaa", <, "bbb", 3);	test_mem("ccc", >, "bbb", 3);	test_mem("ccc", !=, "bbb", 3);	test_mem("abcd", ==, "abcd", 4);	test_mem("abcd", ==, "abcd", 5);	test_mem("ababcd", ==, "ababff", 4);	test_mem("ababcd", !=, "ababff", 6);}

voidtest_rule_tag(const gchar *pattern, const gchar *tag, gboolean set){  LogMessage *msg = log_msg_new_empty();  gboolean found, result;  PDBInput input;  log_msg_set_value(msg, LM_V_MESSAGE, pattern, strlen(pattern));  log_msg_set_value(msg, LM_V_PROGRAM, "prog2", 5);  log_msg_set_value(msg, LM_V_HOST, MYHOST, strlen(MYHOST));  log_msg_set_value(msg, LM_V_PID, MYPID, strlen(MYPID));  result = pattern_db_process(patterndb, PDB_INPUT_WRAP_MESSAGE(&input, msg));  found = log_msg_is_tag_by_name(msg, tag);  if (set ^ found)    test_fail("Tag '%s' is %sset for pattern '%s' (%d)/n", tag, found ? "" : "not ", pattern, !!result);  log_msg_unref(msg);  test_clean_state();}

int main(int argc, char **argv){	int ret;	struct uterm_monitor *mon;	size_t onum;	onum = sizeof(options) / sizeof(*options);	ret = test_prepare(options, onum, argc, argv, &eloop);	if (ret)		goto err_fail;	if (!setlocale(LC_ALL, "")) {		log_err("Cannot set locale: %m");		ret = -EFAULT;		goto err_exit;	}	ret = uterm_monitor_new(&mon, eloop, monitor_event, NULL);	if (ret)		goto err_exit;	ret = ev_eloop_register_signal_cb(eloop, SIGQUIT, sig_quit, NULL);	if (ret)		goto err_mon;	system("stty -echo");	uterm_monitor_scan(mon);	ev_eloop_run(eloop, -1);	system("stty echo");	ev_eloop_unregister_signal_cb(eloop, SIGQUIT, sig_quit, NULL);err_mon:	uterm_monitor_unref(mon);err_exit:	test_exit(options, onum, eloop);err_fail:	if (ret != -ECANCELED)		test_fail(ret);	return abs(ret);}

int main(int argc, char **argv) {	struct perf_event_attr pe;	int fd;	int quiet=0;	int kernel_size;	quiet=test_quiet();	if (!quiet) {		printf("This test checks what happens if attr struct is "		      "exactly what the kernel expects./n");	}	kernel_size=sizeof(struct perf_event_attr);	memset(&pe,0,kernel_size);	pe.size=kernel_size;	pe.type=PERF_TYPE_HARDWARE;	pe.config=PERF_COUNT_HW_INSTRUCTIONS;	pe.disabled=1;	pe.exclude_kernel=1;	pe.exclude_hv=1;	arch_adjust_domain(&pe,quiet);	fd=perf_event_open(&pe,0,-1,-1,0);	if (fd<0) {		fprintf(stderr,"Error opening leader %llx %s/n",			pe.config,strerror(errno));		test_fail(test_string);	}	close(fd);	test_pass(test_string);	return 0;}

int main(int argc, char **argv){	int ret;	struct ev_eloop *eloop;	struct kmscon_vt *vt;	ret = test_prepare(argc, argv, &eloop);	if (ret)		goto err_fail;	ret = kmscon_vt_new(&vt, NULL, NULL);	if (ret)		goto err_exit;	ret = kmscon_vt_open(vt, KMSCON_VT_NEW, eloop);	if (ret)		goto err_vt;	ret = kmscon_vt_enter(vt);	if (ret)		log_warn("Cannot switch to VT");	ev_eloop_run(eloop, -1);	log_debug("Terminating/n");	/* switch back to previous VT but wait for eloop to process SIGUSR0 */	ret = kmscon_vt_leave(vt);	if (ret == -EINPROGRESS)		ev_eloop_run(eloop, 50);err_vt:	kmscon_vt_unref(vt);err_exit:	test_exit(eloop);err_fail:	test_fail(ret);	return abs(ret);}

int main(){	fixtureSetup();	resetTestCount();	testStarted("test_1_returns_false_if_string_not_matches");	setup();		test_1_returns_false_if_string_not_matches();	tearDown();	testEnded();	testStarted("test_2_returns_true_if_string_matches");	setup();		test_2_returns_true_if_string_matches();	tearDown();	testEnded();	testStarted("test_3_returns_true_if_whole_string_matches");	setup();		test_3_returns_true_if_whole_string_matches();	tearDown();	testEnded();	testStarted("test_4_returns_false_if_string_does_not_match");	setup();		test_4_returns_false_if_string_does_not_match();	tearDown();	testEnded();	testStarted("test_5_returns_false_if_string_not_matches");	setup();		test_5_returns_false_if_string_not_matches();	tearDown();	testEnded();	testStarted("test_fail");	setup();		test_fail();	tearDown();	testEnded();	summarizeTestCount();	fixtureTearDown();	return 0;}

static void test_kabi_query(void *fixture){        // Remember, matches regexes from last to first.        static const char *_patterns[] = {                ".*", ".*/dev/md.*", "loop"        };        static struct {                const char *input;                int r;        } _cases[] = {		{"foo", 0},		{"/dev/mapper/vg-lvol1", 0},		{"/dev/mapper/vglvol1", 0},		{"/dev/md1", 1},		{"loop", 2},        };	int r;	unsigned i;	struct dm_pool *mem = fixture;  	struct dm_regex *scanner;	scanner = dm_regex_create(mem, _patterns, DM_ARRAY_SIZE(_patterns));	T_ASSERT(scanner != NULL);	for (i = 0; i < DM_ARRAY_SIZE(_cases); i++) {        	r = dm_regex_match(scanner, _cases[i].input);        	if (r != _cases[i].r) {                	test_fail("'%s' expected to match '%s', but matched %s",                                  _cases[i].input,                                  _cases[i].r >= DM_ARRAY_SIZE(_patterns) ? "<nothing>" : _patterns[_cases[i].r],                                  r >= DM_ARRAY_SIZE(_patterns) ? "<nothing>" : _patterns[r]);        	}	}}

intmain(int argc, char *argv[]){	START(argc, argv, "obj_ctl_alignment");	if (argc != 2)		UT_FATAL("usage: %s file-name", argv[0]);	const char *path = argv[1];	if ((pop = pmemobj_create(path, LAYOUT, PMEMOBJ_MIN_POOL * 10,			S_IWUSR | S_IRUSR)) == NULL)			UT_FATAL("!pmemobj_create: %s", path);	test_fail();	test_aligned_allocs(1024, 512, POBJ_HEADER_NONE);	test_aligned_allocs(1024, 512, POBJ_HEADER_COMPACT);	test_aligned_allocs(64, 64, POBJ_HEADER_COMPACT);	pmemobj_close(pop);	DONE(NULL);}

intadd_two_nonderived_events( int *num_events, int *papi_event, int *mask ) {	/* query and set up the right event to monitor */  int EventSet = PAPI_NULL;#define POTENTIAL_EVENTS 3  unsigned int potential_evt_to_add[POTENTIAL_EVENTS][2] =		{ {( unsigned int ) PAPI_FP_INS, MASK_FP_INS},		  {( unsigned int ) PAPI_FP_OPS, MASK_FP_OPS},		  {( unsigned int ) PAPI_TOT_INS, MASK_TOT_INS}		};  int event_found = 0,i;  *mask = 0;	  for(i=0;i<POTENTIAL_EVENTS;i++) {     if ( PAPI_query_event( ( int ) potential_evt_to_add[i][0] ) == PAPI_OK ) {       if ( !is_event_derived(potential_evt_to_add[i][0])) {	  event_found = 1;	  break;       }    }  }	  if ( event_found ) {     *papi_event = ( int ) potential_evt_to_add[i][0];     *mask = ( int ) potential_evt_to_add[i][1] | MASK_TOT_CYC;     EventSet = add_test_events( num_events, mask, 0 );  } else {     test_fail( __FILE__, __LINE__, "Not enough room to add an event!", 0 );  }  return EventSet;}

int uORBTest::UnitTest::pub_test_queue_main(){	struct orb_test_medium t;	orb_advert_t ptopic;	const unsigned int queue_size = 50;	t.val = 0;	if ((ptopic = orb_advertise_queue(ORB_ID(orb_test_medium_queue_poll), &t, queue_size)) == nullptr) {		_thread_should_exit = true;		return test_fail("advertise failed: %d", errno);	}	int message_counter = 0, num_messages = 20 * queue_size;	++t.val;	while (message_counter < num_messages) {		//simulate burst		int burst_counter = 0;		while (burst_counter++ < queue_size / 2 + 7) { //make interval non-boundary aligned			orb_publish(ORB_ID(orb_test_medium_queue_poll), ptopic, &t);			++t.val;		}		message_counter += burst_counter;		usleep(20 * 1000); //give subscriber a chance to catch up	}	_num_messages_sent = t.val;	usleep(100 * 1000);	_thread_should_exit = true;	orb_unadvertise(ptopic);	return 0;}

intmain (int argc, char *argv[]){  int ret = 0;  struct SplittedHTTPAddress * spa;  GNUNET_log_setup ("test", "DEBUG", NULL);  spa = http_split_address ("");  if (NULL != spa)  {    clean (spa);    spa = NULL;    GNUNET_break (0);  }  spa = http_split_address ("http://");  if (NULL != spa)  {    clean (spa);    GNUNET_break (0);  }  spa = http_split_address ("://");  if (NULL != spa)  {    clean (spa);    GNUNET_break (0);  }  test_pass_hostname ();  test_pass_ipv4 ();  test_fail_ipv6 ();  test_fail ();  return ret;}

void parser_tests(void) {  parser * par;  lexer * lex;  printf("Running parser tests.../n");  printf("Created script./n");  if(0 == (lex = lex_new_file("test.oca"))) {    printf("Unable to create lexer./n");    return;  }  printf("Created lexer./n");  printf("par_new()/n");  if(0 == (par = par_new(lex))) {    printf("Failed to create parser/n");    test_fail();    return;  }  test_pass();  lex_del(lex);  par_del(par);  printf("Completed parser tests/n");}

intadd_two_nonderived_events( int *num_events, int *papi_event, int *mask ) {	/* query and set up the right event to monitor */  int EventSet = PAPI_NULL;#define POTENTIAL_EVENTS 3  unsigned int potential_evt_to_add[POTENTIAL_EVENTS][2] =		{ {( unsigned int ) PAPI_FP_INS, MASK_FP_INS},		  {( unsigned int ) PAPI_FP_OPS, MASK_FP_OPS},		  {( unsigned int ) PAPI_TOT_INS, MASK_TOT_INS}		};  int i;  *mask = 0;     /* could leak up to two event sets. */  for(i=0;i<POTENTIAL_EVENTS;i++) {     if ( PAPI_query_event( ( int ) potential_evt_to_add[i][0] ) == PAPI_OK ) {       if ( !is_event_derived(potential_evt_to_add[i][0])) {		 *papi_event = ( int ) potential_evt_to_add[i][0];		 *mask = ( int ) potential_evt_to_add[i][1] | MASK_TOT_CYC;		 EventSet = add_test_events( num_events, mask, 0 );		 if ( *num_events == 2 ) break;       }    }  }	  if ( i == POTENTIAL_EVENTS ) {     test_fail( __FILE__, __LINE__, "Can't find a non-derived event!", 0 );  }  return EventSet;}

void ref_measurements(int iters, int *eventset, int *events, int nevents, long long *refvalues){   PAPI_event_info_t info;   int i, retval;   double x = 1.1, y;   long long t1, t2;   printf("PAPI reference measurements:/n");   if ((retval = PAPI_create_eventset(eventset)))      test_fail(__FILE__, __LINE__, "PAPI_create_eventset", retval);   for (i = 0; i < nevents; i++) {      if ((retval = PAPI_add_event(*eventset, events[i])))         test_fail(__FILE__, __LINE__, "PAPI_add_event", retval);      x = 1.0;      t1 = PAPI_get_real_usec();      if ((retval = PAPI_start(*eventset)))         test_fail(__FILE__, __LINE__, "PAPI_start", retval);      y = dummy3(x, iters);      if ((retval = PAPI_stop(*eventset, &refvalues[i])))         test_fail(__FILE__, __LINE__, "PAPI_stop", retval);      t2 = PAPI_get_real_usec();#if 0      printf("/tOperations= %.1f Mflop", y * 1e-6);      printf("/t(%g Mflop/s)/n/n", ((float) y / (t2 - t1)));#endif            PAPI_get_event_info(events[i], &info);      printf("%20s = ", info.short_descr);      printf(LLDFMT, refvalues[i]);      printf("/n");            if ((retval = PAPI_cleanup_eventset(*eventset)))	test_fail(__FILE__, __LINE__, "PAPI_cleanup_eventset", retval);   }   if ((retval = PAPI_destroy_eventset(eventset)))      test_fail(__FILE__, __LINE__, "PAPI_destroy_eventset", retval);   *eventset = PAPI_NULL;}

void test_output(){	if (output[0] != BERT_MAGIC)	{		test_fail("bert_encoder_push did not add the magic byte");	}	if (output[1] != BERT_SMALL_TUPLE)	{		test_fail("bert_encoder_push did not add the SMALL_TUPLE magic byte");	}	if (output[2] != EXPECTED_LENGTH)	{		test_fail("bert_encoder_push encoded %u as the tuple length, expected %u",output[2],EXPECTED_LENGTH);	}	if (output[3] != BERT_SMALL_INT)	{		test_fail("bert_encoder_push failed to encode the first small int of the tuple");	}	if (output[4] != 1)	{		test_fail("bert_encoder_push wrote %u as the first small int, expected %u",output[4],1);	}	if (output[5] != BERT_SMALL_INT)	{		test_fail("bert_encoder_push failed to encode the second small int of the tuple");	}	if (output[6] != 2)	{		test_fail("bert_encoder_push wrote %u as the second small int, expected %u",output[6],2);	}}

intmain( int argc, char **argv ){	int nthreads = 8, ret, i;	PAPI_event_info_t info;	pthread_t *threads;	const PAPI_hw_info_t *hw_info;	tests_quiet( argc, argv );	/* Set TESTS_QUIET variable */	if ( !TESTS_QUIET ) {		if ( argc > 1 ) {			int tmp = atoi( argv[1] );			if ( tmp >= 1 )				nthreads = tmp;		}	}	ret = PAPI_library_init( PAPI_VER_CURRENT );	if ( ret != PAPI_VER_CURRENT ) {		test_fail( __FILE__, __LINE__, "PAPI_library_init", ret );	}	hw_info = PAPI_get_hardware_info(  );	if ( hw_info == NULL )		test_fail( __FILE__, __LINE__, "PAPI_get_hardware_info", 2 );	if ( strcmp( hw_info->model_string, "POWER6" ) == 0 ) {		ret = PAPI_set_domain( PAPI_DOM_ALL );		if ( ret != PAPI_OK ) {			test_fail( __FILE__, __LINE__, "PAPI_set_domain", ret );		}	}	ret = PAPI_thread_init( ( unsigned long ( * )( void ) ) pthread_self );	if ( ret != PAPI_OK ) {		test_fail( __FILE__, __LINE__, "PAPI_thread_init", ret );	}	ret = PAPI_multiplex_init(  );	if ( ret != PAPI_OK ) {		test_fail( __FILE__, __LINE__, "PAPI_multiplex_init", ret );	}	/* Fill up the event set with as many non-derived events as we can */	i = PAPI_PRESET_MASK;	do {		if ( PAPI_get_event_info( i, &info ) == PAPI_OK ) {			if ( info.count == 1 ) {				events[numevents++] = ( int ) info.event_code;				printf( "Added %s/n", info.symbol );			} else {				printf( "Skipping derived event %s/n", info.symbol );			}		}	} while ( ( PAPI_enum_event( &i, PAPI_PRESET_ENUM_AVAIL ) == PAPI_OK )			  && ( numevents < PAPI_MPX_DEF_DEG ) );	printf( "Found %d events/n", numevents );	do_stuff(  );	printf( "Creating %d threads:/n", nthreads );	threads =		( pthread_t * ) malloc( ( size_t ) nthreads * sizeof ( pthread_t ) );	if ( threads == NULL ) {		test_fail( __FILE__, __LINE__, "malloc", PAPI_ENOMEM );	}	/* Create the threads */	for ( i = 0; i < nthreads; i++ ) {		ret = pthread_create( &threads[i], NULL, thread, NULL );		if ( ret != 0 ) {			test_fail( __FILE__, __LINE__, "pthread_create", PAPI_ESYS );		}	}	/* Wait for thread completion */	for ( i = 0; i < nthreads; i++ ) {		ret = pthread_join( threads[i], NULL );		if ( ret != 0 ) {			test_fail( __FILE__, __LINE__, "pthread_join", PAPI_ESYS );		}	}	printf( "Done." );	test_pass( __FILE__, NULL, 0 );	pthread_exit( NULL );	exit( 0 );}

void *thread( void *arg ){	( void ) arg;			 /*unused */	int eventset = PAPI_NULL;	long long values[PAPI_MPX_DEF_DEG];	int ret = PAPI_register_thread(  );	if ( ret != PAPI_OK )		test_fail( __FILE__, __LINE__, "PAPI_register_thread", ret );	ret = PAPI_create_eventset( &eventset );	if ( ret != PAPI_OK )		test_fail( __FILE__, __LINE__, "PAPI_create_eventset", ret );	printf( "Event set %d created/n", eventset );	/* In Component PAPI, EventSets must be assigned a component index	   before you can fiddle with their internals.	   0 is always the cpu component */	ret = PAPI_assign_eventset_component( eventset, 0 );	if ( ret != PAPI_OK ) {		test_fail( __FILE__, __LINE__, "PAPI_assign_eventset_component", ret );	}	ret = PAPI_set_multiplex( eventset );        if ( ret == PAPI_ENOSUPP) {	   test_skip( __FILE__, __LINE__, "Multiplexing not supported", 1 );	}	else if ( ret != PAPI_OK ) {		test_fail( __FILE__, __LINE__, "PAPI_set_multiplex", ret );	}	ret = PAPI_add_events( eventset, events, numevents );	if ( ret < PAPI_OK ) {		test_fail( __FILE__, __LINE__, "PAPI_add_events", ret );	}	ret = PAPI_start( eventset );	if ( ret != PAPI_OK ) {		test_fail( __FILE__, __LINE__, "PAPI_start", ret );	}	do_stuff(  );	ret = PAPI_stop( eventset, values );	if ( ret != PAPI_OK ) {		test_fail( __FILE__, __LINE__, "PAPI_stop", ret );	}	ret = PAPI_cleanup_eventset( eventset );	if ( ret != PAPI_OK ) {		test_fail( __FILE__, __LINE__, "PAPI_cleanup_eventset", ret );	}	ret = PAPI_destroy_eventset( &eventset );	if ( ret != PAPI_OK ) {		test_fail( __FILE__, __LINE__, "PAPI_destroy_eventset", ret );	}	ret = PAPI_unregister_thread(  );	if ( ret != PAPI_OK )		test_fail( __FILE__, __LINE__, "PAPI_unregister_thread", ret );	return ( NULL );}

int main(int argc, char** argv) {	int ret,quiet,i;	struct perf_event_attr pe;	struct sigaction sa;	void *our_mmap;	char test_string[]="Testing overflows on sibling...";	quiet=test_quiet();	if (!quiet) printf("This tests that overflows of siblings work./n");	memset(&sa, 0, sizeof(struct sigaction));	sa.sa_sigaction = our_handler;	sa.sa_flags = SA_SIGINFO;	if (sigaction( SIGIO, &sa, NULL) < 0) {		fprintf(stderr,"Error setting up signal handler/n");		exit(1);	}	memset(&pe,0,sizeof(struct perf_event_attr));	pe.type=PERF_TYPE_HARDWARE;	pe.size=sizeof(struct perf_event_attr);	pe.config=PERF_COUNT_HW_CPU_CYCLES;	pe.sample_period=0;	pe.sample_type=0;	pe.read_format=PERF_FORMAT_GROUP|PERF_FORMAT_ID;	pe.disabled=1;	pe.pinned=0;	pe.exclude_kernel=1;	pe.exclude_hv=1;	pe.wakeup_events=1;	arch_adjust_domain(&pe,quiet);	fd1=perf_event_open(&pe,0,-1,-1,0);	if (fd1<0) {		fprintf(stderr,"Error opening leader %llx/n",pe.config);		test_fail(test_string);	}	pe.type=PERF_TYPE_HARDWARE;	pe.config=PERF_COUNT_HW_INSTRUCTIONS;	pe.sample_period=100000;	pe.sample_type=PERF_SAMPLE_IP;	pe.read_format=0;	pe.disabled=0;	pe.pinned=0;	pe.exclude_kernel=1;	pe.exclude_hv=1;	arch_adjust_domain(&pe,quiet);	fd2=perf_event_open(&pe,0,-1,fd1,0);	if (fd2<0) {		fprintf(stderr,"Error opening %llx/n",pe.config);			test_fail(test_string);	}	/* large enough that threshold not a problem */	our_mmap=mmap(NULL, (1+MMAP_PAGES)*getpagesize(),		PROT_READ|PROT_WRITE, MAP_SHARED, fd2, 0);	fcntl(fd2, F_SETFL, O_RDWR|O_NONBLOCK|O_ASYNC);	fcntl(fd2, F_SETSIG, SIGIO);	fcntl(fd2, F_SETOWN,getpid());	ioctl(fd1, PERF_EVENT_IOC_RESET, 0);	ioctl(fd2, PERF_EVENT_IOC_RESET, 0);	ret=ioctl(fd1, PERF_EVENT_IOC_ENABLE,0);	if (ret<0) {		if (!quiet) fprintf(stderr,"Error with PERF_EVENT_IOC_ENABLE of group leader: "			"%d %s/n",errno,strerror(errno));		test_fail(test_string);	}	for(i=0;i<100;i++) {		instructions_million();	}	ret=ioctl(fd1, PERF_EVENT_IOC_DISABLE,0);	if (!quiet) printf("Count: %d %p/n",count.total,our_mmap);	if (count.total==0) {		if (!quiet) printf("No overflow events generated./n");		test_fail(test_string);	}	if (count.total!=1000) {		if (!quiet) printf("Expected %d overflows, got %d./n",				count.total,100);		test_fail(test_string);	}//.........这里部分代码省略.........

//.........这里部分代码省略.........		result=ioctl(fd1, PERF_EVENT_IOC_SET_FILTER, filter);		if (result==0) {			if (!quiet) printf("Found proper event %d/n",i);			close(fd1);			break;		}		else {		}		close(fd1);	}	if (i==MAX_SEARCH) {		if (!quiet) {			printf("Could not find any trace event to filter/n");		}		test_skip(test_string);		errors++;	}	pe1.config=i;	pe1.disabled=1;	pe1.exclude_kernel=0;	pe1.exclude_hv=0;	arch_adjust_domain(&pe1,quiet);	/* Create group leader */	fd1=perf_event_open(&pe1,0,-1,-1,0);	if (fd1<0) {		if (!quiet) {			fprintf(stderr,"Unexpected error %s/n",strerror(errno));		}		test_fail(test_string);	}	for(i=0;i<MAX_FILTER;i++) {		filter[i]=0xff;	}	/* Check a too big value */	if (!quiet) {		printf("/t+ Checking a too-big event: ");	}	result=ioctl(fd1, PERF_EVENT_IOC_SET_FILTER, filter);	if ((result==-1) && (errno==EINVAL)) {		if (!quiet) printf("Failed as expected/n");	}	else {		if (!quiet) printf("Unexpected %d %s/n",result,strerror(errno));		errors++;	}	/* Check off-by-one value */	/* Size limited to pagesize */	if (!quiet) {		printf("/t+ Checking off-by-one filter: ");	}	filter[4096]=0;	result=ioctl(fd1, PERF_EVENT_IOC_SET_FILTER, filter);	if ((result==-1) && (errno==EINVAL)) {		if (!quiet) printf("Failed as expected/n");	}	else {		if (!quiet) printf("Unexpected %d %s/n",result,strerror(errno));		errors++;

intmain( int argc, char **argv ){	int EventSet = PAPI_NULL;	long long values0[2],values1[2],values2[2];	int num_flops = 3000000, retval;	int mythreshold = 1000000;	char event_name1[PAPI_MAX_STR_LEN];        int PAPI_event;	int cid,numcmp,rapl_cid;	const PAPI_component_info_t *cmpinfo = NULL;	/* Set TESTS_QUIET variable */	tests_quiet( argc, argv );      	quiet=TESTS_QUIET;	/* Init PAPI */	retval = PAPI_library_init( PAPI_VER_CURRENT );	if ( retval != PAPI_VER_CURRENT ) {	  test_fail(__FILE__, __LINE__,"PAPI_library_init",retval);	}	numcmp = PAPI_num_components();	for(cid=0; cid<numcmp; cid++) {	  if ( (cmpinfo = PAPI_get_component_info(cid)) == NULL) {	    test_fail(__FILE__, __LINE__,"PAPI_get_component_info failed/n", 0);	  }	  if (strstr(cmpinfo->name,"linux-rapl")) {	    rapl_cid=cid;	    if (!TESTS_QUIET) printf("Found rapl component at cid %d/n",				     rapl_cid);	    if (cmpinfo->num_native_events==0) {              test_skip(__FILE__,__LINE__,"No rapl events found",0);	    }	    break;	  }	}	/* Component not found */	if (cid==numcmp) {	  test_skip(__FILE__,__LINE__,"No rapl component found/n",0);	}	/* add PAPI_TOT_CYC and PAPI_TOT_INS */	retval=PAPI_create_eventset(&EventSet);	if ( retval != PAPI_OK ) {	   test_fail(__FILE__, __LINE__,"PAPI_create_eventset",retval);	}	retval=PAPI_add_event(EventSet,PAPI_TOT_CYC);	if ( retval != PAPI_OK ) {	   test_fail(__FILE__, __LINE__,"PAPI_add_event",retval);	}	retval=PAPI_add_event(EventSet,PAPI_TOT_INS);	if ( retval != PAPI_OK ) {	   test_fail(__FILE__, __LINE__,"PAPI_add_event",retval);	}	/* Add some RAPL events */	retval=PAPI_create_eventset(&EventSet2);	if ( retval != PAPI_OK ) {	   test_fail(__FILE__, __LINE__,"PAPI_create_eventset",retval);	}        retval=PAPI_add_named_event(EventSet2,"PACKAGE_ENERGY:PACKAGE0");	if ( retval != PAPI_OK ) {	   test_fail(__FILE__, __LINE__,"PAPI_add_event",retval);	}        retval=PAPI_add_named_event(EventSet2,"PACKAGE_ENERGY:PACKAGE1");	if ( retval != PAPI_OK ) {	   test_fail(__FILE__, __LINE__,"PAPI_add_event",retval);	}		PAPI_event=PAPI_TOT_CYC;	/* arbitrary */	mythreshold = 2000000;	if (!TESTS_QUIET) {	   printf("Using %x for the overflow event, threshold %d/n",		  PAPI_event,mythreshold);	}	/* Start the run calibration run */	retval = PAPI_start( EventSet );	if ( retval != PAPI_OK ) {	   test_fail(__FILE__, __LINE__,"PAPI_start",retval);	}	do_ints(num_flops,TESTS_QUIET);	do_flops( 3000000 );	/* stop the calibration run */	retval = PAPI_stop( EventSet, values0 );//.........这里部分代码省略.........