Beispiel #1
0
END_TEST


/*-----------------------------------------------------------------------
 * Testing harness
 */

Suite *
ipset_suite()
{
    Suite  *s = suite_create("ipset");

    TCase  *tc_general = tcase_create("general");
    tcase_add_test(tc_general, test_set_starts_empty);
    tcase_add_test(tc_general, test_empty_sets_equal);
    tcase_add_test(tc_general, test_empty_sets_not_unequal);
    tcase_add_test(tc_general, test_store_empty);
    suite_add_tcase(s, tc_general);

    TCase  *tc_ipv4 = tcase_create("ipv4");
    tcase_add_test(tc_ipv4, test_ipv4_insert_01);
    tcase_add_test(tc_ipv4, test_ipv4_insert_02);
    tcase_add_test(tc_ipv4, test_ipv4_insert_network_01);
    tcase_add_test(tc_ipv4, test_ipv4_insert_network_02);
    tcase_add_test(tc_ipv4, test_ipv4_bad_netmask_01);
    tcase_add_test(tc_ipv4, test_ipv4_bad_netmask_02);
    tcase_add_test(tc_ipv4, test_ipv4_equality_1);
    tcase_add_test(tc_ipv4, test_ipv4_inequality_1);
    tcase_add_test(tc_ipv4, test_ipv4_memory_size_1);
    tcase_add_test(tc_ipv4, test_ipv4_memory_size_2);
    tcase_add_test(tc_ipv4, test_ipv4_store_01);
    tcase_add_test(tc_ipv4, test_ipv4_store_02);
    tcase_add_test(tc_ipv4, test_ipv4_store_03);
    suite_add_tcase(s, tc_ipv4);

    TCase  *tc_ipv6 = tcase_create("ipv6");
    tcase_add_test(tc_ipv6, test_ipv6_insert_01);
    tcase_add_test(tc_ipv6, test_ipv6_insert_02);
    tcase_add_test(tc_ipv6, test_ipv6_insert_network_01);
    tcase_add_test(tc_ipv6, test_ipv6_insert_network_02);
    tcase_add_test(tc_ipv6, test_ipv6_bad_netmask_01);
    tcase_add_test(tc_ipv6, test_ipv6_bad_netmask_02);
    tcase_add_test(tc_ipv6, test_ipv6_equality_1);
    tcase_add_test(tc_ipv6, test_ipv6_inequality_1);
    tcase_add_test(tc_ipv6, test_ipv6_memory_size_1);
    tcase_add_test(tc_ipv6, test_ipv6_memory_size_2);
    tcase_add_test(tc_ipv6, test_ipv6_store_01);
    tcase_add_test(tc_ipv6, test_ipv6_store_02);
    tcase_add_test(tc_ipv6, test_ipv6_store_03);
    suite_add_tcase(s, tc_ipv6);

    return s;
}
} END_TEST


Suite *mapistore_namedprops_mysql_suite(void)
{
	Suite	*s;
	TCase	*tc_config;
	TCase	*tc_mysql;
	TCase	*tc_mysql_q;

	s = suite_create("libmapistore named properties: MySQL backend");

	/* Core / Configuration */
	tc_config = tcase_create("MySQL backend configuration");
	tcase_add_test(tc_config, test_parameters);
	suite_add_tcase(s, tc_config);

	/* MySQL initialization */
	tc_mysql = tcase_create("MySQL initialization");
	/* database provisioning takes longer than default timeout */
	tcase_set_timeout(tc_mysql, 60);
	tcase_add_checked_fixture(tc_mysql, checked_mysql_setup, checked_mysql_teardown);
	tcase_add_test(tc_mysql, test_create_schema);
	tcase_add_test(tc_mysql, test_is_schema_created);
	tcase_add_test(tc_mysql, test_initialize_database);
	suite_add_tcase(s, tc_mysql);

	/* MySQL queries */
	tc_mysql_q = tcase_create("MySQL queries");
	tcase_set_timeout(tc_mysql_q, 60);
	tcase_add_checked_fixture(tc_mysql_q, checked_mysql_query_setup, checked_mysql_query_teardown);
	tcase_add_test(tc_mysql_q, test_next_unused_id);
	tcase_add_test(tc_mysql_q, test_get_mapped_id_MNID_ID);
	tcase_add_test(tc_mysql_q, test_get_mapped_id_MNID_STRING);
	tcase_add_test(tc_mysql_q, test_get_mapped_id_not_found);
	tcase_add_test(tc_mysql_q, test_get_nameid_type);
	tcase_add_test(tc_mysql_q, test_get_nameid_type_not_found);
	tcase_add_test(tc_mysql_q, test_get_nameid_MNID_ID);
	tcase_add_test(tc_mysql_q, test_get_nameid_MNID_STRING);
	tcase_add_test(tc_mysql_q, test_get_nameid_not_found);
	tcase_add_test(tc_mysql_q, test_create_id_MNID_ID);
	tcase_add_test(tc_mysql_q, test_create_id_MNID_STRING);
	suite_add_tcase(s, tc_mysql_q);

	return s;
}
END_TEST

Suite *
create_suite_CubicBezier (void)
{
  Suite *suite = suite_create("CubicBezier");
  TCase *tcase = tcase_create("CubicBezier");
  
  
  tcase_add_checked_fixture( tcase,
                            CubicBezierTest_setup,
                            CubicBezierTest_teardown );
  
  tcase_add_test( tcase, test_CubicBezier_create                );
  tcase_add_test( tcase, test_CubicBezier_createWithPoints      );
  tcase_add_test( tcase, test_CubicBezier_createWithPoints_NULL );
  tcase_add_test( tcase, test_CubicBezier_createWithCoordinates );
  tcase_add_test( tcase, test_CubicBezier_free_NULL             );
  tcase_add_test( tcase, test_CubicBezier_setStart              );
  tcase_add_test( tcase, test_CubicBezier_setStart_NULL         );
  tcase_add_test( tcase, test_CubicBezier_setBasePoint1         );
  tcase_add_test( tcase, test_CubicBezier_setBasePoint1_NULL    );
  tcase_add_test( tcase, test_CubicBezier_setBasePoint2         );
  tcase_add_test( tcase, test_CubicBezier_setBasePoint2_NULL    );
  tcase_add_test( tcase, test_CubicBezier_setEnd                );
  tcase_add_test( tcase, test_CubicBezier_setEnd_NULL           );
  tcase_add_test( tcase, test_CubicBezier_createFrom            );
  tcase_add_test( tcase, test_CubicBezier_copyConstructor       );
  tcase_add_test( tcase, test_CubicBezier_assignmentOperator    );
  
  suite_add_tcase(suite, tcase);
  
  return suite;
}
Beispiel #4
0
END_TEST

Suite* suite(void) {
    Suite* s = suite_create("queue");
    TCase *tc_core = tcase_create("core");
    tcase_add_checked_fixture (tc_core, setup, teardown);
    tcase_add_test(tc_core, test_init);
    tcase_add_test(tc_core, test_get);
    tcase_add_test(tc_core, test_get_missing);
    tcase_add_test(tc_core, test_put);
    tcase_add_test(tc_core, test_put_multiple);
    tcase_add_test(tc_core, test_fill_up);
    tcase_add_test(tc_core, test_overwrite);
    tcase_add_test(tc_core, test_contains);
    tcase_add_test(tc_core, test_does_not_contain);
    tcase_add_test(tc_core, test_remove);
    tcase_add_test(tc_core, test_remove_not_in_map);
    tcase_add_test(tc_core, test_is_empty);
    tcase_add_test(tc_core, test_size);
    tcase_add_test(tc_core, test_create);
    tcase_add_test(tc_core, test_iterate_empty);
    tcase_add_test(tc_core, test_iterate_one);
    tcase_add_test(tc_core, test_iterate_many);
    suite_add_tcase(s, tc_core);

    return s;
}
Beispiel #5
0
END_TEST




Suite *req_jobobit_suite(void)
  {
  Suite *s = suite_create("req_jobobit_suite methods");
  TCase *tc_core = tcase_create("req_jobobit_tests");
  tcase_add_test(tc_core, setup_from_test);
  tcase_add_test(tc_core, is_joined_test);
  tcase_add_test(tc_core, return_stdfile_test);
  tcase_add_test(tc_core, rel_resc_test);
  tcase_add_test(tc_core, handle_exiting_or_abort_substate_test);
  tcase_add_test(tc_core, setrerun_test);
  tcase_add_test(tc_core, setup_cpyfiles_test);
  tcase_add_test(tc_core, handle_returnstd_test);
  tcase_add_test(tc_core, mom_comm_test);
  tcase_add_test(tc_core, handle_complete_first_time_test);
  tcase_add_test(tc_core, handle_complete_second_time_test);
  tcase_add_test(tc_core, handle_complete_subjob_test);
  tcase_add_test(tc_core, handle_exited_test);
  tcase_add_test(tc_core, add_comment_to_parent_test);
  tcase_add_test(tc_core, end_of_job_accounting_test);
  tcase_add_test(tc_core, handle_terminating_array_subjob_test);
  tcase_add_test(tc_core, handle_rerunning_array_subjob_test);
  tcase_add_test(tc_core, handle_terminating_job_test);
  tcase_add_test(tc_core, handle_stageout_test);
  tcase_add_test(tc_core, update_substate_from_exit_status_test);
  tcase_add_test(tc_core, handle_stagedel_test);
  tcase_add_test(tc_core, get_used_test);
  suite_add_tcase(s, tc_core);

  return(s);
  }
