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

void single_check(const char *device, const char *connection, const char *model, GSM_Error expected){	GSM_Config *smcfg;	GSM_Error error;	GSM_Debug_Info *debug_info;	/* Allocates state machine */	s = GSM_AllocStateMachine();	test_result(s != NULL);	debug_info = GSM_GetDebug(s);	GSM_SetDebugGlobal(TRUE, debug_info);	smcfg = GSM_GetConfig(s, 0);	strcpy(smcfg->Model, model);	smcfg->Device = strdup(device);	smcfg->UseGlobalDebugFile = TRUE;	smcfg->Connection = strdup(connection);	smcfg->PhoneFeatures[0] = F_PBK_ENCODENUMBER;	smcfg->PhoneFeatures[1] = 0;	GSM_SetConfigNum(s, 1);	error = GSM_InitConnection(s, 1);	test_result(error == expected);	/* Free state machine */	GSM_FreeStateMachine(s);}

int _tmain(int argc, _TCHAR* argv[]){	Crypto crypto;	BYTE salt[CRYPTO_KDF_SALT_LEN];	BYTE master_key[16], db_key[16];	int pass= 0;	int tests= 4;	pass+= test_result(		test_salt(&crypto, (PBYTE) salt)	);	pass+= test_result(		test_db_key(&crypto, db_key)	);		pass+= test_result(		test_kdf(&crypto, (PBYTE) PASSPHRASE, sizeof(PASSPHRASE), salt, master_key)	);	pass+= test_result(		test_key_encryption(&crypto, db_key, master_key)	);	if ( tests == pass ) {		wprintf(L"/n===> ALL TESTS PASSED <===/n/n");		Exit(0);	}	wprintf(L"%d OF %d TESTS PASSING/n/n", pass, tests);	Exit(1);}

int main(void){	test_package_begin("hash", "Externally linked hash table data structure with operations");	hash_init();	test_begin("Hash allocation");	{		Hash	*a;		a = hash_new(int_hash, int_key_eq);		test_result(a != NULL);		hash_destroy(a);	}	test_end();	test_begin("Multiple allocs");	{		Hash	*a, *b;		a = hash_new(int_hash, int_key_eq);		b = hash_new(int_hash, int_key_eq);		test_result(a != NULL && b != NULL && a != b);		hash_destroy(b);		hash_destroy(a);	}	test_end();	test_begin("Insert/lookup");	{		Hash	*a;		const char	*t;		a = hash_new(int_hash, int_key_eq);		hash_insert(a, (const void *) 17, "foo");		test_result((t = hash_lookup(a, (const void *) 17)) != NULL &&			    strcmp(t, "foo") == 0);		hash_destroy(a);	}	test_end();	test_begin("Resize");	{		Hash		*a;		const char	*t;		unsigned int	i;		a = hash_new(int_hash, int_key_eq);		hash_insert(a, (const void *) 4711, "foo");		for(i = 0; i < 100; i++)			hash_insert(a, (const void *) (3519 + i), "test-data");		test_result((t = hash_lookup(a, (const void *) 4711)) != NULL &&			    strcmp(t, "foo") == 0);		hash_destroy(a);	}	test_end();	return test_package_end();}

void test_set_var() /* {{{ */{	/* test the ability to set a variable */	char *teststr = strdup("  set /t task_version   0.6.9  ");	char *testint = strdup("  set /t nc_timeout /t 6969/t/t /n ");	stdout = devnull;	handle_command(teststr);	handle_command(testint);	stdout = out;	test_result("set string var", strcmp(cfg.version, "0.6.9")==0);	test_result("set int var", cfg.nc_timeout==6969);} /* }}} */

