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

int main(){  int number_failed;  SRunner *sr;  size_t i;  suite_getter_fn* suites[] = {    udp_suite,    tcp_suite,    tcp_oos_suite,    mem_suite,    etharp_suite  };  size_t num = sizeof(suites)/sizeof(void*);  LWIP_ASSERT("No suites defined", num > 0);  lwip_init();  sr = srunner_create((suites[0])());  for(i = 1; i < num; i++) {    srunner_add_suite(sr, ((suite_getter_fn*)suites[i])());  }#ifdef LWIP_UNITTESTS_NOFORK  srunner_set_fork_status(sr, CK_NOFORK);#endif#ifdef LWIP_UNITTESTS_FORK  srunner_set_fork_status(sr, CK_FORK);#endif  srunner_run_all(sr, CK_NORMAL);  number_failed = srunner_ntests_failed(sr);  srunner_free(sr);  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

int main(void) {  int number_failed;  Suite *s = edc_suite();  SRunner *sr = srunner_create(s);  srunner_set_xml(sr, "test_results.xml");  srunner_add_suite(sr, almanac_suite());  srunner_add_suite(sr, bits_suite());  srunner_add_suite(sr, edc_suite());  srunner_add_suite(sr, ionosphere_suite());  srunner_add_suite(sr, coord_system_suite());  srunner_add_suite(sr, linear_algebra_suite());  srunner_add_suite(sr, troposphere_suite());  srunner_add_suite(sr, ephemeris_suite());  srunner_add_suite(sr, set_suite());  srunner_add_suite(sr, gnss_time_test_suite());  srunner_add_suite(sr, signal_test_suite());  srunner_add_suite(sr, glo_map_test_suite());  srunner_add_suite(sr, shm_suite());  srunner_add_suite(sr, pvt_test_suite());  srunner_add_suite(sr, nav_meas_test_suite());  srunner_add_suite(sr, sid_set_test_suite());  srunner_set_fork_status(sr, CK_NOFORK);  srunner_run_all(sr, CK_NORMAL);  number_failed = srunner_ntests_failed(sr);  srunner_free(sr);  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

} END_TESTint main(void) {    Suite *s = suite_create("services_nodemanagement");    TCase *tc_addnodes = tcase_create("addnodes");    tcase_add_checked_fixture(tc_addnodes, setup, teardown);    tcase_add_test(tc_addnodes, AddVariableNode);    tcase_add_test(tc_addnodes, AddComplexTypeWithInheritance);    tcase_add_test(tc_addnodes, AddNodeTwiceGivesError);    tcase_add_test(tc_addnodes, AddObjectWithConstructor);    tcase_add_test(tc_addnodes, InstantiateObjectType);    TCase *tc_deletenodes = tcase_create("deletenodes");    tcase_add_checked_fixture(tc_deletenodes, setup, teardown);    tcase_add_test(tc_deletenodes, DeleteObjectWithDestructor);    tcase_add_test(tc_deletenodes, DeleteObjectAndReferences);    suite_add_tcase(s, tc_addnodes);    suite_add_tcase(s, tc_deletenodes);    SRunner *sr = srunner_create(s);    srunner_set_fork_status(sr, CK_NOFORK);    srunner_run_all(sr, CK_NORMAL);    int number_failed = srunner_ntests_failed(sr);    srunner_free(sr);    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

    } END_TESTint main(void) {    TCase *tc_add_pubsub_connections_minimal_config = tcase_create("Create PubSub UDP Connections with minimal valid config");    tcase_add_checked_fixture(tc_add_pubsub_connections_minimal_config, setup, teardown);    tcase_add_test(tc_add_pubsub_connections_minimal_config, AddConnectionsWithMinimalValidConfiguration);    tcase_add_test(tc_add_pubsub_connections_minimal_config, AddRemoveAddConnectionWithMinimalValidConfiguration);    TCase *tc_add_pubsub_connections_invalid_config = tcase_create("Create PubSub UDP Connections with invalid configurations");    tcase_add_checked_fixture(tc_add_pubsub_connections_invalid_config, setup, teardown);    tcase_add_test(tc_add_pubsub_connections_invalid_config, AddConnectionWithInvalidAddress);    tcase_add_test(tc_add_pubsub_connections_invalid_config, AddConnectionWithUnknownTransportURL);    tcase_add_test(tc_add_pubsub_connections_invalid_config, AddConnectionWithNullConfig);    TCase *tc_add_pubsub_connections_maximal_config = tcase_create("Create PubSub UDP Connections with maximal valid config");    tcase_add_checked_fixture(tc_add_pubsub_connections_maximal_config, setup, teardown);    tcase_add_test(tc_add_pubsub_connections_maximal_config, AddSingleConnectionWithMaximalConfiguration);    tcase_add_test(tc_add_pubsub_connections_maximal_config, GetMaximalConnectionConfigurationAndCompareValues);    Suite *s = suite_create("PubSub UDP connection creation");    suite_add_tcase(s, tc_add_pubsub_connections_minimal_config);    suite_add_tcase(s, tc_add_pubsub_connections_invalid_config);    suite_add_tcase(s, tc_add_pubsub_connections_maximal_config);    //suite_add_tcase(s, tc_decode);    SRunner *sr = srunner_create(s);    srunner_set_fork_status(sr, CK_NOFORK);    srunner_run_all(sr,CK_NORMAL);    int number_failed = srunner_ntests_failed(sr);    srunner_free(sr);    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

int main (int argc, char *argv[]){	if (argc < 2)	{		printf("ERR: Expected test data directory/n");		exit(1);	}	if (strlen(argv[1]) > MAX_PATH_LEN)	{		printf("ERR: Test data pathname too long: %u", (unsigned int) strlen(argv[1]));		exit(1);	}	dataDir = argv[1];	int number_failed;	Suite *s = exip_suite();	SRunner *sr = srunner_create (s);#ifdef _MSC_VER	srunner_set_fork_status(sr, CK_NOFORK);#endif	srunner_run_all (sr, CK_NORMAL);	number_failed = srunner_ntests_failed (sr);	srunner_free (sr);	return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

intmain (int argc, char* argv[]) {   int num_failed = 0;  SRunner *runner = srunner_create(create_suite_XMLAttributes());  srunner_add_suite(runner, create_suite_CopyAndClone());  srunner_add_suite(runner, create_suite_XMLNamespaces());  srunner_add_suite(runner, create_suite_XMLTriple());  srunner_add_suite(runner, create_suite_XMLToken());  srunner_add_suite(runner, create_suite_XMLToken_newSetters());  srunner_add_suite(runner, create_suite_XMLNode());  srunner_add_suite(runner, create_suite_XMLNode_newSetters());  srunner_add_suite(runner, create_suite_XMLError());  srunner_add_suite(runner, create_suite_XMLError_C());  srunner_add_suite(runner, create_suite_XMLErrorLog());  srunner_add_suite(runner, create_suite_XMLInputStream());  srunner_add_suite(runner, create_suite_XMLOutputStream());  srunner_add_suite(runner, create_suite_XMLAttributes_C());  srunner_add_suite(runner, create_suite_XMLExceptions());  if (argc > 1 && !strcmp(argv[1], "-nofork"))  {    srunner_set_fork_status( runner, CK_NOFORK );  }  srunner_run_all(runner, CK_NORMAL);  num_failed = srunner_ntests_failed(runner);  srunner_free(runner);  return num_failed;}

END_TESTint main(void) {    int number_failed = 0;    SRunner *sr;    Suite *s  = suite_create("testMemoryHandling");    TCase *tc = tcase_create("Empty Objects");    tcase_add_loop_test(tc, newAndEmptyObjectShallBeDeleted, UA_TYPES_BOOLEAN, UA_TYPES_COUNT - 1);    tcase_add_test(tc, arrayCopyShallMakeADeepCopy);    tcase_add_loop_test(tc, encodeShallYieldDecode, UA_TYPES_BOOLEAN, UA_TYPES_COUNT - 1);    suite_add_tcase(s, tc);    tc = tcase_create("Truncated Buffers");    tcase_add_loop_test(tc, decodeShallFailWithTruncatedBufferButSurvive, UA_TYPES_BOOLEAN, UA_TYPES_COUNT - 1);    suite_add_tcase(s, tc);    tc = tcase_create("Fuzzing with Random Buffers");    tcase_add_loop_test(tc, decodeScalarBasicTypeFromRandomBufferShallSucceed, UA_TYPES_BOOLEAN, UA_TYPES_DOUBLE);    tcase_add_loop_test(tc, decodeComplexTypeFromRandomBufferShallSurvive, UA_TYPES_NODEID, UA_TYPES_COUNT - 1);    suite_add_tcase(s, tc);    tc = tcase_create("Test calcSizeBinary");    tcase_add_loop_test(tc, calcSizeBinaryShallBeCorrect, UA_TYPES_BOOLEAN, UA_TYPES_COUNT - 1);    suite_add_tcase(s, tc);    sr = srunner_create(s);    srunner_set_fork_status(sr, CK_NOFORK);    srunner_run_all (sr, CK_NORMAL);    number_failed += srunner_ntests_failed(sr);    srunner_free(sr);    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

END_TESTintmain(int argc, char *argv[]){    int nf;    SRunner *sr;    TCase *tc;    Suite *s = suite_create("assertions");    parse_args(argc, argv);    tc = tcase_create("set_act_state");    suite_add_tcase(s, tc);    tcase_add_test(tc, test_set_act_state_error);    sr = srunner_create(s);    srunner_set_fork_status(sr, fork_status);    srunner_run_all(sr, verbosity);    nf = srunner_ntests_failed(sr);    srunner_free(sr);    /*suite_free(s);*/    return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

intmain (int argc, char* argv[]){    int num_failed = 0;    setTestDataDirectory();    SRunner *runner = srunner_create(create_suite_Input());    srunner_add_suite(runner, create_suite_Output());    srunner_add_suite(runner, create_suite_FunctionTerm());    srunner_add_suite(runner, create_suite_Transition());    srunner_add_suite(runner, create_suite_QualitativeSpecies());    srunner_add_suite(runner, create_suite_DefaultTerm());    srunner_add_suite(runner, create_suite_ListOfFunctionTerms());    srunner_add_suite(runner, create_suite_CopyAndClone());    if (argc > 1 && !strcmp(argv[1], "-nofork"))    {        srunner_set_fork_status( runner, CK_NOFORK );    }    srunner_run_all(runner, CK_NORMAL);    num_failed = srunner_ntests_failed(runner);    srunner_free(runner);    return num_failed;}

int main(void){    int number_failed;    int memdebug;    int error;        // Check if memdebug enabled    memdebug = getenv("MEMDEBUG") ? atoi(getenv("MEMDEBUG")) : 0;    if( memdebug ) {        talloc_enable_leak_report_full();    }        // Set up test suite    Suite * s = parser_suite();    SRunner * sr = srunner_create(s);    if( IS_WIN || memdebug ) {        srunner_set_fork_status(sr, CK_NOFORK);    }    srunner_run_all(sr, CK_ENV);    number_failed = srunner_ntests_failed(sr);    srunner_free(sr);    error = (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;        // Generate report for memdebug    if( memdebug ) {        talloc_report_full(NULL, stderr);    }        // Return    return error;}

static void run_from_file(char *filename){    FILE *tc_file = NULL;    int n_failures = 0;    char tc[100] = "";    int num_tcs = 0;    int len=0;    Suite *s = suite_create("GMS Client API");    /* Test Cases for clGmsInitialize and clGmsFinalize APIs */    TCase *sel_tcs = tcase_create("Selected Test");    suite_add_tcase(s, sel_tcs);    tc_file = fopen(filename, "r");    if (tc_file == NULL)    {        perror("Open Failed:");        exit(-1);    }    while (1)    {        if (fgets (tc, 100,tc_file) != NULL)        {            if (tc[0] != '#')            {                num_tcs++;                len=strlen(tc);                tc[len-1] = '/0';                tc_add(sel_tcs,tc);            }        } else {            break;        }    }    if (num_tcs == 0)    {        printf("NO Test cases are specified in the given file/n");        exit(-1);    } else {        printf("%d test cases are provided/n",num_tcs);    }    /* Now run the tests */    SRunner *sr = srunner_create(s);    /* do not fork; forking seg-faults EO (why?) */    srunner_set_fork_status(sr, CK_NOFORK);    srunner_run_all(sr, CK_NORMAL); /* Can also use CK_VERBOSE */    srunner_set_log(sr, "./gms_unit_test_logs.log");    n_failures = srunner_ntests_failed(sr);    srunner_free(sr);}

intmain (int argc, char* argv[]) {   int num_failed;  setTestDataDirectory();  SRunner *runner = srunner_create( create_suite_CVTerms() );  srunner_add_suite( runner, create_suite_CVTerms_newSetters  () );  srunner_add_suite( runner, create_suite_ModelHistory  () );  srunner_add_suite( runner, create_suite_Date_newSetters  () );  srunner_add_suite( runner, create_suite_ModelCreator_newSetters  () );  srunner_add_suite( runner, create_suite_ModelHistory_newSetters  () );  srunner_add_suite( runner, create_suite_CopyAndClone  () );  srunner_add_suite( runner, create_suite_RDFAnnotation () );  srunner_add_suite( runner, create_suite_RDFAnnotation2() );  srunner_add_suite( runner, create_suite_Validation () );  srunner_add_suite( runner, create_suite_RDFAnnotation_C () );  srunner_add_suite( runner, create_suite_L3ModelHistory  () );  if (argc > 1 && !strcmp(argv[1], "-nofork"))  {    srunner_set_fork_status( runner, CK_NOFORK );  }  srunner_run_all(runner, CK_NORMAL);  num_failed = srunner_ntests_failed(runner);  srunner_free(runner);  return num_failed;}

intmain (int argc, char* argv[]) {   int num_failed = 0;  setTestDataDirectory();  SRunner *runner = srunner_create(create_suite_PolygonObject());  srunner_add_suite(runner, create_suite_ParametricObject());  srunner_add_suite(runner, create_suite_ImageData());  srunner_add_suite(runner, create_suite_TransformationComponents());  srunner_add_suite(runner, create_suite_CopyAndClone());  if (argc > 1 && !strcmp(argv[1], "-nofork"))  {    srunner_set_fork_status( runner, CK_NOFORK );  }  srunner_run_all(runner, CK_NORMAL);  num_failed = srunner_ntests_failed(runner);  srunner_free(runner);  return num_failed;}

int main(void){  int number_failed;  Suite *s = edc_suite();  SRunner *sr = srunner_create(s);  srunner_set_xml(sr, "test_results.xml");  srunner_add_suite(sr, dgnss_management_test_suite());  srunner_add_suite(sr, baseline_test_suite());  srunner_add_suite(sr, amb_kf_test_suite());  srunner_add_suite(sr, observation_test_suite());  srunner_add_suite(sr, ambiguity_test_suite());  srunner_add_suite(sr, rtcm3_suite());  srunner_add_suite(sr, bits_suite());  srunner_add_suite(sr, memory_pool_suite());  srunner_add_suite(sr, coord_system_suite());  srunner_add_suite(sr, linear_algebra_suite());  srunner_add_suite(sr, filter_utils_suite());  srunner_add_suite(sr, ephemeris_suite());  srunner_add_suite(sr, set_suite());  srunner_set_fork_status(sr, CK_NOFORK);  srunner_run_all(sr, CK_NORMAL);  number_failed = srunner_ntests_failed(sr);  srunner_free(sr);  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

int main(int argc, char* argv[]){  int no_fork = ((argc > 1) && !strcmp(argv[1], "nofork")) ? 1 : 0;  int i       = 0;  int failed  = 0;  FILE* log_file = NULL;    if (!no_fork) {      log_file = fopen ("gu_tests.log", "w");      if (!log_file) return EXIT_FAILURE;      gu_conf_set_log_file (log_file);  }  gu_conf_debug_on();  while (suites[i]) {      SRunner* sr = srunner_create(suites[i]());      if (no_fork) srunner_set_fork_status(sr, CK_NOFORK);      srunner_run_all (sr, CK_NORMAL);      failed += srunner_ntests_failed (sr);      srunner_free (sr);      i++;  }  if (log_file)  {      fclose (log_file);  }  printf ("Total tests failed: %d/n", failed);  return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

intmain (int argc, char* argv[]) {   int num_failed = 0;  setTestDataDirectory();  SRunner *runner = srunner_create(create_suite_GroupsExtension());  srunner_add_suite(runner, create_suite_WriteGroupsExtension());  srunner_add_suite(runner, create_suite_ReadGroupsExtension());  if (argc > 1 && !strcmp(argv[1], "-nofork"))  {    srunner_set_fork_status( runner, CK_NOFORK );  }  srunner_run_all(runner, CK_NORMAL);  num_failed = srunner_ntests_failed(runner);  srunner_free(runner);  safe_free(TestDataDirectory);  return num_failed;}

int main(int argc, char *argv[]){#ifdef TEST_COLLECTIVES  MPI_Init(&argc, &argv);  MPI_Comm_size(MPI_COMM_WORLD, &comm_ndev);  MPI_Comm_rank(MPI_COMM_WORLD, &comm_rank);  if (argc < comm_ndev) {    if (comm_rank == 0)      printf("Usage : %s <GPU list per rank>/n", argv[0]);    exit(1);  }  dev_name = argv[comm_rank + 1];  // Set a gpu for this process.#endif  // TEST_COLLECTIVES  int number_failed;  Suite *s = get_suite();  SRunner *sr = srunner_create(s);#ifdef TEST_COLLECTIVES  // Check by default forks to another (non mpi registered) process in order to  // run tests. Using MPI inside tests means we must disable this.  srunner_set_fork_status(sr, CK_NOFORK);#endif  // TEST_COLLECTIVES  srunner_run_all(sr, CK_VERBOSE);  number_failed = srunner_ntests_failed(sr);  srunner_free(sr);#ifdef TEST_COLLECTIVES  MPI_Finalize();#endif  // TEST_COLLECTIVES  return number_failed == 0 ? EXIT_SUCCESS : EXIT_FAILURE;}

int main(int argc, char **argv) {  Suite *s = NULL;  Suite *s2 = NULL;  SRunner *sr = NULL;  struct argument_s arguments;  int nf;  ZERO_STRUCT(arguments);  cmdline_parse(argc, argv, &arguments);  s = make_std_c_streq_suite();  s2 = make_std_c_strlist_suite();  sr = srunner_create(s);  if (arguments.nofork) {    srunner_set_fork_status(sr, CK_NOFORK);  }  srunner_add_suite (sr, s2);  srunner_run_all(sr, CK_VERBOSE);  nf = srunner_ntests_failed(sr);  srunner_free(sr);  return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

void fork_setup (void){  fork_sr = srunner_create(make_fork_sub_suite());  fork_dummy_sr = srunner_create (make_fork_sub_suite());  srunner_set_fork_status(fork_sr,CK_NOFORK);  srunner_run_all(fork_sr,CK_VERBOSE);}

END_TESTSTART_TEST(test_set_fork){  srunner_set_fork_status(fork_dummy_sr, CK_NOFORK);  ck_assert_msg(srunner_fork_status(fork_dummy_sr) == CK_NOFORK,	      "Fork status not changed correctly");}

END_TESTSTART_TEST(test_set_fork){  srunner_set_fork_status(fork_dummy_sr, CK_NOFORK);  fail_unless(srunner_fork_status(fork_dummy_sr) == CK_NOFORK,	      "Fork status not changed correctly");}

int main(void) {    Suite *s = testSuite_Client();    SRunner *sr = srunner_create(s);    srunner_set_fork_status(sr, CK_NOFORK);    srunner_run_all(sr,CK_NORMAL);    int number_failed = srunner_ntests_failed(sr);    srunner_free(sr);    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

int RunCheck(){   Suite *s = CreateSuite ();  SRunner *sr = srunner_create (s);  srunner_set_fork_status(sr, CK_NOFORK);  srunner_run_all (sr, CK_NORMAL);  srunner_free (sr);  return 0;}

intmain (int argc, char **argv){        GOptionContext *context;        SRunner        *r;        int             failed;        GError         *error;        failed = 0;        context = g_option_context_new ("");        g_option_context_add_main_entries (context, entries, NULL);        error = NULL;        g_option_context_parse (context, &argc, &argv, &error);        g_option_context_free (context);        if (error != NULL) {                g_warning ("%s", error->message);                g_error_free (error);                exit (EXIT_FAILURE);        }        r = srunner_create (suite_common_address ());        if (no_fork) {                srunner_set_fork_status (r, CK_NOFORK);        }        srunner_run_all (r, verbose ? CK_VERBOSE : CK_NORMAL);        failed = srunner_ntests_failed (r);        srunner_free (r);        r = srunner_create (suite_common ());        if (no_fork) {                srunner_set_fork_status (r, CK_NOFORK);        }        srunner_run_all (r, verbose ? CK_VERBOSE : CK_NORMAL);        failed |= srunner_ntests_failed (r);        srunner_free (r);        return failed != 0;}

int main() {  int number_failed;  SRunner *sr = srunner_create(hash_table_suite());  srunner_set_fork_status(sr, CK_NOFORK);  srunner_run_all(sr, CK_NORMAL);  number_failed = srunner_ntests_failed(sr);  srunner_free(sr);  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

int main (void) {    int number_failed = 0;    Suite *s = namespace_suite();    SRunner *sr = srunner_create(s);    srunner_set_fork_status(sr,CK_NOFORK);    srunner_run_all(sr, CK_NORMAL);    number_failed += srunner_ntests_failed (sr);    srunner_free(sr);    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

int RunCheck(){   Suite *s = Poisson_suite ();  SRunner *sr = srunner_create (IntelFFT_Suite());//  srunner_add_suite(sr, IntelFFT_Suite() );  srunner_set_fork_status(sr, CK_NOFORK);  srunner_run_all (sr, CK_NORMAL);  srunner_free (sr);  return 0;}

int main() {  setlocale(LC_ALL,"");  int number_failed;  Suite *s = graph_suite();  SRunner *sr = srunner_create(s);  srunner_set_fork_status(sr, CK_NOFORK);  srunner_run_all (sr, CK_NORMAL);  number_failed = srunner_ntests_failed (sr);  srunner_free (sr);  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;}

int main(void) {    int numberFailed;    Suite* s = canwriteSuite();    SRunner *sr = srunner_create(s);    // Don't fork so we can actually use gdb    srunner_set_fork_status(sr, CK_NOFORK);    srunner_run_all(sr, CK_NORMAL);    numberFailed = srunner_ntests_failed(sr);    srunner_free(sr);    return (numberFailed == 0) ? 0 : 1;}