Beispiel #6
0
END_TEST

void add_common_tests(Suite *s)
{
	TCase *tc_common = tcase_create("Common");
	tcase_add_test(tc_common, printe_options);
	tcase_add_test(tc_common, logprint_options);
	tcase_add_loop_test(tc_common, dmonth_return_within_range, 0, 12);
	tcase_add_test(tc_common, leapyears_are_known);
	tcase_add_test(tc_common, mosecs_return_values);
	tcase_add_test(tc_common, mosecs_does_not_change_tz);
	tcase_add_test(tc_common, mosecs_does_not_change_struct_tm_pointer_content);
	tcase_add_test(tc_common, countercalc_no_change_32bit);
	tcase_add_test(tc_common, countercalc_no_change_64bit);
	tcase_add_test(tc_common, countercalc_small_change_32bit);
	tcase_add_test(tc_common, countercalc_small_change_64bit);
	tcase_add_test(tc_common, countercalc_rollover_with_32bit);
	tcase_add_test(tc_common, countercalc_rollover_with_64bit);
	tcase_add_test(tc_common, countercalc_rollover_with_64bit_2);
	tcase_add_test(tc_common, countercalc_rollover_with_32bit_starting_32bit);
	tcase_add_test(tc_common, countercalc_rollover_with_32bit_starting_over_32bit);
	tcase_add_test(tc_common, countercalc_rollover_with_64bit_starting_32bit);
	tcase_add_test(tc_common, countercalc_rollover_with_64bit_starting_64bit);
	tcase_add_test(tc_common, strncpy_nt_with_below_maximum_length_string);
	tcase_add_test(tc_common, strncpy_nt_with_maximum_length_string);
	tcase_add_test(tc_common, strncpy_nt_with_over_maximum_length_string);
	tcase_add_test(tc_common, isnumeric_empty);
	tcase_add_test(tc_common, isnumeric_it_is);
	tcase_add_test(tc_common, isnumeric_it_is_not);
	tcase_add_test(tc_common, getversion_returns_a_version);
	tcase_add_test(tc_common, timeused_debug_outputs_something_expected_when_debug_is_enabled);
	tcase_add_test(tc_common, timeused_debug_does_not_output_anything_when_debug_is_disabled);
	tcase_add_test(tc_common, timeused_tracks_used_time);
	tcase_add_exit_test(tc_common, can_panic, 1);
	suite_add_tcase(s, tc_common);
}
Beispiel #7
0
END_TEST


Suite *pico_suite(void)
{
    Suite *s = suite_create("PicoTCP");

    TCase *TCase_check_opcode = tcase_create("Unit test for check_opcode");
    TCase *TCase_find_session_by_socket = tcase_create("Unit test for find_session_by_socket");
    TCase *TCase_tftp_finish = tcase_create("Unit test for tftp_finish");
    TCase *TCase_tftp_send_ack = tcase_create("Unit test for tftp_send_ack");
    TCase *TCase_tftp_send_req = tcase_create("Unit test for tftp_send_req");
    TCase *TCase_tftp_send_rx_req = tcase_create("Unit test for tftp_send_rx_req");
    TCase *TCase_tftp_send_tx_req = tcase_create("Unit test for tftp_send_tx_req");
    TCase *TCase_tftp_send_error = tcase_create("Unit test for tftp_send_error");
    TCase *TCase_tftp_send_data = tcase_create("Unit test for tftp_send_data");
    TCase *Tcase_pico_tftp_abort = tcase_create("Unit test for pico_tftp_abort");
    TCase *TCase_tftp_data = tcase_create("Unit test for tftp_data");
    TCase *TCase_tftp_ack = tcase_create("Unit test for tftp_ack");
    TCase *TCase_tftp_timeout = tcase_create("Unit test for tftp_timeout");
    TCase *TCase_tftp_req = tcase_create("Unit test for tftp_req");
    TCase *TCase_tftp_data_err = tcase_create("Unit test for tftp_data_err");
    TCase *TCase_tftp_fsm_timeout = tcase_create("Unit test for tftp_fsm_timeout");
    TCase *TCase_tftp_receive = tcase_create("Unit test for tftp_receive");
    TCase *TCase_tftp_cb = tcase_create("Unit test for tftp_cb");
    TCase *TCase_tftp_socket_open = tcase_create("Unit test for tftp_socket_open");


    tcase_add_test(TCase_check_opcode, tc_check_opcode);
    suite_add_tcase(s, TCase_check_opcode);
    tcase_add_test(TCase_find_session_by_socket, tc_find_session_by_socket);
    suite_add_tcase(s, TCase_find_session_by_socket);
    tcase_add_test(TCase_tftp_finish, tc_tftp_finish);
    suite_add_tcase(s, TCase_tftp_finish);
    tcase_add_test(TCase_tftp_send_ack, tc_tftp_send_ack);
    suite_add_tcase(s, TCase_tftp_send_ack);
    tcase_add_test(TCase_tftp_send_req, tc_tftp_send_req);
    suite_add_tcase(s, TCase_tftp_send_req);
    tcase_add_test(TCase_tftp_send_rx_req, tc_tftp_send_rx_req);
    suite_add_tcase(s, TCase_tftp_send_rx_req);
    tcase_add_test(TCase_tftp_send_tx_req, tc_tftp_send_tx_req);
    suite_add_tcase(s, TCase_tftp_send_tx_req);
    tcase_add_test(TCase_tftp_send_error, tc_tftp_send_error);
    suite_add_tcase(s, TCase_tftp_send_error);
    tcase_add_test(TCase_tftp_send_data, tc_tftp_send_data);
    suite_add_tcase(s, TCase_tftp_send_data);
    tcase_add_test(TCase_tftp_data, tc_tftp_data);
    suite_add_tcase(s, Tcase_pico_tftp_abort);
    tcase_add_test(Tcase_pico_tftp_abort, tc_pico_tftp_abort);
    suite_add_tcase(s, TCase_tftp_data);
    tcase_add_test(TCase_tftp_ack, tc_tftp_ack);
    suite_add_tcase(s, TCase_tftp_ack);
    tcase_add_test(TCase_tftp_timeout, tc_tftp_timeout);
    suite_add_tcase(s, TCase_tftp_timeout);
    tcase_add_test(TCase_tftp_req, tc_tftp_req);
    suite_add_tcase(s, TCase_tftp_req);
    tcase_add_test(TCase_tftp_data_err, tc_tftp_data_err);
    suite_add_tcase(s, TCase_tftp_data_err);
    tcase_add_test(TCase_tftp_fsm_timeout, tc_tftp_fsm_timeout);
    suite_add_tcase(s, TCase_tftp_fsm_timeout);
    tcase_add_test(TCase_tftp_receive, tc_tftp_receive);
    suite_add_tcase(s, TCase_tftp_receive);
    tcase_add_test(TCase_tftp_cb, tc_tftp_cb);
    suite_add_tcase(s, TCase_tftp_cb);
    tcase_add_test(TCase_tftp_socket_open, tc_tftp_socket_open);
    suite_add_tcase(s, TCase_tftp_socket_open);
    return s;
}
Beispiel #8
0
END_TEST


/* Create Suite */
Suite *inpdbzone_suite(void)
{
   Suite *s = suite_create("InPDBZone");
   TCase *tc_core          = tcase_create("Core"),
         *tc_single_resnum = tcase_create("Single_Resnum"),
         *tc_wrapper       = tcase_create("Wrapper");


   /* blInPDBZone() */
   /* Core */
   tcase_add_checked_fixture(tc_core, inpdbzone_setup, 
                             inpdbzone_teardown);
   tcase_add_test(tc_core, test_01);
   tcase_add_test(tc_core, test_02);
   tcase_add_test(tc_core, test_03);
   tcase_add_test(tc_core, test_04);
   tcase_add_test(tc_core, test_05);
   tcase_add_test(tc_core, test_06);
   tcase_add_test(tc_core, test_07);
   tcase_add_test(tc_core, test_08);
   tcase_add_test(tc_core, test_09);
   tcase_add_test(tc_core, test_10);
   tcase_add_test(tc_core, test_11);
   tcase_add_test(tc_core, test_12);
   suite_add_tcase(s, tc_core);

   /* Single resnum */
   tcase_add_checked_fixture(tc_single_resnum, inpdbzone_setup, 
                             inpdbzone_teardown);
   tcase_add_test(tc_single_resnum, test_single_resnum_01);
   tcase_add_test(tc_single_resnum, test_single_resnum_02);
   tcase_add_test(tc_single_resnum, test_single_resnum_03);
   tcase_add_test(tc_single_resnum, test_single_resnum_04);
   tcase_add_test(tc_single_resnum, test_single_resnum_05);
   tcase_add_test(tc_single_resnum, test_single_resnum_06);
   tcase_add_test(tc_single_resnum, test_single_resnum_07);
   tcase_add_test(tc_single_resnum, test_single_resnum_08);
   suite_add_tcase(s, tc_single_resnum);

   /* blInPDBZoneSpec() */
   /* Wrapper */
   tcase_add_checked_fixture(tc_wrapper, inpdbzone_setup, 
                             inpdbzone_teardown);
   tcase_add_test(tc_wrapper, test_wrapper_01);
   tcase_add_test(tc_wrapper, test_wrapper_02);
   tcase_add_test(tc_wrapper, test_wrapper_03);
   tcase_add_test(tc_wrapper, test_wrapper_04);
   tcase_add_test(tc_wrapper, test_wrapper_05);
   tcase_add_test(tc_wrapper, test_wrapper_06);   
   suite_add_tcase(s, tc_wrapper);
   return(s);
}
END_TEST