int main(){    test(1000);    test_comp(1000);    test_proj(1000);    test_move_only(1000);    {        int const N = 1000;        S* ia = new S[N];        int* ib = new int[N];        for (int i = 0; i < N; ++i)            ia[i].i = i;        std::shuffle(ia, ia+N, gen);        for (int i = 0; i <= N; ++i)        {            CHECK(ranges::push_heap(ranges::make_iterator_range(ia, ia+i), std::greater<int>(), &S::i).get_unsafe() == ia+i);            std::transform(ia, ia+i, ib, std::mem_fn(&S::i));            CHECK(std::is_heap(ib, ib+i, std::greater<int>()));        }        delete[] ia;        delete[] ib;    }    return test_result();}

    }END_TESTstatic void test_searcher_overflow_to_64bit( int search_type ) {    init_constant_scores( 127, -1 );    init_symbol_translation( AMINOACID, FORWARD_STRAND, 3, 3 );    p_query query = query_read_from_file( "./tests/testdata/NP_009305.1.fas" );    s_init( search_type, BIT_WIDTH_8, query );    ssa_db_init( "./tests/testdata/NP_009305.1.fas" );    gapO = -1;    gapE = -1;    size_t hit_count = 1;    adp_init( hit_count );    p_search_result res = s_search( &hit_count );    minheap_sort( res->heap );    query_free( query );    ck_assert_int_eq( hit_count, res->heap->count );    ck_assert_int_eq( 1, res->overflow_8_bit_count );    ck_assert_int_eq( 1, res->overflow_16_bit_count );    int result[2] = { 67818, 0 };    test_result( res, result, 2 );}

void check_log(FILE * f, gboolean match, const char *test_name){	char buff[100];	char test_message[] = "T3ST M3S5AG3";	char cleaner[] = "XXXXXXXXXXXXXXXXX";	int result;	rewind(f);	GSM_LogError(s, test_message, ERR_MOREMEMORY);	rewind(f);	result = fread(buff, 1, sizeof(test_message), f);	if (match && result != sizeof(test_message)) {		printf("%s: Read failed (%d)!/n", test_name, result);		fail(10);	}	if (!match && result != sizeof(test_message)) {		goto done;	}	result = strncmp(test_message, buff, sizeof(test_message) - 1);	if (match && result != 0) {		printf("%s: Match failed!/n", test_name);		fail(11);	}	if (!match && result == 0) {		printf("%s: Matched but should not!/n", test_name);		fail(12);	}done:	rewind(f);	result = fwrite(cleaner, 1, sizeof(cleaner), f);	test_result(result == sizeof(cleaner));	rewind(f);}