Suite* roman_converter_suite(void)
{
    Suite *s;
    TCase *tc_convert_to_arabic;
    TCase *tc_convert_to_roman;
    TCase *tc_invalid;

    s = suite_create("Roman Numerals Converter");

    tc_convert_to_arabic = tcase_create("Convert to Arabic");
    tc_convert_to_roman = tcase_create("Convert to Roman");
    tc_invalid = tcase_create("Invalid");

    // Convert to arabic test case
    tcase_add_test(tc_convert_to_arabic, test_convert_I_to_1);
    tcase_add_test(tc_convert_to_arabic, test_convert_II_to_2);
    tcase_add_test(tc_convert_to_arabic, test_convert_IV_to_4);
    tcase_add_test(tc_convert_to_arabic, test_convert_V_to_5);
    tcase_add_test(tc_convert_to_arabic, test_convert_VI_to_6);
    tcase_add_test(tc_convert_to_arabic, test_convert_IX_to_9);
    tcase_add_test(tc_convert_to_arabic, test_convert_X_to_10);
    tcase_add_test(tc_convert_to_arabic, test_convert_XL_to_40);
    tcase_add_test(tc_convert_to_arabic, test_convert_L_to_50);
    tcase_add_test(tc_convert_to_arabic, test_convert_XC_to_90);
    tcase_add_test(tc_convert_to_arabic, test_convert_C_to_100);
    tcase_add_test(tc_convert_to_arabic, test_convert_CD_to_400);
    tcase_add_test(tc_convert_to_arabic, test_convert_CD_to_500);
    tcase_add_test(tc_convert_to_arabic, test_convert_CM_to_900);
    tcase_add_test(tc_convert_to_arabic, test_convert_M_to_1000);


    // Convert to roman test case
    tcase_add_test(tc_convert_to_roman, test_convert_1_to_I);
    tcase_add_test(tc_convert_to_roman, test_convert_2_to_II);
    tcase_add_test(tc_convert_to_roman, test_convert_3_to_III);
    tcase_add_test(tc_convert_to_roman, test_convert_4_to_IV);
    tcase_add_test(tc_convert_to_roman, test_convert_5_to_V);
    tcase_add_test(tc_convert_to_roman, test_convert_9_to_IX);
    tcase_add_test(tc_convert_to_roman, test_convert_10_to_X);
    tcase_add_test(tc_convert_to_roman, test_convert_40_to_XL);
    tcase_add_test(tc_convert_to_roman, test_convert_50_to_L);
    tcase_add_test(tc_convert_to_roman, test_convert_90_to_XC);
    tcase_add_test(tc_convert_to_roman, test_convert_100_to_C);
    tcase_add_test(tc_convert_to_roman, test_convert_400_to_CD);
    tcase_add_test(tc_convert_to_roman, test_convert_500_to_D);
    tcase_add_test(tc_convert_to_roman, test_convert_900_to_CM);
    tcase_add_test(tc_convert_to_roman, test_convert_1000_to_M);

    // Test invalid
    tcase_add_test(tc_convert_to_roman, test_convert_4000_is_invalid);
    tcase_add_test(tc_convert_to_roman, test_convert_negative_values_is_invalid);
    tcase_add_test(tc_convert_to_roman, test_convert_zero_is_invalid);

    suite_add_tcase(s, tc_convert_to_roman);
    suite_add_tcase(s, tc_convert_to_arabic);
    suite_add_tcase(s, tc_invalid);

    return s;
}
END_TEST