int main(){    test_iter<forward_iterator<const int*> >();    test_iter<bidirectional_iterator<const int*> >();    test_iter<random_access_iterator<const int*> >();    test_iter<const int*>();    test_iter<forward_iterator<const int*>, sentinel<const int*>>();    test_iter<bidirectional_iterator<const int*>, sentinel<const int*>>();    test_iter<random_access_iterator<const int*>, sentinel<const int*>>();    test_iter<forward_iterator<const int*> >();    test_iter<bidirectional_iterator<const int*> >();    test_iter<random_access_iterator<const int*> >();    test_iter<const int*>();    test_iter<forward_iterator<const int*>, sentinel<const int*>>();    test_iter<bidirectional_iterator<const int*>, sentinel<const int*>>();    test_iter<random_access_iterator<const int*>, sentinel<const int*>>();    // Works with projections?    S s[] = {S{1},S{2},S{3},S{4},S{-4},S{5},S{6},S{40},S{7},S{8},S{9}};    std::pair<S const *, S const *> ps = ranges::minmax_element(s, std::less<int>{}, &S::i);    CHECK(ps.first->i == -4);    CHECK(ps.second->i == 40);    return test_result();}

int main(){    int d = 0;    ranges::nth_element(&d, &d, &d);    CHECK(d == 0);    test(256);    test(257);    test(499);    test(500);    test(997);    test(1000);    test(1009);    // Works with projections?    const int N = 257;    const int M = 56;    S ia[N];    for(int i = 0; i < N; ++i)        ia[i].i = ia[i].j = i;    std::shuffle(ia, ia+N, gen);    ranges::nth_element(ia, ia+M, std::less<int>(), &S::i);    CHECK(ia[M].i == M);    CHECK(ia[M].j == M);    return test_result();}

int main(){    test_iter<input_iterator<const int*> >();    test_iter<forward_iterator<const int*> >();    test_iter<bidirectional_iterator<const int*> >();    test_iter<random_access_iterator<const int*> >();    test_iter<const int*>();    test_iter<input_iterator<const int*>, sentinel<const int*>>();    test_iter<forward_iterator<const int*>, sentinel<const int*>>();    test_iter<bidirectional_iterator<const int*>, sentinel<const int*>>();    test_iter<random_access_iterator<const int*>, sentinel<const int*>>();    test_iter_comp<input_iterator<const int*> >();    test_iter_comp<forward_iterator<const int*> >();    test_iter_comp<bidirectional_iterator<const int*> >();    test_iter_comp<random_access_iterator<const int*> >();    test_iter_comp<const int*>();    test_iter_comp<input_iterator<const int*>, sentinel<const int*>>();    test_iter_comp<forward_iterator<const int*>, sentinel<const int*>>();    test_iter_comp<bidirectional_iterator<const int*>, sentinel<const int*>>();    test_iter_comp<random_access_iterator<const int*>, sentinel<const int*>>();    // Works with projections?    S s[] = {S{1},S{2},S{3},S{4},S{40},S{5},S{6},S{7},S{8},S{9}};    S v = ranges::max(s, std::less<int>{}, &S::i);    CHECK(v.i == 40);    return test_result();}

int main(){    // Test for constant generator functions    {        int i = 0, j = 1;        auto fib = view::generate_n([&]()->int{int tmp = i; i += j; std::swap(i, j); return tmp;}, 10);        CONCEPT_ASSERT(ranges::InputRange<decltype(fib)>());        check_equal(fib, {0,1,1,2,3,5,8,13,21,34});        auto const &cfib = fib;        auto it = fib.begin();        auto cit = cfib.begin();        CONCEPT_ASSERT(ranges::Same<decltype(it), decltype(cit)>());    }    // Test for mutable-only generator functions    {        int i = 0, j = 1;        auto fib = view::generate_n([=]()mutable->int{int tmp = i; i += j; std::swap(i, j); return tmp;}, 10);        CONCEPT_ASSERT(ranges::InputRange<decltype(fib)>());        check_equal(fib, {0,1,1,2,3,5,8,13,21,34});        // The generator cannot be called when it's const-qualified, so "fib const"        // does not model Range.        CONCEPT_ASSERT(!ranges::Range<decltype(fib) const>());    }    return test_result();}

int main(){    test_iter();    test_iter_comp();    return test_result();}

int main(int argc, char *argv[]){  if (argc>1 && argv[1][0]=='-' && argv[1][1]=='h') {    cout << "usage: " << argv[0] << " < result-file " <<endl;    cout << " result-file format: true-label predicted-score" <<endl;    exit(-1);  }  Target y_type("BINARY");  int loss=TrainLoss::str2loss(string("LS"));  BinaryTestStat test_result(y_type,loss);  int nl=0;  while(true) {    bool label;    double y;    double score;    cin >> y >> score;    label=y_type.binary_label(y);    if (cin.eof()) break;    test_result.update(label,0,score);    nl++;  }  cout << "auc=" << test_result.auc() <<endl;}

inttau_ex(double *rmax,       int nx,       double *ip,       int ni,       long *nrad,       int nr,       double alpha,       char *str){  int status=0,i;  double (*analres)();  test_result("/nTesting OPTICAL DEPTH for extinction %s, alpha=%g/n",str,alpha);  if(alpha==0.0)    analres=&const_ex_anal;  else if(alpha<0)    analres=&incin_ex_anal;  else    analres=&incout_ex_anal;  for(i=0;i<nr;i++)    status += tau_rad(rmax[i],ip,ni,nrad,nr,alpha,analres);  return status;}

inttau_dens(double rm,	 double ip,	 long nrad,	 double alpha,	 double res){  int status=0,i;  double rad[nrad],ex[nrad],refr[nrad];  double dr=rm/nrad;  test_result("      Using %li layers, an interspacing of %g/n",nrad,dr);  if(outp)    fprintf(outp,	    "/n#rad        extinction  refrac/n");  for(i=0;i<nrad;i++){    rad[i]=(i+1)*dr;    ex[i]=calcex(alpha, rm, rad[i]);    refr[i]=1;    if(outp)      fprintf(outp,	      "%12.9g%12.9g%12.9g/n"	      ,rad[i],ex[i],refr[i]);  }  status+=tau_now(ip,rad,refr,ex,nrad,res,1,"RefIdx constant technique");  status+=tau_now(ip,rad,refr,ex,nrad,res,2,"Ray bending technique");  return status;}

int main(int argc, char** argv) {    char* mpi_inbuf;    char* mpi_outbuf;    char* farc_inbuf;    char* farc_outbuf;    MPI_Init(&argc, &argv);    test_start("pack(1, hvector[[int], count=2, blklen=2, stride=-5*sizeof(int)])");    init_buffers(20*sizeof(int), &mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);    farc::DDT_Init();    farc::Datatype* t1 = new farc::PrimitiveDatatype(farc::PrimitiveDatatype::INT);    farc::Datatype* t2 = new farc::HVectorDatatype(2, 2, -5*sizeof(int), t1);    farc::DDT_Commit(t2);    farc::DDT_Pack(farc_inbuf+10*sizeof(int), farc_outbuf, t2, 1);    MPI_Datatype newtype;    MPI_Type_hvector(2, 2, -5*sizeof(int), MPI_INT, &newtype);    MPI_Type_commit(&newtype);    int position = 0;    MPI_Pack(mpi_inbuf+10*sizeof(int), 1, newtype, mpi_outbuf, 20*sizeof(int), &position, MPI_COMM_WORLD);    int res = compare_ddt_info(newtype, t2);    res = compare_buffers(20*sizeof(int), &mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);    // inspect_buffers(20*sizeof(int), &mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);    free_buffers(&mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);    test_result(res);    MPI_Finalize();    return 0;}

int main(int argc, char** argv) {    char* mpi_inbuf;    char* mpi_outbuf;    char* farc_inbuf;    char* farc_outbuf;    MPI_Init(&argc, &argv);    test_start("pack(2, [MPI_INT])");    init_buffers(20*sizeof(int), &mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);    farc::DDT_Init();    farc::Datatype* t1 = new farc::PrimitiveDatatype(farc::PrimitiveDatatype::INT);    int res = compare_ddt_info(MPI_INT, t1);    farc::DDT_Commit(t1);    farc::DDT_Pack(farc_inbuf, farc_outbuf, t1, 2);    int position = 0;    MPI_Pack(mpi_inbuf, 2, MPI_INT, mpi_outbuf, 20*sizeof(int), &position, MPI_COMM_WORLD);    res += compare_buffers(20*sizeof(int), &mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);    free_buffers(&mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);    test_result(res);    MPI_Finalize();    return 0;}

int main(){    test_iter<input_iterator<const int*> >();    test_iter<forward_iterator<const int*> >();    test_iter<bidirectional_iterator<const int*> >();    test_iter<random_access_iterator<const int*> >();    test_iter<const int*>();    test_iter<input_iterator<const int*>, sentinel<const int*>>();    test_iter<forward_iterator<const int*>, sentinel<const int*>>();    test_iter<bidirectional_iterator<const int*>, sentinel<const int*>>();    test_iter<random_access_iterator<const int*>, sentinel<const int*>>();    test_iter<input_iterator<const int*> >();    test_iter<forward_iterator<const int*> >();    test_iter<bidirectional_iterator<const int*> >();    test_iter<random_access_iterator<const int*> >();    test_iter<const int*>();    test_iter<input_iterator<const int*>, sentinel<const int*>>();    test_iter<forward_iterator<const int*>, sentinel<const int*>>();    test_iter<bidirectional_iterator<const int*>, sentinel<const int*>>();    test_iter<random_access_iterator<const int*>, sentinel<const int*>>();    // Works with projections?    S s[] = {S{1,0},S{2,1},S{3,2},S{4,3},S{-4,4},S{40,5},S{-4,6},S{40,7},S{7,8},S{8,9},S{9,10}};    auto res = ranges::minmax(s, std::less<int>{}, &S::value);    CHECK(res.first.value == -4);    CHECK(res.first.index == 4);    CHECK(res.second.value == 40);    CHECK(res.second.index == 7);    return test_result();}

int main(){    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();    test<bidirectional_iterator<const int*>, int*>();    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();    test<random_access_iterator<const int*>, random_access_iterator<int*> >();    test<random_access_iterator<const int*>, int*>();    test<const int*, bidirectional_iterator<int*> >();    test<const int*, random_access_iterator<int*> >();    test<const int*, int*>();    test1<bidirectional_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();    test1<bidirectional_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();    test1<bidirectional_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();    test1<random_access_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();    test1<random_access_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();    test1<random_access_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();    test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();    test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();    test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();    return test_result();}

void test_regex_iterator(boost::basic_regex<charT, traits>& r){   typedef typename std::basic_string<charT>::const_iterator const_iterator;   typedef boost::regex_iterator<const_iterator, charT, traits> test_iterator;   const std::basic_string<charT>& search_text = test_info<charT>::search_text();   boost::regex_constants::match_flag_type opts = test_info<charT>::match_options();   const int* answer_table = test_info<charT>::answer_table();   test_iterator start(search_text.begin(), search_text.end(), r, opts), end;   test_iterator copy(start);   const_iterator last_end = search_text.begin();   while(start != end)   {      if(start != copy)      {         BOOST_REGEX_TEST_ERROR("Failed iterator != comparison.", charT);      }      if(!(start == copy))      {         BOOST_REGEX_TEST_ERROR("Failed iterator == comparison.", charT);      }      test_result(*start, search_text.begin(), answer_table);      // test $` and $' :      if(start->prefix().first != last_end)      {         BOOST_REGEX_TEST_ERROR("Incorrect position for start of $`", charT);      }      if(start->prefix().second != (*start)[0].first)      {         BOOST_REGEX_TEST_ERROR("Incorrect position for end of $`", charT);      }      if(start->prefix().matched != (start->prefix().first != start->prefix().second))      {         BOOST_REGEX_TEST_ERROR("Incorrect position for matched member of $`", charT);      }      if(start->suffix().first != (*start)[0].second)      {         BOOST_REGEX_TEST_ERROR("Incorrect position for start of $'", charT);      }      if(start->suffix().second != search_text.end())      {         BOOST_REGEX_TEST_ERROR("Incorrect position for end of $'", charT);      }      if(start->suffix().matched != (start->suffix().first != start->suffix().second))      {         BOOST_REGEX_TEST_ERROR("Incorrect position for matched member of $'", charT);      }      last_end = (*start)[0].second;      ++start;      ++copy;      // move on the answer table to next set of answers;      if(*answer_table != -2)         while(*answer_table++ != -2){}   }   if(answer_table[0] >= 0)   {      // we should have had a match but didn't:      BOOST_REGEX_TEST_ERROR("Expected match was not found.", charT);   }}

 bool operator()(const boost::match_results<test_iter>& what) {    test_result(what, m_base, m_table);    // move on the answer table to next set of answers;    if(*m_table != -2)       while(*m_table++ != -2){}    return true; }

void test_idle(void){   /* both task must run exactly TEST_CYCLES times, different value means OS    * scheduling bug */   test_assert(TEST_CYCLES == task_data[0].loop);   test_assert(TEST_CYCLES == task_data[1].loop);   test_result(0);}

void test_idle(void){   /* check if both task was run to the end */   test_assert(TEST_CYCLES == cnt1);   test_assert(TEST_CYCLES == cnt2);   test_result(0);}

voidOK(test_batch_runner *runner, int cond, const char *msg, ...){	va_list ap;	va_start(ap, msg);	test_result(runner, cond, msg, ap);	va_end(ap);}

int main(void){	test_package_begin("xmlnode", "XML parser");	test_begin("Non-creation");	{		XmlNode	*root;		root = xmlnode_new(NULL);		test_result(root == NULL);	}	test_end();	test_begin("Single node creation");	{		XmlNode	*root;		root = xmlnode_new("<test/>");		test_result(root != NULL && strcmp(xmlnode_get_name(root), "test") == 0);		xmlnode_destroy(root);	}	test_end();	test_begin("Attribute access");	{		XmlNode	*root;		root = xmlnode_new("<test foo='bar'/>");		test_result(strcmp(xmlnode_attrib_get_value(root, "foo"), "bar") == 0);		xmlnode_destroy(root);	}	test_end();	test_begin("Path evaluation");	{		XmlNode	*root;		root = xmlnode_new("<parent><child name='foo'/><child name='bar'/><child name='baz'/></parent>");		test_result(strcmp(xmlnode_eval_single(root, "parent/child[@NAME]"), "baz") == 0);		xmlnode_destroy(root);	}	test_end();		return test_package_end();}

int main(){    test(1000);    test_comp(1000);    test_proj(1000);    test_move_only(1000);    return test_result();}

    }END_TESTSTART_TEST (test_searcher_AA_BLOSUM_nw_64)    {        int result[12] = { 82, 0 };        p_search_result res = setup_BLOSUM62_test( BIT_WIDTH_64, NEEDLEMAN_WUNSCH, 1 );        test_result( res, result, 2 );    }END_TEST

int main(){    test(0);    test(1);    test(2);    test(3);    test(10);    test(1000);    test_9(1000);    test_10(1000);    return test_result();}