Suite *job_func_suite(void)
  {
  Suite *s = suite_create("job_func_suite methods");
  TCase *tc_core = tcase_create("hostname_in_externals_test");
  tcase_add_test(tc_core, hostname_in_externals_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("fix_cray_exec_hosts_test");
  tcase_add_test(tc_core, fix_cray_exec_hosts_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("fix_external_exec_hosts_test");
  tcase_add_test(tc_core, fix_external_exec_hosts_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("change_external_job_name_test");
  tcase_add_test(tc_core, change_external_job_name_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("split_job_test");
  tcase_add_test(tc_core, split_job_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("job_abt_test");
  tcase_add_test(tc_core, job_abt_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("conn_qsub_test");
  tcase_add_test(tc_core, conn_qsub_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("job_alloc_test");
  tcase_add_test(tc_core, job_alloc_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("job_free_test");
  tcase_add_test(tc_core, job_free_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("copy_job_test");
  tcase_add_test(tc_core, copy_job_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("job_clone_test");
  tcase_add_test(tc_core, job_clone_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("job_clone_wt_test");
  tcase_add_test(tc_core, job_clone_wt_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("cpy_checkpoint_test");
  tcase_add_test(tc_core, cpy_checkpoint_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("remove_checkpoint_test");
  tcase_add_test(tc_core, remove_checkpoint_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("cleanup_restart_file_test");
  tcase_add_test(tc_core, cleanup_restart_file_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("record_jobinfo_test");
  tcase_add_test(tc_core, record_jobinfo_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("svr_job_purge_test");
  tcase_add_test(tc_core, svr_job_purge_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("find_job_by_array_test");
  tcase_add_test(tc_core, find_job_by_array_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("svr_find_job_test");
  tcase_add_test(tc_core, svr_find_job_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("get_jobs_array_test");
  tcase_add_test(tc_core, get_jobs_array_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("get_jobs_array_test");
  tcase_add_test(tc_core, get_jobs_array_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("get_jobs_queue_test");
  tcase_add_test(tc_core, get_jobs_queue_test);
  suite_add_tcase(s, tc_core);

  return(s);
  }
END_TEST


Suite *
create_suite_Reaction (void)
{
  Suite *suite = suite_create("Reaction");
  TCase *tcase = tcase_create("Reaction");


  tcase_add_checked_fixture(tcase, ReactionTest_setup, ReactionTest_teardown);

  tcase_add_test( tcase, test_Reaction_create          );
  //tcase_add_test( tcase, test_Reaction_createWith      );
  tcase_add_test( tcase, test_Reaction_free_NULL       );
  tcase_add_test( tcase, test_Reaction_setId           );
  tcase_add_test( tcase, test_Reaction_setName         );
  tcase_add_test( tcase, test_Reaction_reversible      );
  tcase_add_test( tcase, test_Reaction_fast            );
  tcase_add_test( tcase, test_Reaction_compartment     );
  tcase_add_test( tcase, test_Reaction_addReactant     );
  tcase_add_test( tcase, test_Reaction_addReactantBySpecies     );
  tcase_add_test( tcase, test_Reaction_addProduct      );
  tcase_add_test( tcase, test_Reaction_addProductBySpecies      );
  tcase_add_test( tcase, test_Reaction_addModifier     );
  tcase_add_test( tcase, test_Reaction_addModifierBySpecies     );
  tcase_add_test( tcase, test_Reaction_getReactant     );
  tcase_add_test( tcase, test_Reaction_getReactantById );
  tcase_add_test( tcase, test_Reaction_getProduct      );
  tcase_add_test( tcase, test_Reaction_getProductById  );
  tcase_add_test( tcase, test_Reaction_getModifier     );
  tcase_add_test( tcase, test_Reaction_getModifierById );
  tcase_add_test( tcase, test_Reaction_createWithNS         );
  tcase_add_test( tcase, test_Reaction_removeReactant  );
  tcase_add_test( tcase, test_Reaction_removeProduct   );
  tcase_add_test( tcase, test_Reaction_removeModifier  );

  suite_add_tcase(suite, tcase);

  return suite;
}
Beispiel #12
0
END_TEST


Suite *
create_suite_CalcUnitDefinition (void)
{
    Suite *suite = suite_create("CalcUnitDefinition");
    TCase *tcase = tcase_create("CalcUnitDefinition");

    tcase_add_checked_fixture(tcase,
                              CalcUnitDefinition_setup,
                              CalcUnitDefinition_teardown);

    tcase_add_test(tcase, test_CalcUnitDefinition_parameter );
    tcase_add_test(tcase, test_CalcUnitDefinition_parameter1 );

    tcase_add_test(tcase, test_CalcUnitDefinition_initialAssignment );
    tcase_add_test(tcase, test_CalcUnitDefinition_initialAssignment1 );
    tcase_add_test(tcase, test_CalcUnitDefinition_initialAssignment_useRn );
    tcase_add_test(tcase, test_CalcUnitDefinition_initialAssignment_useSR );
    tcase_add_test(tcase, test_CalcUnitDefinition_initialAssignment_useSR1 );

    tcase_add_test(tcase, test_CalcUnitDefinition_assignmentRule );
    tcase_add_test(tcase, test_CalcUnitDefinition_assignmentRule1 );

    tcase_add_test(tcase, test_CalcUnitDefinition_eventAssignment );
    tcase_add_test(tcase, test_CalcUnitDefinition_eventAssignment1 );
    tcase_add_test(tcase, test_CalcUnitDefinition_eventAssignment2 );

    tcase_add_test(tcase, test_CalcUnitDefinition_rateRule );
    tcase_add_test(tcase, test_CalcUnitDefinition_rateRule1 );

    tcase_add_test(tcase, test_CalcUnitDefinition_delay );

    tcase_add_test(tcase, test_CalcUnitDefinition_priority );

    tcase_add_test(tcase, test_CalcUnitDefinition_global_with_local_known );
    tcase_add_test(tcase, test_CalcUnitDefinition_global_with_local_unknown );

    tcase_add_test(tcase, test_CalcUnitDefinition_local );
    //tcase_add_test(tcase, test_CalcUnitDefinition_local1 );

    tcase_add_test(tcase, test_CalcUnitDefinition_unknownReaction );

    tcase_add_test(tcase, test_CalcUnitDefinition_rateRule_timeUnknown );

    tcase_add_test(tcase, test_CalcUnitDefinition_noModel );

    suite_add_tcase(suite, tcase);

    return suite;
}
Beispiel #13
0
END_TEST


Suite *
create_suite_L3_Compartment (void)
{
  Suite *suite = suite_create("L3_Compartment");
  TCase *tcase = tcase_create("L3_Compartment");


  tcase_add_checked_fixture( tcase,
                             L3CompartmentTest_setup,
                             L3CompartmentTest_teardown );

  tcase_add_test( tcase, test_L3_Compartment_create              );
  tcase_add_test( tcase, test_L3_Compartment_free_NULL           );
  tcase_add_test( tcase, test_L3_Compartment_id               );
  tcase_add_test( tcase, test_L3_Compartment_name             );
  tcase_add_test( tcase, test_L3_Compartment_units            );
  tcase_add_test( tcase, test_L3_Compartment_size           );
  tcase_add_test( tcase, test_L3_Compartment_constant      );
  tcase_add_test( tcase, test_L3_Compartment_spatialDimensions);
  tcase_add_test( tcase, test_L3_Compartment_createWithNS         );
  tcase_add_test( tcase, test_L3_Compartment_hasRequiredAttributes        );
  tcase_add_test( tcase, test_L3_Compartment_NS              );
  tcase_add_test( tcase, test_L3_Compartment_initDefaults              );

  suite_add_tcase(suite, tcase);

  return suite;
}
Beispiel #14
0
END_TEST


Suite * csstoken_suite (void) {
    Suite *s = suite_create( "CSS Token" );

    //
    //  Creation
    //
    TCase *tc_create = tcase_create( "Creation" );
    tcase_add_checked_fixture (tc_create, setup, teardown);
    tcase_add_test (tc_create, test_csstoken_create_value);
    tcase_add_test (tc_create, test_csstoken_create_start);
    tcase_add_test (tc_create, test_csstoken_create_end);
    tcase_add_test (tc_create, test_csstoken_create_length);
    tcase_add_test (tc_create, test_csstoken_create_type);
    suite_add_tcase (s, tc_create);
    //
    //  Equality 
    //
    TCase *tc_eq = tcase_create( "Equality" );
    tcase_add_checked_fixture (tc_eq, setup, teardown);
    tcase_add_test (tc_eq, test_csstoken_eq);
    tcase_add_test (tc_eq, test_csstoken_eq_value);
    tcase_add_test (tc_eq, test_csstoken_eq_start);
    tcase_add_test (tc_eq, test_csstoken_eq_end);
    tcase_add_test (tc_eq, test_csstoken_eq_length);
    tcase_add_test (tc_eq, test_csstoken_eq_type);
    suite_add_tcase (s, tc_eq);

    return s;
}
END_TEST


static
Suite*
make_test_suite (void)
{
	Suite* s;

	s = suite_create (__FILE__);

	TCase* tc_parse_raw = tcase_create ("parse-raw");
	suite_add_tcase (s, tc_parse_raw);
	tcase_add_test (tc_parse_raw, test_parse_raw_pass_001);
#ifndef PGM_CHECK_NOFORK
	tcase_add_test_raise_signal (tc_parse_raw, test_parse_raw_fail_001, SIGABRT);
#endif

	TCase* tc_parse_udp_encap = tcase_create ("parse-udp-encap");
	suite_add_tcase (s, tc_parse_udp_encap);
	tcase_add_test (tc_parse_udp_encap, test_parse_udp_encap_pass_001);
#ifndef PGM_CHECK_NOFORK
	tcase_add_test_raise_signal (tc_parse_udp_encap, test_parse_udp_encap_fail_001, SIGABRT);
#endif

	TCase* tc_verify_spm = tcase_create ("verify-spm");
	suite_add_tcase (s, tc_verify_spm);
	tcase_add_test (tc_verify_spm, test_verify_spm_pass_001);
#ifndef PGM_CHECK_NOFORK
	tcase_add_test_raise_signal (tc_verify_spm, test_verify_spm_fail_001, SIGABRT);
#endif

	TCase* tc_verify_spmr = tcase_create ("verify-spmr");
	suite_add_tcase (s, tc_verify_spmr);
	tcase_add_test (tc_verify_spmr, test_verify_spmr_pass_001);
#ifndef PGM_CHECK_NOFORK
	tcase_add_test_raise_signal (tc_verify_spmr, test_verify_spmr_fail_001, SIGABRT);
#endif

	TCase* tc_verify_nak = tcase_create ("verify-nak");
	suite_add_tcase (s, tc_verify_nak);
	tcase_add_test (tc_verify_nak, test_verify_nak_pass_001);
#ifndef PGM_CHECK_NOFORK
	tcase_add_test_raise_signal (tc_verify_nak, test_verify_nak_fail_001, SIGABRT);
#endif

	TCase* tc_verify_nnak = tcase_create ("verify-nnak");
	suite_add_tcase (s, tc_verify_nnak);
	tcase_add_test (tc_verify_nnak, test_verify_nnak_pass_001);
#ifndef PGM_CHECK_NOFORK
	tcase_add_test_raise_signal (tc_verify_nnak, test_verify_nnak_fail_001, SIGABRT);
#endif

	TCase* tc_verify_ncf = tcase_create ("verify-ncf");
	suite_add_tcase (s, tc_verify_ncf);
	tcase_add_test (tc_verify_ncf, test_verify_ncf_pass_001);
#ifndef PGM_CHECK_NOFORK
	tcase_add_test_raise_signal (tc_verify_ncf, test_verify_ncf_fail_001, SIGABRT);
#endif
	return s;
}
END_TEST

/******************************************************************************
 * Suite
 *****************************************************************************/
Suite *
cipher_suite(void) {
	Suite *s = suite_create("Cipher Suite");
	TCase *tc = NULL;

	/* md4 tests */
	tc = tcase_create("MD4");
	tcase_add_test(tc, test_md4_empty_string);
	tcase_add_test(tc, test_md4_a);
	tcase_add_test(tc, test_md4_abc);
	tcase_add_test(tc, test_md4_message_digest);
	tcase_add_test(tc, test_md4_a_to_z);
	tcase_add_test(tc, test_md4_A_to_Z_a_to_z_0_to_9);
	tcase_add_test(tc, test_md4_1_to_0_8_times);
	suite_add_tcase(s, tc);

	/* md5 tests */
	tc = tcase_create("MD5");
	tcase_add_test(tc, test_md5_empty_string);
	tcase_add_test(tc, test_md5_a);
	tcase_add_test(tc, test_md5_abc);
	tcase_add_test(tc, test_md5_message_digest);
	tcase_add_test(tc, test_md5_a_to_z);
	tcase_add_test(tc, test_md5_A_to_Z_a_to_z_0_to_9);
	tcase_add_test(tc, test_md5_1_to_0_8_times);
	suite_add_tcase(s, tc);

	/* sha1 tests */
	tc = tcase_create("SHA1");
	tcase_add_test(tc, test_sha1_empty_string);
	tcase_add_test(tc, test_sha1_a);
	tcase_add_test(tc, test_sha1_abc);
	tcase_add_test(tc, test_sha1_abcd_gibberish);
	tcase_add_test(tc, test_sha1_1000_as_1000_times);
	suite_add_tcase(s, tc);

	/* sha256 tests */
	tc = tcase_create("SHA256");
	tcase_add_test(tc, test_sha256_empty_string);
	tcase_add_test(tc, test_sha256_a);
	tcase_add_test(tc, test_sha256_abc);
	tcase_add_test(tc, test_sha256_abcd_gibberish);
	tcase_add_test(tc, test_sha256_1000_as_1000_times);
	suite_add_tcase(s, tc);

	/* des tests */
	tc = tcase_create("DES");
	tcase_add_test(tc, test_des_12345678);
	tcase_add_test(tc, test_des_abcdefgh);
	suite_add_tcase(s, tc);

	/* des3 ecb tests */
	tc = tcase_create("DES3 ECB");
	tcase_add_test(tc, test_des3_ecb_nist1);
	tcase_add_test(tc, test_des3_ecb_nist2);
	tcase_add_test(tc, test_des3_ecb_null_key);
	tcase_add_test(tc, test_des3_ecb_null_text);
	tcase_add_test(tc, test_des3_ecb_null_key_and_text);
	suite_add_tcase(s, tc);
	/* des3 cbc tests */
	tc = tcase_create("DES3 CBC");
	tcase_add_test(tc, test_des3_cbc_nist1);
	tcase_add_test(tc, test_des3_cbc_nist2);
	tcase_add_test(tc, test_des3_cbc_null_key);
	tcase_add_test(tc, test_des3_cbc_null_text);
	tcase_add_test(tc, test_des3_cbc_null_key_and_text);
	suite_add_tcase(s, tc);

	/* hmac tests */
	tc = tcase_create("HMAC");
	tcase_add_test(tc, test_hmac_md5_Hi);
	tcase_add_test(tc, test_hmac_md5_what);
	tcase_add_test(tc, test_hmac_md5_dd);
	tcase_add_test(tc, test_hmac_md5_cd);
	tcase_add_test(tc, test_hmac_md5_truncation);
	tcase_add_test(tc, test_hmac_md5_large_key);
	tcase_add_test(tc, test_hmac_md5_large_key_and_data);
	tcase_add_test(tc, test_hmac_md5_null_key);
	tcase_add_test(tc, test_hmac_md5_null_text);
	tcase_add_test(tc, test_hmac_md5_null_key_and_text);
	tcase_add_test(tc, test_hmac_sha1_Hi);
	tcase_add_test(tc, test_hmac_sha1_what);
	tcase_add_test(tc, test_hmac_sha1_dd);
	tcase_add_test(tc, test_hmac_sha1_cd);
	tcase_add_test(tc, test_hmac_sha1_truncation);
	tcase_add_test(tc, test_hmac_sha1_large_key);
	tcase_add_test(tc, test_hmac_sha1_large_key_and_data);
	tcase_add_test(tc, test_hmac_sha1_null_key);
	tcase_add_test(tc, test_hmac_sha1_null_text);
	tcase_add_test(tc, test_hmac_sha1_null_key_and_text);
	suite_add_tcase(s, tc);

	return s;
}
int main() {
    Suite *s = suite_create("Validation");
    TCase *tc_validation = tcase_create("Validation");
    SRunner *sr = srunner_create(s);

    int num_fails;

    suite_add_tcase(s, tc_validation);

    tcase_add_test(tc_validation, I_is_considered_valid);
    tcase_add_test(tc_validation, Z_is_considered_invalid);
    tcase_add_test(tc_validation, XI_is_considered_valid);
    tcase_add_test(tc_validation, XZ_is_considered_invalid);
    tcase_add_test(tc_validation, Dinosaurs_is_considered_invalid);

    tcase_add_test(tc_validation, MMXLVI_is_considered_valid);
    tcase_add_test(tc_validation, IXI_is_considered_invalid);
    tcase_add_test(tc_validation, IVI_is_considered_invalid);
    tcase_add_test(tc_validation, IM_is_considered_invalid);
    tcase_add_test(tc_validation, VV_is_considered_invalid);

    tcase_add_test(tc_validation, DD_is_considered_invalid);
    tcase_add_test(tc_validation, IXCD_is_considered_invalid);

    srunner_run_all(sr, CK_NORMAL);
    num_fails = srunner_ntests_failed(sr);
    srunner_free(sr);

    return num_fails == 0 ? 0 : 1;
}
Beispiel #18
0
} END_TEST

/* ----------------------------------------------------------------------------
 * Program
 * ------------------------------------------------------------------------- */

/*
 * Create a test suite for all registered test cases and run it.
 *
 * Tests must be run sequentially (in no-fork mode) or code coverage
 * cannot be determined properly.
 */
int
main(void) {
  void *suite = suite_create("protobluff/core/descriptor"),
       *tcase = NULL;

  /* Add tests to test case "iterator" */
  tcase = tcase_create("iterator");
  tcase_add_test(tcase, test_iterator);
  tcase_add_test(tcase, test_iterator_empty);
  suite_add_tcase(suite, tcase);

  /* Add tests to test case "field_by_tag" */
  tcase = tcase_create("field_by_tag");
  tcase_add_checked_fixture(tcase, setup, teardown);
  tcase_add_test(tcase, test_field_by_tag);
  tcase_add_test(tcase, test_field_by_tag_absent);
  tcase_add_test(tcase, test_field_by_tag_empty);
  tcase_add_test(tcase, test_field_by_tag_scattered);
  tcase_add_test(tcase, test_field_by_tag_scattered_absent);
  tcase_add_test(tcase, test_field_by_tag_extended);
  suite_add_tcase(suite, tcase);

  /* Add tests to test case "extend" */
  tcase = tcase_create("extend");
  tcase_add_checked_fixture(tcase, setup, teardown);
  tcase_add_test(tcase, test_extend);
  suite_add_tcase(suite, tcase);

  /* Add tests to test case "enum_iterator" */
  tcase = tcase_create("enum_iterator");
  tcase_add_test(tcase, test_enum_iterator);
  tcase_add_test(tcase, test_enum_iterator_empty);
  suite_add_tcase(suite, tcase);

  /* Add tests to test case "enum_value_by_number" */
  tcase = tcase_create("enum_value_by_number");
  tcase_add_test(tcase, test_enum_value_by_number);
  tcase_add_test(tcase, test_enum_value_by_number_absent);
  tcase_add_test(tcase, test_enum_value_by_number_empty);
  tcase_add_test(tcase, test_enum_value_by_number_scattered);
  tcase_add_test(tcase, test_enum_value_by_number_scattered_absent);
  suite_add_tcase(suite, tcase);

  /* Add tests to test case "oneof_iterator" */
  tcase = tcase_create("oneof_iterator");
  tcase_add_test(tcase, test_oneof_iterator);
  suite_add_tcase(suite, tcase);

  /* Create a test suite runner in no-fork mode */
  void *runner = srunner_create(suite);
  srunner_set_fork_status(runner, CK_NOFORK);

  /* Execute test suite runner */
  srunner_run_all(runner, CK_NORMAL);
  int failed = srunner_ntests_failed(runner);
  srunner_free(runner);

  /* Exit with status code */
  return failed ? EXIT_FAILURE : EXIT_SUCCESS;
}
Beispiel #19
0
END_TEST

Suite *
package_suite(void)
{
    Suite *s = suite_create("Package");
    TCase *tc;

    tc = tcase_create("Core");
    tcase_add_unchecked_fixture(tc, fixture_system_only, teardown);
    tcase_add_test(tc, test_refcounting);
    tcase_add_test(tc, test_userdata);
    tcase_add_test(tc, test_package_summary);
    tcase_add_test(tc, test_identical);
    tcase_add_test(tc, test_versions);
    tcase_add_test(tc, test_no_sourcerpm);
    suite_add_tcase(s, tc);

    tc = tcase_create("Requires");
    tcase_add_unchecked_fixture(tc, fixture_with_main, teardown);
    tcase_add_test(tc, test_get_requires);
    tcase_add_test(tc, test_get_more_requires);
    tcase_add_test(tc, test_chksum_fail);
    tcase_add_test(tc, test_installed);
    suite_add_tcase(s, tc);

    tc = tcase_create("WithRealRepo");
    tcase_add_unchecked_fixture(tc, fixture_yum, teardown);
    tcase_add_test(tc, test_checksums);
    tcase_add_test(tc, test_get_files);
    tcase_add_test(tc, test_get_updateinfo);
    tcase_add_test(tc, test_lookup_num);
    tcase_add_test(tc, test_packager);
    tcase_add_test(tc, test_sourcerpm);
    tcase_add_test(tc, test_presto);
    suite_add_tcase(s, tc);

    return s;
}
Beispiel #20
0
END_TEST


int main(int argc, char *argv[])
{
  int mpiret;
  sc_MPI_Comm mpicomm;
  int proc_size;
  int nf;
  
  p4est_connectivity_t *conn;
  p4est_t* p4est;
  
  /* MPI init */
  mpiret = sc_MPI_Init(&argc, &argv);
  SC_CHECK_MPI(mpiret);
  mpicomm = sc_MPI_COMM_WORLD;
  /* sc_init (mpicomm, 1, 1, NULL, SC_LP_ESSENTIAL); */
  mpiret = MPI_Comm_size(mpicomm, &proc_size);
  SC_CHECK_MPI (mpiret);
  /* pXest init */
  p4est_init(NULL, SC_LP_PRODUCTION);

#if (P4EST_DIM)==3
  conn = p8est_connectivity_new_unitcube();
#else
  conn = p4est_connectivity_new_unitsquare();
#endif

  p4est = p4est_new(mpicomm, conn, 0, NULL, NULL);
  global_p4est_pointer = p4est;
  
  /* start just-in-time dg-math */
  dgmath_jit_init();
  
  /* run tests */
  Suite *s1 = suite_create("Test Plotting Functions");
  SRunner *sr = srunner_create(s1);
  
  TCase *tc1 = tcase_create("Test Surface and Contour plotting");
  TCase *tc2 = tcase_create("Test Error Plotting");

  tcase_add_test(tc1, test_surface_plot);
  tcase_add_test(tc2, test_error_plot);
  tcase_set_timeout(tc2, 100);
  /* suite_add_tcase(s1,tc1);  */
  suite_add_tcase(s1,tc2); 
  
  srunner_run_all(sr, CK_ENV);
  nf = srunner_ntests_failed(sr);

  /* free pointers */
  dgmath_jit_destroy();

  /* free pXest */
  p4est_destroy(p4est);
  p4est_connectivity_destroy(conn);


  /* finalize mpi stuff   */
  /* sc_finalize(); */
  mpiret = sc_MPI_Finalize ();
  SC_CHECK_MPI(mpiret);
  srunner_free(sr);
  
  return nf == 0 ? 0 : 1;
}
Beispiel #21
0
END_TEST


static Suite* Streader_suite(void)
{
    Suite* s = suite_create("Streader");

    const int timeout = DEFAULT_TIMEOUT;

#define BUILD_TCASE(name)                   \
    TCase* tc_##name = tcase_create(#name); \
    suite_add_tcase(s, tc_##name);          \
    tcase_set_timeout(tc_##name, timeout)

    BUILD_TCASE(init);
    BUILD_TCASE(match);

    BUILD_TCASE(read_null);
    BUILD_TCASE(read_bool);
    BUILD_TCASE(read_int);
    BUILD_TCASE(read_float);
    BUILD_TCASE(read_string);
    BUILD_TCASE(read_tstamp);
    BUILD_TCASE(read_piref);
    BUILD_TCASE(read_list);
    BUILD_TCASE(read_dict);
    BUILD_TCASE(read_format);

#undef BUILD_TCASE

    tcase_add_test(tc_init, Initial_streader_has_no_error_set);

    tcase_add_test(tc_match, Matching_visible_characters_succeed);
    tcase_add_test(tc_match, Matching_wrong_characters_fails);
    tcase_add_test(tc_match, Characters_past_specified_length_are_ignored);
    tcase_add_test(tc_match, Matching_strings_requires_quotes_in_data);
    tcase_add_test(tc_match, Matching_strings_succeeds);
    tcase_add_test(tc_match, Matching_wrong_strings_fails);

    tcase_add_test(tc_read_null, Reading_null_consumes_data);
    tcase_add_test(tc_read_null, Null_token_with_trailing_garbage_is_rejected);

    tcase_add_test(tc_read_bool, Reading_bool_stores_correct_value);
    tcase_add_test(tc_read_bool, Bool_with_trailing_garbage_is_rejected);

    tcase_add_test(tc_read_int, Read_zero_int);
    tcase_add_test(tc_read_int, Read_nonzero_int);
    tcase_add_test(tc_read_int, Reading_too_large_int_in_magnitude_fails);

    tcase_add_test(tc_read_float, Read_zero_float);
    tcase_add_test(tc_read_float, Read_nonzero_float);
    tcase_add_test(tc_read_float, Whitespace_terminates_decimal_number);

    tcase_add_test(tc_read_string, Read_valid_string);
    tcase_add_test(tc_read_string, Reading_invalid_string_fails);

    tcase_add_test(tc_read_tstamp, Read_valid_tstamp);
    tcase_add_test(tc_read_tstamp, Reading_invalid_tstamp_fails);

    tcase_add_test(tc_read_piref, Read_valid_piref);
    tcase_add_test(tc_read_piref, Reading_invalid_piref_fails);

    tcase_add_test(tc_read_list, Read_empty_list);
    tcase_add_test(tc_read_list, Read_list_of_numbers);
    tcase_add_test(tc_read_list, Read_list_of_tstamps);
    tcase_add_test(tc_read_list, Callback_must_be_specified_for_nonempty_lists);
    tcase_add_test(tc_read_list, Callback_failure_interrupts_list_reading);

    tcase_add_test(tc_read_dict, Read_empty_dict);
    tcase_add_test(tc_read_dict, Read_dict_of_numbers);
    tcase_add_test(tc_read_dict, Callback_must_be_specified_for_nonempty_dicts);
    tcase_add_test(tc_read_dict, Callback_failure_interrupts_dict_reading);

    tcase_add_test(tc_read_format, Read_formatted_input);

    return s;
}
Beispiel #22
0
END_TEST


Suite *liblist_suite ( void )
{
    Suite *s = suite_create ( "Lib linked list tester" );

    /* Core test case */
    TCase *tc_core = tcase_create ( "Core" );
	TCase *tc_mt = tcase_create ("Multithreaded");

	tcase_add_test ( tc_core, llist_01_create_delete_lists );
    tcase_add_test ( tc_core, llist_02_add_nodes );
    tcase_add_test ( tc_core, llist_03_add_dynamic_nodes );
    tcase_add_test ( tc_core, llist_04_delete_nodes );
    tcase_add_test ( tc_core, llist_05_list_for_each );
    tcase_add_test ( tc_core, llist_06_insert_nodes );
    tcase_add_test ( tc_core, llist_07_test_stack );
    tcase_add_test ( tc_core, llist_08_list_reverse );
    tcase_add_test ( tc_core, llist_09_list_sort );
    tcase_add_test ( tc_core, llist_11_find_min_max );

    //really multithreaded test case
    tcase_add_test ( tc_mt, llist_01_create_delete_lists );
    tcase_add_test ( tc_mt, llist_02_add_nodes );
    tcase_add_test ( tc_mt, llist_03_add_dynamic_nodes );
    tcase_add_test ( tc_mt, llist_04_delete_nodes );
    tcase_add_test ( tc_mt, llist_05_list_for_each );
    tcase_add_test ( tc_mt, llist_06_insert_nodes );
    tcase_add_test ( tc_mt, llist_07_test_stack );
    tcase_add_test ( tc_mt, llist_08_list_reverse );
    tcase_add_test ( tc_mt, llist_09_list_sort );
    tcase_add_test ( tc_mt, llist_10_pure_add_delete_mt );
    tcase_add_test ( tc_mt, llist_11_find_min_max );


    suite_add_tcase ( s, tc_core );
	suite_add_tcase ( s, tc_mt );
    return s;
}
Beispiel #23
0
static Suite *
hls_demux_suite (void)
{
  Suite *s = suite_create ("hls_demux");
  TCase *tc_basicTest = tcase_create ("basicTest");

  tcase_add_test (tc_basicTest, simpleTest);
  tcase_add_test (tc_basicTest, testMasterPlaylist);
  tcase_add_test (tc_basicTest, testMediaPlaylistNotFound);
  tcase_add_test (tc_basicTest, testFragmentNotFound);
  tcase_add_test (tc_basicTest, testFragmentDownloadError);
  tcase_add_test (tc_basicTest, testSeek);
  tcase_add_test (tc_basicTest, testSeekKeyUnitPosition);
  tcase_add_test (tc_basicTest, testSeekPosition);
  tcase_add_test (tc_basicTest, testSeekUpdateStopPosition);
  tcase_add_test (tc_basicTest, testSeekSnapBeforePosition);
  tcase_add_test (tc_basicTest, testSeekSnapAfterPosition);
  tcase_add_test (tc_basicTest, testReverseSeekSnapBeforePosition);
  tcase_add_test (tc_basicTest, testReverseSeekSnapAfterPosition);

  tcase_add_unchecked_fixture (tc_basicTest, gst_adaptive_demux_test_setup,
      gst_adaptive_demux_test_teardown);

  suite_add_tcase (s, tc_basicTest);

  return s;
}
Beispiel #24
0
END_TEST


Suite* r3_suite (void) {
        Suite *suite = suite_create("blah");

        TCase *tcase = tcase_create("testcase");
        tcase_add_test(tcase, test_str_array);
        tcase_add_test(tcase, test_ltrim_slash);
        tcase_add_test(tcase, test_r3_node_construct_uniq);
        tcase_add_test(tcase, test_r3_node_find_edge);
        tcase_add_test(tcase, test_r3_tree_insert_pathl);
        tcase_add_test(tcase, test_compile_slug);
        tcase_add_test(tcase, test_compile);
        tcase_add_test(tcase, test_route_cmp);
        tcase_add_test(tcase, test_insert_route);
        tcase_add_test(tcase, test_pcre_pattern_simple);
        tcase_add_test(tcase, test_pcre_pattern_more);
        tcase_add_test(tcase, test_pcre_patterns_insert);
        tcase_add_test(tcase, benchmark_str);

        suite_add_tcase(suite, tcase);

        return suite;
}
Beispiel #25
0
END_TEST

Suite *tests_get_auth_suite(void) {
    Suite *suite;
    TCase *testcase;

    suite = suite_create("auth");

    testcase = tcase_create("base");

    tcase_add_checked_fixture(testcase, set_up, tear_down);

    /* pwent* et al */
    tcase_add_test(testcase, auth_setpwent_test);
    tcase_add_test(testcase, auth_endpwent_test);
    tcase_add_test(testcase, auth_getpwent_test);
    tcase_add_test(testcase, auth_getpwnam_test);
    tcase_add_test(testcase, auth_getpwuid_test);
    tcase_add_test(testcase, auth_name2uid_test);
    tcase_add_test(testcase, auth_uid2name_test);

    /* grent* et al */
    tcase_add_test(testcase, auth_setgrent_test);
    tcase_add_test(testcase, auth_endgrent_test);
    tcase_add_test(testcase, auth_getgrent_test);
    tcase_add_test(testcase, auth_getgrnam_test);
    tcase_add_test(testcase, auth_getgrgid_test);
    tcase_add_test(testcase, auth_gid2name_test);
    tcase_add_test(testcase, auth_name2gid_test);
    tcase_add_test(testcase, auth_getgroups_test);

    /* Caching tests */
    tcase_add_test(testcase, auth_cache_uid2name_test);
    tcase_add_test(testcase, auth_cache_gid2name_test);
    tcase_add_test(testcase, auth_cache_uid2name_failed_test);
    tcase_add_test(testcase, auth_cache_gid2name_failed_test);
    tcase_add_test(testcase, auth_cache_name2uid_failed_test);
    tcase_add_test(testcase, auth_cache_name2gid_failed_test);

#if 0
    /* Authorization */
    tcase_add_test(testcase, auth_authenticate_test);
    tcase_add_test(testcase, auth_authorize_test);
    tcase_add_test(testcase, auth_check_test);
    tcase_add_test(testcase, auth_requires_pass_test);

    /* Auth modules */
    tcase_add_test(testcase, auth_add_auth_only_module_test);
    tcase_add_test(testcase, auth_remove_auth_only_module_test);
    tcase_add_test(testcase, auth_clear_auth_only_modules_test);
#endif

    suite_add_tcase(suite, testcase);

    return suite;
}
Beispiel #26
0
END_TEST

/* public */
Suite *create_suite_odeSolver(void)
{
	Suite *s;
	TCase *tc_SBML_odeSolver;
	TCase *tc_Model_odeSolver;
	TCase *tc_VarySettings_allocate;
	TCase *tc_VarySettings_free;
	TCase *tc_VarySettings_addDesignPoint;
	TCase *tc_VarySettings_addParameter;
	TCase *tc_VarySettings_setName;
	TCase *tc_VarySettings_setValue;
	TCase *tc_VarySettings_getValue;
	TCase *tc_VarySettings_setValueByID;
	TCase *tc_VarySettings_getValueByID;
	TCase *tc_VarySettings_getName;
	TCase *tc_VarySettings_getReactionName;

	s = suite_create("odeSolver");

	tc_SBML_odeSolver = tcase_create("SBML_odeSolver");
	tcase_add_checked_fixture(tc_SBML_odeSolver,
							  NULL,
							  teardown_doc);
	tcase_add_checked_fixture(tc_SBML_odeSolver,
							  setup_cs,
							  teardown_cs);
	tcase_add_checked_fixture(tc_SBML_odeSolver,
							  NULL,
							  teardown_results);
	tcase_add_test(tc_SBML_odeSolver, test_SBML_odeSolver_MAPK);
	suite_add_tcase(s, tc_SBML_odeSolver);

	tc_Model_odeSolver = tcase_create("Model_odeSolver");
	tcase_add_checked_fixture(tc_Model_odeSolver,
							  NULL,
							  teardown_doc);
	tcase_add_checked_fixture(tc_Model_odeSolver,
							  setup_cs,
							  teardown_cs);
	tcase_add_checked_fixture(tc_Model_odeSolver,
							  NULL,
							  teardown_results);
	tcase_add_test(tc_Model_odeSolver, test_Model_odeSolver_basic_model1_forward_l2);
	tcase_add_test(tc_Model_odeSolver, test_Model_odeSolver_basic);
	tcase_add_test(tc_Model_odeSolver, test_Model_odeSolver_events_1_event_1_assignment_l2);
	tcase_add_test(tc_Model_odeSolver, test_Model_odeSolver_events_2_events_1_assignment_l2);
	tcase_add_test(tc_Model_odeSolver, test_Model_odeSolver_huang96);
	tcase_add_test(tc_Model_odeSolver, test_Model_odeSolver_repressilator);
	suite_add_tcase(s, tc_Model_odeSolver);

	tc_VarySettings_allocate = tcase_create("VarySettings_allocate");
	tcase_add_checked_fixture(tc_VarySettings_allocate,
							  NULL,
							  teardown_vs);
	tcase_add_test(tc_VarySettings_allocate, test_VarySettings_allocate);
	suite_add_tcase(s, tc_VarySettings_allocate);

	tc_VarySettings_free = tcase_create("VarySettings_free");
	tcase_add_test(tc_VarySettings_free, test_VarySettings_free);
	suite_add_tcase(s, tc_VarySettings_free);

	tc_VarySettings_addDesignPoint = tcase_create("VarySettings_addDesignPoint");
	tcase_add_checked_fixture(tc_VarySettings_addDesignPoint,
							  setup_vs,
							  teardown_vs);
	tcase_add_test(tc_VarySettings_addDesignPoint, test_VarySettings_addDesignPoint);
	suite_add_tcase(s, tc_VarySettings_addDesignPoint);

	tc_VarySettings_addParameter = tcase_create("VarySettings_addParameter");
	tcase_add_checked_fixture(tc_VarySettings_addParameter,
							  setup_vs,
							  teardown_vs);
	tcase_add_test(tc_VarySettings_addParameter, test_VarySettings_addParameter);
	suite_add_tcase(s, tc_VarySettings_addParameter);

	tc_VarySettings_setName = tcase_create("VarySettings_setName");
	tcase_add_checked_fixture(tc_VarySettings_setName,
							  setup_vs,
							  teardown_vs);
	tcase_add_test(tc_VarySettings_setName, test_VarySettings_setName);
	suite_add_tcase(s, tc_VarySettings_setName);

	tc_VarySettings_setValue = tcase_create("VarySettings_setValue");
	tcase_add_checked_fixture(tc_VarySettings_setValue,
							  setup_vs,
							  teardown_vs);
	tcase_add_test(tc_VarySettings_setValue, test_VarySettings_setValue);
	suite_add_tcase(s, tc_VarySettings_setValue);

	tc_VarySettings_getValue = tcase_create("VarySettings_getValue");
	tcase_add_checked_fixture(tc_VarySettings_getValue,
							  setup_vs,
							  teardown_vs);
	tcase_add_test(tc_VarySettings_getValue, test_VarySettings_getValue);
	suite_add_tcase(s, tc_VarySettings_getValue);

	tc_VarySettings_setValueByID = tcase_create("VarySettings_setValueByID");
	tcase_add_checked_fixture(tc_VarySettings_setValueByID,
							  setup_vs,
							  teardown_vs);
	tcase_add_test(tc_VarySettings_setValueByID, test_VarySettings_setValueByID);
	suite_add_tcase(s, tc_VarySettings_setValueByID);

	tc_VarySettings_getValueByID = tcase_create("VarySettings_getValueByID");
	tcase_add_checked_fixture(tc_VarySettings_getValueByID,
							  setup_vs,
							  teardown_vs);
	tcase_add_test(tc_VarySettings_getValueByID, test_VarySettings_getValueByID);
	suite_add_tcase(s, tc_VarySettings_getValueByID);

	tc_VarySettings_getName = tcase_create("VarySettings_getName");
	tcase_add_checked_fixture(tc_VarySettings_getName,
							  setup_vs,
							  teardown_vs);
	tcase_add_test(tc_VarySettings_getName, test_VarySettings_getName);
	suite_add_tcase(s, tc_VarySettings_getName);

	tc_VarySettings_getReactionName = tcase_create("VarySettings_getReactionName");
	tcase_add_checked_fixture(tc_VarySettings_getReactionName,
							  setup_vs,
							  teardown_vs);
	tcase_add_test(tc_VarySettings_getReactionName, test_VarySettings_getReactionName);
	suite_add_tcase(s, tc_VarySettings_getReactionName);

	return s;
}
Beispiel #27
0
END_TEST

Suite *
signon_suite(void)
{
    Suite *s = suite_create ("signon-glib");

    /* Core test case */
    TCase * tc_core = tcase_create("Core");

    /*
     * 18 minutes timeout
     * */
    tcase_set_timeout(tc_core, 1080);
    tcase_add_test (tc_core, test_init);
    tcase_add_test (tc_core, test_query_methods);
    tcase_add_test (tc_core, test_query_mechanisms);
    tcase_add_test (tc_core, test_get_existing_identity);
    tcase_add_test (tc_core, test_get_nonexisting_identity);

    tcase_add_test (tc_core, test_auth_session_creation);
    tcase_add_test (tc_core, test_auth_session_query_mechanisms);
    tcase_add_test (tc_core, test_auth_session_query_mechanisms_nonexisting);
    tcase_add_test (tc_core, test_auth_session_process);
    tcase_add_test (tc_core, test_store_credentials_identity);
    tcase_add_test (tc_core, test_verify_secret_identity);
    tcase_add_test (tc_core, test_remove_identity);
    tcase_add_test (tc_core, test_info_identity);

    tcase_add_test (tc_core, test_signout_identity);
    tcase_add_test (tc_core, test_unregistered_identity);
    tcase_add_test (tc_core, test_unregistered_auth_session);

    tcase_add_test (tc_core, test_regression_unref);

    suite_add_tcase (s, tc_core);

    return s;
}
Beispiel #28
0
END_TEST

void add_ifinfo_tests(Suite *s)
{
	TCase *tc_ifinfo = tcase_create("Ifinfo");
	tcase_add_test(tc_ifinfo, parseifinfo_zero_change);
	tcase_add_test(tc_ifinfo, parseifinfo_1kb_change);
	tcase_add_test(tc_ifinfo, parseifinfo_newdb);
	tcase_add_test(tc_ifinfo, parseifinfo_1kb_change_with_booted_system);
	tcase_add_test(tc_ifinfo, parseifinfo_long_update_interval_causes_sync);
	tcase_add_test(tc_ifinfo, parseifinfo_hitting_maxbw_limit_causes_sync);
	tcase_add_test(tc_ifinfo, parseifinfo_multiple_parses);
	tcase_add_test(tc_ifinfo, getiflist_no_source);
	tcase_add_test(tc_ifinfo, getiflist_proc_one_interface);
	tcase_add_test(tc_ifinfo, getiflist_proc_one_interface_with_speed);
	tcase_add_test(tc_ifinfo, getiflist_proc_multiple_interfaces);
	tcase_add_test(tc_ifinfo, getiflist_sysclassnet_one_interface);
	tcase_add_test(tc_ifinfo, getiflist_sysclassnet_one_interface_with_speed);
	tcase_add_test(tc_ifinfo, getiflist_sysclassnet_multiple_interfaces);
	tcase_add_test(tc_ifinfo, readproc_no_file);
	tcase_add_test(tc_ifinfo, readproc_not_found);
	tcase_add_test(tc_ifinfo, readproc_success);
	tcase_add_test(tc_ifinfo, readsysclassnet_not_found);
	tcase_add_test(tc_ifinfo, readsysclassnet_success);
	tcase_add_test(tc_ifinfo, getifinfo_not_found);
	tcase_add_test(tc_ifinfo, getifinfo_success);
	suite_add_tcase(s, tc_ifinfo);
}
Beispiel #29
0
END_TEST

static Suite* testSuite_Client(void) {
    Suite *s = suite_create("Register Server and Client");
    TCase *tc_register = tcase_create("RegisterServer");
    tcase_add_unchecked_fixture(tc_register, setup_lds, teardown_lds);
    tcase_add_unchecked_fixture(tc_register, setup_register, teardown_register);
    tcase_add_test(tc_register, Server_register);
    // register two times, just for fun
    tcase_add_test(tc_register, Server_register);
    tcase_add_test(tc_register, Server_unregister);
    tcase_add_test(tc_register, Server_register_periodic);
    tcase_add_test(tc_register, Server_unregister_periodic);
    suite_add_tcase(s,tc_register);

    TCase *tc_register_retry = tcase_create("RegisterServer Retry");
    //tcase_add_unchecked_fixture(tc_register, setup_lds, teardown_lds);
    tcase_add_unchecked_fixture(tc_register_retry, setup_register, teardown_register);
    tcase_add_test(tc_register_retry, Server_register_periodic);
    tcase_add_test(tc_register_retry, Util_wait_startup); // wait a bit to let first try run through
    // now start LDS
    tcase_add_test(tc_register_retry, Util_start_lds);
    tcase_add_test(tc_register_retry, Util_wait_retry);
    // check if there
    tcase_add_test(tc_register_retry, Client_find_registered);
    tcase_add_test(tc_register_retry, Server_unregister_periodic);
    tcase_add_test(tc_register_retry, Client_find_discovery);
    tcase_add_test(tc_register_retry, Util_stop_lds);

    suite_add_tcase(s,tc_register_retry);

#ifdef UA_ENABLE_DISCOVERY_MULTICAST
    TCase *tc_register_find = tcase_create("RegisterServer and FindServers");
    tcase_add_unchecked_fixture(tc_register_find, setup_lds, teardown_lds);
    tcase_add_unchecked_fixture(tc_register_find, setup_register, teardown_register);
    tcase_add_test(tc_register_find, Client_find_discovery);
    tcase_add_test(tc_register_find, Server_register);
    tcase_add_test(tc_register_find, Client_find_registered);
    tcase_add_test(tc_register_find, Util_wait_mdns);
    tcase_add_test(tc_register_find, Client_find_on_network_registered);
    tcase_add_test(tc_register_find, Client_find_filter);
    tcase_add_test(tc_register_find, Client_get_endpoints);
    tcase_add_test(tc_register_find, Client_filter_locale);
    tcase_add_test(tc_register_find, Server_unregister);
    tcase_add_test(tc_register_find, Client_find_discovery);
    tcase_add_test(tc_register_find, Client_filter_discovery);
    suite_add_tcase(s,tc_register_find);
#endif

    // register server again, then wait for timeout and auto unregister
    TCase *tc_register_timeout = tcase_create("RegisterServer timeout");
    tcase_add_unchecked_fixture(tc_register_timeout, setup_lds, teardown_lds);
    tcase_add_unchecked_fixture(tc_register_timeout, setup_register, teardown_register);
    tcase_set_timeout(tc_register_timeout, checkWait+2);
    tcase_add_test(tc_register_timeout, Server_register);
    tcase_add_test(tc_register_timeout, Client_find_registered);
    tcase_add_test(tc_register_timeout, Util_wait_timeout);
    tcase_add_test(tc_register_timeout, Client_find_discovery);
#ifdef UA_ENABLE_DISCOVERY_SEMAPHORE
    // now check if semaphore file works
    tcase_add_test(tc_register_timeout, Server_register_semaphore);
    tcase_add_test(tc_register_timeout, Client_find_registered);
    tcase_add_test(tc_register_timeout, Server_unregister_semaphore);
    tcase_add_test(tc_register_timeout, Util_wait_timeout);
    tcase_add_test(tc_register_timeout, Client_find_discovery);
#endif
    suite_add_tcase(s,tc_register_timeout);
    return s;
}
END_TEST

Suite *bio_reader_suite_create()
{
	Suite *s;
	TCase *tc;

	s = suite_create("bio_reader");

	tc = tcase_create("integer reads");
	tcase_add_test(tc, test_read_uint8);
	tcase_add_test(tc, test_read_uint16);
	tcase_add_test(tc, test_read_uint24);
	tcase_add_test(tc, test_read_uint32);
	tcase_add_test(tc, test_read_uint64);
	suite_add_tcase(s, tc);

	tc = tcase_create("integer reads from end");
	tcase_add_test(tc, test_read_uint8_end);
	tcase_add_test(tc, test_read_uint16_end);
	tcase_add_test(tc, test_read_uint24_end);
	tcase_add_test(tc, test_read_uint32_end);
	tcase_add_test(tc, test_read_uint64_end);
	suite_add_tcase(s, tc);

	tc = tcase_create("data reads and peek");
	tcase_add_test(tc, test_read_data);
	tcase_add_test(tc, test_read_data_end);
	suite_add_tcase(s, tc);

	tc = tcase_create("data length reads");
	tcase_add_test(tc, test_read_data8);
	tcase_add_test(tc, test_read_data16);
	tcase_add_test(tc, test_read_data24);
	tcase_add_test(tc, test_read_data32);
	suite_add_tcase(s, tc);

	tc = tcase_create("constructors");
	tcase_add_test(tc, test_create);
	tcase_add_test(tc, test_create_own);
	suite_add_tcase(s, tc);

	return s;
}