Suite *local_suite(void)
{
    Suite *s  = suite_create(__FILE__);
    TCase *tc = tcase_create(__FILE__);

    /* put responses */
    TEST_RES1(bsp_get_put_res, "INSERTED 4\r\n",      BSC_PUT_RES_INSERTED,      uint64_t, 4, intcmp, 1);
    TEST_RES1(bsp_get_put_res, "BURIED 4\r\n",        BSC_RES_BURIED,            uint64_t, 4, intcmp, 1);
    TEST_RES1(bsp_get_put_res, "EXPECTED_CRLF\r\n",   BSC_PUT_RES_EXPECTED_CRLF, uint64_t, 0, intcmp, 0);
    TEST_RES1(bsp_get_put_res, "JOB_TOO_BIG\r\n",     BSC_PUT_RES_JOB_TOO_BIG,   uint64_t, 0, intcmp, 0);
    TEST_RES1(bsp_get_put_res, "OUT_OF_MEMORY\r\n",   BSC_RES_OUT_OF_MEMORY,     uint64_t, 0, intcmp, 0);
    TEST_RES1(bsp_get_put_res, "INTERNAL_ERROR\r\n",  BSC_RES_INTERNAL_ERROR,    uint64_t, 0, intcmp, 0);
    TEST_RES1(bsp_get_put_res, "UNKNOWN_COMMAND\r\n", BSC_RES_UNKNOWN_COMMAND,   uint64_t, 0, intcmp, 0);

    /* use responses */
    TEST_RES1(bsp_get_use_res, "USING bar\r\n",       BSC_USE_RES_USING,         char *,   "bar", strcmp, 1);
    TEST_RES1(bsp_get_use_res, "OUT_OF_MEMORY\r\n",   BSC_RES_OUT_OF_MEMORY,     char *,   "bar", strcmp, 0);
    
    /* reserve responses */
    TEST_RES3( bsp_get_reserve_res, "RESERVED 3456543 3\r\n", BSC_RESERVE_RES_RESERVED,      3456543, 1);
    TEST_RES3( bsp_get_reserve_res, "DEADLINE_SOON\r\n",      BSC_RESERVE_RES_DEADLINE_SOON, 3456543, 0);
    TEST_RES3( bsp_get_reserve_res, "TIMED_OUT\r\n",          BSC_RESERVE_RES_TIMED_OUT,     3456543, 0);
    TEST_RES3( bsp_get_reserve_res, "INTERNAL_ERROR\r\n",     BSC_RES_INTERNAL_ERROR,        3456543, 0);
    TEST_RES3( bsp_get_reserve_res, "UNKNOWN_COMMAND\r\n",    BSC_RES_UNKNOWN_COMMAND,       3456543, 0);

    /* delete responses */
    TEST_RES(  bsp_get_delete_res,   "DELETED\r\n",        BSC_DELETE_RES_DELETED   );
    TEST_RES(  bsp_get_delete_res,   "NOT_FOUND\r\n",      BSC_RES_NOT_FOUND        );
    TEST_RES(  bsp_get_delete_res,   "OUT_OF_MEMORY\r\n",  BSC_RES_OUT_OF_MEMORY    );

    /* release responses */
    TEST_RES(  bsp_get_release_res,  "RELEASED\r\n",       BSC_RELEASE_RES_RELEASED );
    TEST_RES(  bsp_get_release_res,  "BURIED\r\n",         BSC_RES_BURIED           );
    TEST_RES(  bsp_get_release_res,  "NOT_FOUND\r\n",      BSC_RES_NOT_FOUND        );
    TEST_RES(  bsp_get_release_res,  "INTERNAL_ERROR\r\n", BSC_RES_INTERNAL_ERROR   );

    /* bury responses */
    TEST_RES(  bsp_get_bury_res,     "BURIED\r\n",         BSC_RES_BURIED           );
    TEST_RES(  bsp_get_bury_res,     "NOT_FOUND\r\n",      BSC_RES_NOT_FOUND        );
    TEST_RES(  bsp_get_bury_res,     "INTERNAL_ERROR\r\n", BSC_RES_INTERNAL_ERROR   );

    /* touch responses */
    TEST_RES(  bsp_get_touch_res,    "TOUCHED\r\n",         BSC_TOUCH_RES_TOUCHED    );
    TEST_RES(  bsp_get_touch_res,    "NOT_FOUND\r\n",       BSC_RES_NOT_FOUND        );
    TEST_RES(  bsp_get_touch_res,    "UNKNOWN_COMMAND\r\n", BSC_RES_UNKNOWN_COMMAND  );

    /* watch responses */
    TEST_RES1(bsp_get_watch_res, "WATCHING 4\r\n",      BSC_RES_WATCHING,       uint32_t, 4, intcmp, 1);
    TEST_RES1(bsp_get_watch_res, "OUT_OF_MEMORY\r\n",   BSC_RES_OUT_OF_MEMORY,  uint32_t, 0, intcmp, 0);

    /* ignore responses */
    TEST_RES1(bsp_get_ignore_res, "WATCHING 4\r\n",      BSC_RES_WATCHING,           uint32_t, 4, intcmp, 1);
    TEST_RES1(bsp_get_ignore_res, "NOT_IGNORED\r\n",     BSC_IGNORE_RES_NOT_IGNORED, uint32_t, 0, intcmp, 0);
    TEST_RES1(bsp_get_ignore_res, "OUT_OF_MEMORY\r\n",   BSC_RES_OUT_OF_MEMORY,      uint32_t, 0, intcmp, 0);

    /* peek responses */
    TEST_RES3( bsp_get_peek_res, "FOUND 3456543 3\r\n", BSC_PEEK_RES_FOUND,        3456543, 1);
    TEST_RES3( bsp_get_peek_res, "NOT_FOUND\r\n",       BSC_RES_NOT_FOUND,         3456543, 0);
    TEST_RES3( bsp_get_peek_res, "INTERNAL_ERROR\r\n",  BSC_RES_INTERNAL_ERROR,    3456543, 0);
    TEST_RES3( bsp_get_peek_res, "GIBRISH\r\n",         BSC_RES_UNRECOGNIZED, 3456543, 0);

    /* kick responses */
    TEST_RES1(bsp_get_kick_res, "KICKED 4\r\n",        BSC_KICK_RES_KICKED,        uint32_t, 4, intcmp, 1);
    TEST_RES1(bsp_get_kick_res, "OUT_OF_MEMORY\r\n",   BSC_RES_OUT_OF_MEMORY,      uint32_t, 0, intcmp, 0);

    /* pause-tube responses */
    TEST_RES(  bsp_get_pause_tube_res,    "PAUSED\r\n",          BSC_PAUSE_TUBE_RES_PAUSED  );
    TEST_RES(  bsp_get_pause_tube_res,    "NOT_FOUND\r\n",       BSC_RES_NOT_FOUND          );
    TEST_RES(  bsp_get_pause_tube_res,    "GIBRISH\r\n",         BSC_RES_UNRECOGNIZED  );
    suite_add_tcase(s, tc);

    return s;
}
void check_register_cases(Suite *suite, int threading)
{
  suite_add_tcase(suite, register_tcase(threading));
  suite_add_tcase(suite, pingpong_tcase(threading));
}
Esempio n. 3
0
END_TEST
#endif /* !OPENSSL_NO_ENGINE */

Suite *
ssl_suite(void)
{
	Suite *s;
	TCase *tc;

	s = suite_create("ssl");

	tc = tcase_create("ssl_wildcardify");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_wildcardify_01);
	tcase_add_test(tc, ssl_wildcardify_02);
	tcase_add_test(tc, ssl_wildcardify_03);
	suite_add_tcase(s, tc);

	tc = tcase_create("ssl_dnsname_match");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_dnsname_match_01);
	tcase_add_test(tc, ssl_dnsname_match_02);
	tcase_add_test(tc, ssl_dnsname_match_03);
	tcase_add_test(tc, ssl_dnsname_match_04);
	tcase_add_test(tc, ssl_dnsname_match_05);
	tcase_add_test(tc, ssl_dnsname_match_06);
	tcase_add_test(tc, ssl_dnsname_match_07);
	tcase_add_test(tc, ssl_dnsname_match_08);
	tcase_add_test(tc, ssl_dnsname_match_09);
	tcase_add_test(tc, ssl_dnsname_match_10);
	tcase_add_test(tc, ssl_dnsname_match_11);
	tcase_add_test(tc, ssl_dnsname_match_12);
	tcase_add_test(tc, ssl_dnsname_match_13);
	tcase_add_test(tc, ssl_dnsname_match_14);
	tcase_add_test(tc, ssl_dnsname_match_15);
	tcase_add_test(tc, ssl_dnsname_match_16);
	suite_add_tcase(s, tc);

	tc = tcase_create("ssl_tls_clienthello_parse");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_tls_clienthello_parse_00);
	tcase_add_test(tc, ssl_tls_clienthello_parse_01);
	tcase_add_test(tc, ssl_tls_clienthello_parse_02);
	tcase_add_test(tc, ssl_tls_clienthello_parse_03);
	tcase_add_test(tc, ssl_tls_clienthello_parse_04);
	tcase_add_test(tc, ssl_tls_clienthello_parse_05);
	tcase_add_test(tc, ssl_tls_clienthello_parse_06);
	tcase_add_test(tc, ssl_tls_clienthello_parse_07);
	tcase_add_test(tc, ssl_tls_clienthello_parse_08);
	tcase_add_test(tc, ssl_tls_clienthello_parse_09);
	tcase_add_test(tc, ssl_tls_clienthello_parse_10);
	suite_add_tcase(s, tc);

	tc = tcase_create("ssl_key_identifier_sha1");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_key_identifier_sha1_01);
	suite_add_tcase(s, tc);

	tc = tcase_create("ssl_x509_names");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_x509_names_01);
	suite_add_tcase(s, tc);

	tc = tcase_create("ssl_x509_names_to_str");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_x509_names_to_str_01);
	tcase_add_test(tc, ssl_x509_names_to_str_02);
	suite_add_tcase(s, tc);

	tc = tcase_create("ssl_x509_subject");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_x509_subject_01);
	suite_add_tcase(s, tc);

	tc = tcase_create("ssl_x509_subject_cn");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_x509_subject_cn_01);
	suite_add_tcase(s, tc);

	tc = tcase_create("ssl_x509_ocsps");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_x509_ocsps_01);
	tcase_add_test(tc, ssl_x509_ocsps_02);
	suite_add_tcase(s, tc);

	tc = tcase_create("ssl_is_ocspreq");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_is_ocspreq_01);
	suite_add_tcase(s, tc);

	tc = tcase_create("ssl_features");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_features_01);
	tcase_add_test(tc, ssl_features_02);
	suite_add_tcase(s, tc);

	tc = tcase_create("ssl_key_refcount_inc");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_key_refcount_inc_01);
	suite_add_tcase(s, tc);

	tc = tcase_create("ssl_x509_refcount_inc");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_x509_refcount_inc_01);
	suite_add_tcase(s, tc);

#ifndef OPENSSL_NO_ENGINE
	tc = tcase_create("ssl_engine");
	tcase_add_checked_fixture(tc, ssl_setup, ssl_teardown);
	tcase_add_test(tc, ssl_engine_01);
	suite_add_tcase(s, tc);
#else /* OPENSSL_NO_ENGINE */
	fprintf(stderr, "ssl: 1 test omitted because OpenSSL has no "
	                "engine support\n");
#endif /* OPENSSL_NO_ENGINE */

	return s;
}
Esempio n. 4
0
END_TEST

/* cria suite de testes */
Suite * hd_suite(void)
{
	Suite *s = suite_create("LDC_HD");

	/* testes para a format_megabyte */
	TCase *tc_hd_format = tcase_create("HD_format");
	tcase_add_test(tc_hd_format, format_with_0m);
	tcase_add_test(tc_hd_format, format_with_1m);
	tcase_add_test(tc_hd_format, format_with_1024m);
	tcase_add_test(tc_hd_format, format_with_1025m);
	tcase_add_test(tc_hd_format, format_with_2047m);
	tcase_add_test(tc_hd_format, format_with_2048m);
	tcase_add_test(tc_hd_format, format_with_1024g);
	tcase_add_test(tc_hd_format, format_with_1025g);

	/* testes para a função get_info */
	TCase *tc_hd_get_info = tcase_create("HD_get_info");
	tcase_add_test(tc_hd_get_info, get_info_ok);
	tcase_add_test(tc_hd_get_info, get_info_with_null_device);


	/* testes para a função add_device_main_info */
	TCase *tc_hd_add_device_main_info = tcase_create("HD_add_device_main_info");
	tcase_add_test(tc_hd_add_device_main_info, add_device_main_info_ok);
	tcase_add_test(tc_hd_add_device_main_info, add_device_main_info_with_null_device);


	/* testes para a função add_device_size_info */
	TCase *tc_hd_add_device_size_info = tcase_create("HD_add_device_size_info");
	tcase_add_test(tc_hd_add_device_size_info, add_device_size_info_ok);
	tcase_add_test(tc_hd_add_device_size_info, add_device_size_info_with_null_device);


	/* testes para a função add_part_info */
	TCase *tc_hd_add_part_info = tcase_create("HD_add_part_info");
	tcase_add_test(tc_hd_add_part_info, add_part_info_ok);
	tcase_add_test(tc_hd_add_part_info, add_part_info_with_null_device);


	/* testes para a função add_part_flags */
	TCase *tc_hd_add_part_flags = tcase_create("HD_add_part_flags");
	tcase_add_test(tc_hd_add_part_flags, add_part_flags_ok);
	tcase_add_test(tc_hd_add_part_flags, add_part_flags_with_null_device);


	/* testes para a função add_geom_info */
	TCase *tc_hd_add_geom_info = tcase_create("HD_add_geom_info");
	tcase_add_test(tc_hd_add_geom_info, add_geom_info_ok);
	tcase_add_test(tc_hd_add_geom_info, add_geom_info_with_null_device);


	/* testes para a função add_df_info */
	TCase *tc_hd_add_df_info = tcase_create("HD_add_df_info");
	tcase_add_test(tc_hd_add_df_info, add_df_info_ok);
	tcase_add_test(tc_hd_add_df_info, add_df_info_with_null_device);


	/* testes para a função add_file_system_info */
	TCase *tc_hd_add_file_system_info = tcase_create("HD_add_file_system_info");
	tcase_add_test(tc_hd_add_file_system_info, add_file_system_info_ok);
	tcase_add_test(tc_hd_add_file_system_info, add_file_system_info_with_null_device);


	suite_add_tcase(s, tc_hd_format);
	suite_add_tcase(s, tc_hd_get_info);
	suite_add_tcase(s, tc_hd_add_device_main_info);
	suite_add_tcase(s, tc_hd_add_device_size_info);
	suite_add_tcase(s, tc_hd_add_part_info);
	suite_add_tcase(s, tc_hd_add_part_flags);
	suite_add_tcase(s, tc_hd_add_geom_info);
	suite_add_tcase(s, tc_hd_add_df_info);
	suite_add_tcase(s, tc_hd_add_file_system_info);

	return s;
}
Esempio n. 5
0
END_TEST

/* this test is excluded for now, due to lack of a way
 *  to set a friend's status for now.
 *  ideas:
 *      if we have access to the friends list, we could
 *      just add a status manually ourselves. */
/*
START_TEST(test_m_copy_userstatus)
{
    assert(m_copy_userstatus(-1, buf, MAX_USERSTATUS_LENGTH) == -1);
    assert(m_copy_userstatus(REALLY_BIG_NUMBER, buf, MAX_USERSTATUS_LENGTH) == -1);
    m_copy_userstatus(friend_id_num, buf, MAX_USERSTATUS_LENGTH + 6);

    assert(STRINGS_EQUAL(name_buf, friend_id_status));
}
END_TEST
*/

/* this test is excluded for now, due to lack of a way
 *  to set a friend's nickname for now.
 *  ideas:
 *      if we have access to the friends list, we could
 *      just add a name manually ourselves. */
/*
START_TEST(test_getname)
{
    uint8_t name_buf[MAX_NAME_LENGTH];

    assert(getname(-1, name_buf) == -1);
    assert(getname(REALLY_BIG_NUMBER, name_buf) == -1);

    getname(friend_id_num, name_buf);
    assert(name_buf[MAX_NAME_LENGTH] == '\0'); // something like this
}
END_TEST
*/

Suite *messenger_suite(void)
{
    Suite *s = suite_create("Messenger");

    TCase *userstatus_size = tcase_create("userstatus_size");
    TCase *set_userstatus = tcase_create("set_userstatus");
    TCase *send_message = tcase_create("send_message");
    TCase *friendstatus = tcase_create("friendstatus");
    TCase *getself_name = tcase_create("getself_name");
    TCase *delfriend = tcase_create("delfriend");
    TCase *addfriend = tcase_create("addfriend");
    TCase *setname = tcase_create("setname");

    tcase_add_test(userstatus_size, test_m_get_userstatus_size);
    tcase_add_test(set_userstatus, test_m_set_userstatus);
    tcase_add_test(friendstatus, test_m_friendstatus);
    tcase_add_test(getself_name, test_getself_name);
    tcase_add_test(send_message, test_m_sendmesage);
    tcase_add_test(delfriend, test_m_delfriend);
    tcase_add_test(addfriend, test_m_addfriend);
    tcase_add_test(setname, test_setname);

    suite_add_tcase(s, userstatus_size);
    suite_add_tcase(s, set_userstatus);
    suite_add_tcase(s, friendstatus);
    suite_add_tcase(s, send_message);
    suite_add_tcase(s, getself_name);
    suite_add_tcase(s, delfriend);
    suite_add_tcase(s, addfriend);
    suite_add_tcase(s, setname);

    return s;
}
Esempio n. 6
0
Suite *nsurl_suite(void)
{
	Suite *s;
	TCase *tc_api_assert;
	TCase *tc_create;
	TCase *tc_access;
	TCase *tc_nice_nostrip;
	TCase *tc_nice_strip;
	TCase *tc_replace_query;
	TCase *tc_join;
	TCase *tc_compare;
	TCase *tc_fragment;
	TCase *tc_component;
	TCase *tc_parent;

	s = suite_create("nsurl");

	/* Basic API operation assert checks */
	tc_api_assert = tcase_create("API asserts");

	tcase_add_unchecked_fixture(tc_api_assert,
				    corestring_create,
				    corestring_teardown);

	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_create_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_ref_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_unref_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_compare1_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_compare2_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_get_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_get_component1_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_get_component2_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_has_component1_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_has_component2_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_access_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_access_leaf_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_length_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_hash_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_join1_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_join2_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_defragment_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_refragment1_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_refragment2_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_replace_query1_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_replace_query2_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_replace_query3_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_nice_test, 6);
	tcase_add_test_raise_signal(tc_api_assert,
				    nsurl_api_assert_parent_test, 6);

	suite_add_tcase(s, tc_api_assert);

	/* url creation */
	tc_create = tcase_create("Create");

	tcase_add_unchecked_fixture(tc_create,
				    corestring_create,
				    corestring_teardown);

	tcase_add_loop_test(tc_create,
			    nsurl_create_test,
			    0, NELEMS(create_tests));
	tcase_add_test(tc_create, nsurl_ref_test);
	suite_add_tcase(s, tc_create);

	/* url access and length */
	tc_access = tcase_create("Access");

	tcase_add_unchecked_fixture(tc_access,
				    corestring_create,
				    corestring_teardown);
	tcase_add_loop_test(tc_access,
			    nsurl_access_test,
			    0, NELEMS(access_tests));
	tcase_add_loop_test(tc_access,
			    nsurl_access_leaf_test,
			    0, NELEMS(access_tests));
	tcase_add_loop_test(tc_access,
			    nsurl_length_test,
			    0, NELEMS(access_tests));
	suite_add_tcase(s, tc_access);

	/* nice filename without strip */
	tc_nice_nostrip = tcase_create("Nice (nostrip)");

	tcase_add_unchecked_fixture(tc_nice_nostrip,
				    corestring_create,
				    corestring_teardown);

	tcase_add_loop_test(tc_nice_nostrip,
			    nsurl_nice_nostrip_test,
			    0, NELEMS(nice_tests));
	suite_add_tcase(s, tc_nice_nostrip);


	/* nice filename with strip */
	tc_nice_strip = tcase_create("Nice (strip)");

	tcase_add_unchecked_fixture(tc_nice_strip,
				    corestring_create,
				    corestring_teardown);

	tcase_add_loop_test(tc_nice_strip,
			    nsurl_nice_strip_test,
			    0, NELEMS(nice_strip_tests));
	suite_add_tcase(s, tc_nice_strip);


	/* replace query */
	tc_replace_query = tcase_create("Replace Query");

	tcase_add_unchecked_fixture(tc_replace_query,
				    corestring_create,
				    corestring_teardown);

	tcase_add_loop_test(tc_replace_query,
			    nsurl_replace_query_test,
			    0, NELEMS(replace_query_tests));
	suite_add_tcase(s, tc_replace_query);

	/* url join */
	tc_join = tcase_create("Join");

	tcase_add_unchecked_fixture(tc_join,
				    corestring_create,
				    corestring_teardown);

	tcase_add_loop_test(tc_join,
			    nsurl_join_test,
			    0, NELEMS(join_tests));
	tcase_add_loop_test(tc_join,
			    nsurl_join_complex_test,
			    0, NELEMS(join_complex_tests));

	suite_add_tcase(s, tc_join);


	/* url compare */
	tc_compare = tcase_create("Compare");

	tcase_add_unchecked_fixture(tc_compare,
				    corestring_create,
				    corestring_teardown);

	tcase_add_loop_test(tc_compare,
			    nsurl_compare_test,
			    0, NELEMS(compare_tests));

	suite_add_tcase(s, tc_compare);

	/* fragment */
	tc_fragment = tcase_create("Fragment");

	tcase_add_unchecked_fixture(tc_fragment,
				    corestring_create,
				    corestring_teardown);

	tcase_add_loop_test(tc_fragment,
			    nsurl_defragment_test,
			    0, NELEMS(parent_tests));
	tcase_add_loop_test(tc_fragment,
			    nsurl_refragment_test,
			    0, NELEMS(parent_tests));

	suite_add_tcase(s, tc_fragment);


	/* component */
	tc_component = tcase_create("Component");

	tcase_add_unchecked_fixture(tc_component,
				    corestring_create,
				    corestring_teardown);

	tcase_add_loop_test(tc_component,
			    nsurl_get_component_test,
			    0, NELEMS(component_tests));
	tcase_add_loop_test(tc_component,
			    nsurl_has_component_test,
			    0, NELEMS(component_tests));

	suite_add_tcase(s, tc_component);


	/* parent */
	tc_parent = tcase_create("Parent");

	tcase_add_unchecked_fixture(tc_parent,
				    corestring_create,
				    corestring_teardown);

	tcase_add_loop_test(tc_parent,
			    nsurl_parent_test,
			    0, NELEMS(parent_tests));

	suite_add_tcase(s, tc_parent);

	return s;
}
Esempio n. 7
0
int main(void)
{
    setlogmask(LOG_UPTO(LOG_DEBUG));

    Suite *s1 = suite_create("Bloomd");
    TCase *tc1 = tcase_create("config");
    TCase *tc3 = tcase_create("filter");
    TCase *tc4 = tcase_create("filter manager");
    TCase *tc5 = tcase_create("art");
    SRunner *sr = srunner_create(s1);
    int nf;

    // Add the config tests
    suite_add_tcase(s1, tc1);
    tcase_add_test(tc1, test_config_get_default);
    tcase_add_test(tc1, test_config_bad_file);
    tcase_add_test(tc1, test_config_empty_file);
    tcase_add_test(tc1, test_config_basic_config);
    tcase_add_test(tc1, test_validate_default_config);
    tcase_add_test(tc1, test_validate_bad_config);
    tcase_add_test(tc1, test_join_path_no_slash);
    tcase_add_test(tc1, test_join_path_with_slash);
    tcase_add_test(tc1, test_sane_log_level);
    tcase_add_test(tc1, test_sane_init_capacity);
    tcase_add_test(tc1, test_sane_default_probability);
    tcase_add_test(tc1, test_sane_scale_size);
    tcase_add_test(tc1, test_sane_probability_reduction);
    tcase_add_test(tc1, test_sane_flush_interval);
    tcase_add_test(tc1, test_sane_cold_interval);
    tcase_add_test(tc1, test_sane_in_memory);
    tcase_add_test(tc1, test_sane_use_mmap);
    tcase_add_test(tc1, test_sane_worker_threads);
    tcase_add_test(tc1, test_filter_config_bad_file);
    tcase_add_test(tc1, test_filter_config_empty_file);
    tcase_add_test(tc1, test_filter_config_basic_config);
    tcase_add_test(tc1, test_update_filename_from_filter_config);

    // Add the filter tests
    suite_add_tcase(s1, tc3);
    tcase_set_timeout(tc3, 3);
    tcase_add_test(tc3, test_filter_init_destroy);
    tcase_add_test(tc3, test_filter_init_discover_destroy);
    tcase_add_test(tc3, test_filter_init_discover_delete);
    tcase_add_test(tc3, test_filter_init_proxied);
    tcase_add_test(tc3, test_filter_add_check);
    tcase_add_test(tc3, test_filter_restore);
    tcase_add_test(tc3, test_filter_flush);
    tcase_add_test(tc3, test_filter_add_check_in_mem);
    tcase_add_test(tc3, test_filter_grow);
    tcase_add_test(tc3, test_filter_grow_restore);
    tcase_add_test(tc3, test_filter_restore_order);
    tcase_add_test(tc3, test_filter_page_out);
    tcase_add_test(tc3, test_filter_bounded_fp);

    // Add the filter tests
    suite_add_tcase(s1, tc4);
    tcase_set_timeout(tc4, 3);
    tcase_add_test(tc4, test_mgr_init_destroy);
    tcase_add_test(tc4, test_mgr_create_drop);
    tcase_add_test(tc4, test_mgr_create_double_drop);
    tcase_add_test(tc4, test_mgr_list);
    tcase_add_test(tc4, test_mgr_list_prefix);
    tcase_add_test(tc4, test_mgr_list_no_filters);
    tcase_add_test(tc4, test_mgr_add_check_keys);
    tcase_add_test(tc4, test_mgr_check_no_keys);
    tcase_add_test(tc4, test_mgr_add_check_no_filter);
    tcase_add_test(tc4, test_mgr_flush_no_filter);
    tcase_add_test(tc4, test_mgr_flush);
    tcase_add_test(tc4, test_mgr_unmap_no_filter);
    tcase_add_test(tc4, test_mgr_unmap);
    tcase_add_test(tc4, test_mgr_unmap_add_keys);
    tcase_add_test(tc4, test_mgr_clear_no_filter);
    tcase_add_test(tc4, test_mgr_clear_not_proxied);
    tcase_add_test(tc4, test_mgr_clear);
    tcase_add_test(tc4, test_mgr_clear_reload);
    tcase_add_test(tc4, test_mgr_list_cold_no_filters);
    tcase_add_test(tc4, test_mgr_list_cold);
    tcase_add_test(tc4, test_mgr_unmap_in_mem);
    tcase_add_test(tc4, test_mgr_create_custom_config);
    tcase_add_test(tc4, test_mgr_grow);
    tcase_add_test(tc4, test_mgr_restore);
    tcase_add_test(tc4, test_mgr_callback);

    // Add the art tests
    suite_add_tcase(s1, tc5);
    tcase_set_timeout(tc4, 8);
    tcase_add_test(tc5, test_art_init_and_destroy);
    tcase_add_test(tc5, test_art_insert);
    tcase_add_test(tc5, test_art_insert_search);
    tcase_add_test(tc5, test_art_insert_delete);
    tcase_add_test(tc5, test_art_insert_iter);
    tcase_add_test(tc5, test_art_iter_prefix);
    tcase_add_test(tc5, test_art_insert_copy_delete);

    srunner_run_all(sr, CK_ENV);
    nf = srunner_ntests_failed(sr);
    srunner_free(sr);

    return nf == 0 ? 0 : 1;
}
Esempio n. 8
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/message/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 "extend" */
  tcase = tcase_create("extend");
  tcase_add_test(tcase, test_extend);
  tcase_add_checked_fixture(tcase, setup, teardown);
  suite_add_tcase(suite, tcase);

  /* Add tests to test case "field-by-tag" */
  tcase = tcase_create("field-by-tag");
  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);
  tcase_add_checked_fixture(tcase, setup, teardown);
  suite_add_tcase(suite, tcase);

  /* Add tests to test case "field-by-name" */
  tcase = tcase_create("field-by-name");
  tcase_add_test(tcase, test_field_by_name);
  tcase_add_test(tcase, test_field_by_name_absent);
  tcase_add_test(tcase, test_field_by_name_empty);
  tcase_add_test(tcase, test_field_by_name_scattered);
  tcase_add_test(tcase, test_field_by_name_scattered_absent);
  tcase_add_test(tcase, test_field_by_name_extended);
  tcase_add_checked_fixture(tcase, setup, teardown);
  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;
}
Esempio n. 9
0
END_TEST

static Suite *
make_suite(void)
{
    Suite *s = suite_create("basic");
    TCase *tc_basic = tcase_create("basic tests");
    TCase *tc_namespace = tcase_create("XML namespaces");

    suite_add_tcase(s, tc_basic);
    tcase_add_checked_fixture(tc_basic, basic_setup, basic_teardown);
    tcase_add_test(tc_basic, test_nul_byte);
    tcase_add_test(tc_basic, test_u0000_char);
    tcase_add_test(tc_basic, test_bom_utf8);
    tcase_add_test(tc_basic, test_bom_utf16_be);
    tcase_add_test(tc_basic, test_bom_utf16_le);
    tcase_add_test(tc_basic, test_illegal_utf8);
    tcase_add_test(tc_basic, test_utf16);
    tcase_add_test(tc_basic, test_utf16_le_epilog_newline);
    tcase_add_test(tc_basic, test_latin1_umlauts);
    /* Regression test for SF bug #491986. */
    tcase_add_test(tc_basic, test_danish_latin1);
    /* Regression test for SF bug #514281. */
    tcase_add_test(tc_basic, test_french_charref_hexidecimal);
    tcase_add_test(tc_basic, test_french_charref_decimal);
    tcase_add_test(tc_basic, test_french_latin1);
    tcase_add_test(tc_basic, test_french_utf8);
    tcase_add_test(tc_basic, test_utf8_false_rejection);
    tcase_add_test(tc_basic, test_line_number_after_parse);
    tcase_add_test(tc_basic, test_column_number_after_parse);
    tcase_add_test(tc_basic, test_line_and_column_numbers_inside_handlers);
    tcase_add_test(tc_basic, test_line_number_after_error);
    tcase_add_test(tc_basic, test_column_number_after_error);
    tcase_add_test(tc_basic, test_really_long_lines);
    tcase_add_test(tc_basic, test_end_element_events);
    tcase_add_test(tc_basic, test_attr_whitespace_normalization);
    tcase_add_test(tc_basic, test_xmldecl_misplaced);
    tcase_add_test(tc_basic, test_unknown_encoding_internal_entity);
    tcase_add_test(tc_basic,
                   test_wfc_undeclared_entity_unread_external_subset);
    tcase_add_test(tc_basic, test_wfc_undeclared_entity_no_external_subset);
    tcase_add_test(tc_basic, test_wfc_undeclared_entity_standalone);
    tcase_add_test(tc_basic, test_wfc_undeclared_entity_with_external_subset);
    tcase_add_test(tc_basic,
                   test_wfc_undeclared_entity_with_external_subset_standalone);
    tcase_add_test(tc_basic, test_wfc_no_recursive_entity_refs);
    tcase_add_test(tc_basic, test_ext_entity_set_encoding);
    tcase_add_test(tc_basic, test_dtd_default_handling);
    tcase_add_test(tc_basic, test_empty_ns_without_namespaces);
    tcase_add_test(tc_basic, test_ns_in_attribute_default_without_namespaces);

    suite_add_tcase(s, tc_namespace);
    tcase_add_checked_fixture(tc_namespace,
                              namespace_setup, namespace_teardown);
    tcase_add_test(tc_namespace, test_return_ns_triplet);
    tcase_add_test(tc_namespace, test_ns_tagname_overwrite);
    tcase_add_test(tc_namespace, test_ns_tagname_overwrite_triplet);
    tcase_add_test(tc_namespace, test_start_ns_clears_start_element);
    tcase_add_test(tc_namespace, test_default_ns_from_ext_subset_and_ext_ge);
    tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_1);
    tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_2);
    tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_3);
    tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_4);
    tcase_add_test(tc_namespace, test_ns_default_with_empty_uri);
    tcase_add_test(tc_namespace, test_ns_duplicate_attrs_diff_prefixes);
    tcase_add_test(tc_namespace, test_ns_unbound_prefix_on_attribute);
    tcase_add_test(tc_namespace, test_ns_unbound_prefix_on_element);

    return s;
}
Esempio n. 10
0
END_TEST

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

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

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

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

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

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

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

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

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

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

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

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

  tc_core = tcase_create("set_resc_deflt_test");
  tcase_add_test(tc_core, set_resc_deflt_test);
  tcase_add_test(tc_core, test_numa_task_exceeds_resources);
  suite_add_tcase(s, tc_core);

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

  tc_core = tcase_create("set_statechar_test");
  tcase_add_test(tc_core, set_statechar_test);
  tcase_add_test(tc_core, is_valid_state_transition_test);
  tcase_add_test(tc_core, has_conflicting_resource_requeusts_test);
  suite_add_tcase(s, tc_core);

  tc_core = tcase_create("lock_ji_mutex_test");
  tcase_add_test(tc_core, lock_ji_mutex_test);
  tcase_add_test(tc_core, chk_mppnodect_test);
  tcase_add_test(tc_core, job_wait_over_test);
  suite_add_tcase(s, tc_core);

  return s;
  }
END_TEST


Suite *
create_suite_ArrayInfixWriting ()
{
  Suite *suite = suite_create("ArrayInfixWriting");
  TCase *tcase = tcase_create("ArrayInfixWriting");

  tcase_add_test( tcase, test_parse_brackets_0args);
  tcase_add_test( tcase, test_parse_brackets_1args);
  tcase_add_test( tcase, test_parse_brackets_2args);
  tcase_add_test( tcase, test_parse_function_selector_0args);
  tcase_add_test( tcase, test_parse_function_selector_1args);
  tcase_add_test( tcase, test_parse_function_selector_2args);
  tcase_add_test( tcase, test_parse_function_selector_3args);
  tcase_add_test( tcase, test_parse_function_selector_needParens);
  tcase_add_test( tcase, test_parse_function_selector_needNoParens1);
  tcase_add_test( tcase, test_parse_function_selector_needNoParens2);
#if (0)
  tcase_add_test( tcase, test_parse_function_selector_needNoParens3);
#endif

  tcase_add_test( tcase, test_parse_curlybraces_0args);
  tcase_add_test( tcase, test_parse_curlybraces_1args);
  tcase_add_test( tcase, test_parse_curlybraces_2args);
  tcase_add_test( tcase, test_parse_curlybraces_nested);
#if (0)
  tcase_add_test( tcase, test_parse_curlybraces_semicolons);
  tcase_add_test( tcase, test_parse_curlybraces_semicolons_short);
#endif

#if (0)
  tcase_add_test( tcase, test_parse_function_determinant);
  tcase_add_test( tcase, test_parse_function_det);
  tcase_add_test( tcase, test_parse_function_transpose);
  tcase_add_test( tcase, test_parse_function_trans);
  tcase_add_test( tcase, test_parse_function_vectorproduct);
  tcase_add_test( tcase, test_parse_function_vectorprod);
  tcase_add_test( tcase, test_parse_function_cross);
  tcase_add_test( tcase, test_parse_function_scalarproduct);
  tcase_add_test( tcase, test_parse_function_scalarprod);
  tcase_add_test( tcase, test_parse_function_dot);
  tcase_add_test( tcase, test_parse_function_outerproduct);
  tcase_add_test( tcase, test_parse_function_outerprod);
  tcase_add_test( tcase, test_parse_function_outer);
#endif

  tcase_add_test( tcase, test_parse_function_vector_0args);
  tcase_add_test( tcase, test_parse_function_vector_1args);
  tcase_add_test( tcase, test_parse_function_vector_2args);

#if (0)
  tcase_add_test( tcase, test_parse_function_matrix_empty);
  tcase_add_test( tcase, test_parse_function_matrix_1row);
  tcase_add_test( tcase, test_parse_function_matrix_2rows);
  tcase_add_test( tcase, test_parse_function_matrix_emptyrows);
#endif

  tcase_add_test( tcase, test_parse_function_sum);

  suite_add_tcase(suite, tcase);

  return suite;
}
Esempio n. 12
0
END_TEST


Suite *
goal_suite(void)
{
    Suite *s = suite_create("Goal");
    TCase *tc;

    tc = tcase_create("Core");
    tcase_add_unchecked_fixture(tc, fixture_all, teardown);
    tcase_add_test(tc, test_goal_actions);
    tcase_add_test(tc, test_goal_sanity);
    tcase_add_test(tc, test_goal_update_impossible);
    tcase_add_test(tc, test_goal_list_err);
    tcase_add_test(tc, test_goal_install);
    tcase_add_test(tc, test_goal_install_multilib);
    tcase_add_test(tc, test_goal_install_selector);
    tcase_add_test(tc, test_goal_install_selector_err);
    tcase_add_test(tc, test_goal_install_selector_two);
    tcase_add_test(tc, test_goal_install_selector_nomatch);
    tcase_add_test(tc, test_goal_install_optional);
    tcase_add_test(tc, test_goal_selector_glob);
    tcase_add_test(tc, test_goal_selector_provides_glob);
    tcase_add_test(tc, test_goal_selector_upgrade);
    tcase_add_test(tc, test_goal_selector_upgrade_provides);
    tcase_add_test(tc, test_goal_upgrade);
    tcase_add_test(tc, test_goal_upgrade_all);
    tcase_add_test(tc, test_goal_downgrade);
    tcase_add_test(tc, test_goal_get_reason);
    tcase_add_test(tc, test_goal_get_reason_selector);
    tcase_add_test(tc, test_goal_describe_problem);
    tcase_add_test(tc, test_goal_describe_problem_rules);
    tcase_add_test(tc, test_goal_distupgrade_all_keep_arch);
    tcase_add_test(tc, test_goal_no_reinstall);
    tcase_add_test(tc, test_goal_erase_simple);
    tcase_add_test(tc, test_goal_erase_with_deps);
    tcase_add_test(tc, test_goal_protected);
    tcase_add_test(tc, test_goal_erase_clean_deps);
    tcase_add_test(tc, test_goal_forcebest);
    tcase_add_test(tc, test_goal_get_solution);
    suite_add_tcase(s, tc);

    tc = tcase_create("ModifiesSackState");
    tcase_add_unchecked_fixture(tc, fixture_all, teardown);
    tcase_add_checked_fixture(tc, fixture_reset, NULL);
    tcase_add_test(tc, test_goal_installonly);
    tcase_add_test(tc, test_goal_installonly_upgrade_all);
    tcase_add_test(tc, test_goal_upgrade_all_excludes);
    tcase_add_test(tc, test_goal_upgrade_disabled_repo);
    tcase_add_test(tc, test_goal_describe_problem_excludes);
    suite_add_tcase(s, tc);

    tc = tcase_create("Main");
    tcase_add_unchecked_fixture(tc, fixture_with_main, teardown);
    tcase_add_test(tc, test_goal_distupgrade_all);
    tcase_add_test(tc, test_goal_distupgrade_selector_upgrade);
    tcase_add_test(tc, test_goal_distupgrade_selector_downgrade);
    tcase_add_test(tc, test_goal_distupgrade_selector_nothing);
    tcase_add_test(tc, test_goal_install_selector_file);
    tcase_add_test(tc, test_goal_rerun);
    tcase_add_test(tc, test_goal_unneeded);
    tcase_add_test(tc, test_goal_distupgrade_all_excludes);
    suite_add_tcase(s, tc);

    tc = tcase_create("Greedy");
    tcase_add_unchecked_fixture(tc, fixture_greedy_only, teardown);
    tcase_add_test(tc, test_goal_run_all);
    tcase_add_test(tc, test_goal_install_selector_obsoletes_first);
    tcase_add_test(tc, test_goal_install_weak_deps);
    suite_add_tcase(s, tc);

    tc = tcase_create("Installonly");
    tcase_add_unchecked_fixture(tc, fixture_installonly, teardown);
    tcase_add_checked_fixture(tc, fixture_reset, NULL);
    tcase_add_test(tc, test_goal_installonly_limit);
    tcase_add_test(tc, test_goal_installonly_limit_disabled);
    tcase_add_test(tc, test_goal_installonly_limit_running_kernel);
    tcase_add_test(tc, test_goal_installonly_limit_with_modules);
    tcase_add_test(tc, test_goal_kernel_protected);
    suite_add_tcase(s, tc);

    tc = tcase_create("Vendor");
    tcase_add_unchecked_fixture(tc, fixture_with_vendor, teardown);
    tcase_add_test(tc, test_goal_update_vendor);
    suite_add_tcase(s, tc);

    tc = tcase_create("Forcebest");
    tcase_add_unchecked_fixture(tc, fixture_with_forcebest, teardown);
    tcase_add_test(tc, test_goal_forcebest_arches);
    suite_add_tcase(s, tc);

    tc = tcase_create("Change");
    tcase_add_unchecked_fixture(tc, fixture_with_change, teardown);
    tcase_add_test(tc, test_goal_change);
    tcase_add_test(tc, test_goal_clone);
    suite_add_tcase(s, tc);

    tc = tcase_create("Cmdline");
    tcase_add_unchecked_fixture(tc, fixture_with_cmdline, teardown);
    tcase_add_test(tc, test_cmdline_file_provides);
    suite_add_tcase(s, tc);

    tc = tcase_create("Verify");
    tcase_add_unchecked_fixture(tc, fixture_verify, teardown);
    tcase_add_test(tc, test_goal_verify);
    suite_add_tcase(s, tc);

    return s;
}
Suite *mod_auth_cas_suite(void) {
  Suite *s = suite_create("mod_auth_cas");

  TCase *tc_core = tcase_create("core");
  tcase_add_checked_fixture(tc_core, core_setup, core_teardown);
  tcase_add_test(tc_core, escapeString_test);
  tcase_add_test(tc_core, isSSL_test);
  tcase_add_test(tc_core, cas_char_to_env_test);
  tcase_add_test(tc_core, cas_scrub_headers_test);
  tcase_add_test(tc_core, cas_strnenvcmp_test);
  tcase_add_test(tc_core, normalizeHeaderName_test);
  tcase_add_test(tc_core, cas_merge_server_config_test);
  tcase_add_test(tc_core, cas_merge_dir_config_test);
  tcase_add_test(tc_core, cas_setURL_test);
  tcase_add_test(tc_core, getCASPath_test);
  tcase_add_test(tc_core, getCASScope_test);
  tcase_add_test(tc_core, getCASGatewayV1_test);
  tcase_add_test(tc_core, getCASGatewayV2_test);
  tcase_add_test(tc_core, getCASRenew_test);
  tcase_add_test(tc_core, getCASLoginURL_test);
  tcase_add_test(tc_core, getCASService_http_test);
  tcase_add_test(tc_core, getCASService_https_test);
  tcase_add_test(tc_core, getCASService_http_port_test);
  tcase_add_test(tc_core, getCASService_https_port_test);
  tcase_add_test(tc_core, getCASService_root_proxied_test);
  tcase_add_test(tc_core, getCASService_empty_qs_test);
  tcase_add_test(tc_core, redirectRequest_test);
  tcase_add_test(tc_core, removeCASParams_test);
  tcase_add_test(tc_core, validCASTicketFormat_test);
  tcase_add_test(tc_core, getCASTicket_test);
  tcase_add_test(tc_core, getCASCookie_test);
  tcase_add_test(tc_core, setCASCookie_test);
  tcase_add_test(tc_core, setCASCookieExpiryNow_test);
  tcase_add_test(tc_core, setCASCookieExpiryFiveSeconds_test);
  tcase_add_test(tc_core, removeGatewayCookie_test);
  tcase_add_test(tc_core, urlEncode_test);
  tcase_add_test(tc_core, readCASCacheFile_test);
  tcase_add_test(tc_core, CASCleanCache_test);
  tcase_add_test(tc_core, writeCASCacheEntry_test);
  tcase_add_test(tc_core, createCASCookie_test);
  tcase_add_test(tc_core, expireCASST_test);
  tcase_add_test(tc_core, CASSAMLLogout_test);
  tcase_add_test(tc_core, deleteCASCacheFile_test);
  tcase_add_test(tc_core, getResponseFromServer_test);
  tcase_add_test(tc_core, isValidCASTicket_OpenSAML1_test);
  tcase_add_test(tc_core, isValidCASTicket_OpenSAML2_test);
  tcase_add_test(tc_core, isValidCASCookie_test);
  tcase_add_test(tc_core, cas_curl_write_test);
  tcase_add_test(tc_core, cas_curl_ssl_ctx_test);
  tcase_add_test(tc_core, cas_authenticate_test);
  tcase_add_test(tc_core, cas_ssl_locking_callback_test);
  tcase_add_test(tc_core, cas_ssl_id_callback_test);
  tcase_add_test(tc_core, cas_cleanup_test);
  tcase_add_test(tc_core, check_vhost_config_test);
  tcase_add_test(tc_core, check_merged_vhost_configs_test);
  tcase_add_test(tc_core, merged_vhost_configs_exist_test);
  tcase_add_test(tc_core, cas_post_config_test);
  tcase_add_test(tc_core, cas_in_filter_test);
  tcase_add_test(tc_core, cas_register_hooks_test);
  tcase_add_test(tc_core, cas_attribute_authz_test);
  suite_add_tcase(s, tc_core);
  suite_add_tcase(s, cas_saml_attr_tcase());

  return s;
}
END_TEST
START_TEST(tc_pico_sntp_sync_ip)
{
    union pico_address sntp_addr = { .ip4.addr = 0ul };

    fail_if(pico_sntp_sync_ip(NULL, cb_synced) == 0);
    fail_if(pico_err != PICO_ERR_EINVAL);

    fail_if(pico_sntp_sync_ip(&sntp_addr, NULL) == 0);
    fail_if(pico_err != PICO_ERR_EINVAL);

    fail_if(pico_sntp_sync_ip(&sntp_addr, cb_synced) != 0);
}
END_TEST
START_TEST(tc_pico_sntp_sync_start)
{
    struct sntp_server_ns_cookie ck = { 0 };
    union pico_address sntp_addr = { .ip4.addr= 0ul };

    fail_if(pico_sntp_sync_start(&ck, &sntp_addr) != 0);
}
END_TEST
START_TEST(tc_pico_sntp_sync_start_dns_ipv4)
{
    const char *sntp_server = "ntp.nasa.gov";

    fail_if(pico_sntp_sync_start_dns_ipv4(sntp_server, cb_synced) != 0);
}
END_TEST
START_TEST(tc_pico_sntp_sync_start_dns_ipv6)
{
    const char *sntp_server = "ntp.nasa.gov";

    fail_if(pico_sntp_sync_start_dns_ipv6(sntp_server, cb_synced) != 0);
}
END_TEST
START_TEST(tc_pico_sntp_sync_start_ipv4)
{
    union pico_address sntp_addr = { .ip4.addr = 0};

    fail_if(pico_sntp_sync_start_ipv4(&sntp_addr, cb_synced) != 0);
}
END_TEST
START_TEST(tc_pico_sntp_sync_start_ipv6)
{
    union pico_address sntp_addr = { .ip6.addr = { 0 } };

    fail_if(pico_sntp_sync_start_ipv6(&sntp_addr, cb_synced) != 0);
}
END_TEST

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

    TCase *TCase_timestamp_convert = tcase_create("Unit test for pico_timeval");
    TCase *TCase_pico_sntp_cleanup = tcase_create("Unit test for pico_sntp_cleanup");
    TCase *TCase_pico_sntp_send = tcase_create("Unit test for pico_sntp_send");
    TCase *TCase_pico_sntp_parse = tcase_create("Unit test for pico_sntp_parse");
    TCase *TCase_pico_sntp_client_wakeup = tcase_create("Unit test for pico_sntp_client_wakeup");
    TCase *TCase_sntp_receive_timeout = tcase_create("Unit test for sntp_receive_timeout");
    TCase *TCase_dnsCallback = tcase_create("Unit test for dnsCallback");
    TCase *TCase_pico_sntp_sync = tcase_create("Unit test for pico_sntp_sync");
    TCase *TCase_pico_sntp_sync_ip = tcase_create("Unit test for pico_sntp_sync_ip");
    TCase *TCase_pico_sntp_sync_start = tcase_create("Unit test for pico_sntp_sync_start");
    TCase *TCase_pico_sntp_sync_start_dns_ipv4 = tcase_create("Unit test for pico_sntp_sync_start_dns_ipv4");
    TCase *TCase_pico_sntp_sync_start_dns_ipv6 = tcase_create("Unit test for pico_sntp_sync_start_dns_ipv6");
    TCase *TCase_pico_sntp_sync_start_ipv4 = tcase_create("Unit test for pico_sntp_sync_start_ipv4");
    TCase *TCase_pico_sntp_sync_start_ipv6 = tcase_create("Unit test for pico_sntp_sync_start_ipv6");


    tcase_add_test(TCase_timestamp_convert, tc_timestamp_convert);
    suite_add_tcase(s, TCase_timestamp_convert);
    tcase_add_test(TCase_pico_sntp_cleanup, tc_pico_sntp_cleanup);
    suite_add_tcase(s, TCase_pico_sntp_cleanup);
    tcase_add_test(TCase_pico_sntp_parse, tc_pico_sntp_parse);
    suite_add_tcase(s, TCase_pico_sntp_parse);
    tcase_add_test(TCase_pico_sntp_client_wakeup, tc_pico_sntp_client_wakeup);
    suite_add_tcase(s, TCase_pico_sntp_client_wakeup);
    tcase_add_test(TCase_sntp_receive_timeout, tc_sntp_receive_timeout);
    suite_add_tcase(s, TCase_sntp_receive_timeout);
    tcase_add_test(TCase_pico_sntp_send, tc_pico_sntp_send);
    suite_add_tcase(s, TCase_pico_sntp_send);
    tcase_add_test(TCase_dnsCallback, tc_dnsCallback);
    suite_add_tcase(s, TCase_dnsCallback);
    tcase_add_test(TCase_pico_sntp_sync, tc_pico_sntp_sync);
    suite_add_tcase(s, TCase_pico_sntp_sync);
    tcase_add_test(TCase_pico_sntp_sync_ip, tc_pico_sntp_sync_ip);
    suite_add_tcase(s, TCase_pico_sntp_sync_ip);
    tcase_add_test(TCase_pico_sntp_sync_start, tc_pico_sntp_sync_start);
    suite_add_tcase(s, TCase_pico_sntp_sync_start);
    tcase_add_test(TCase_pico_sntp_sync_start_dns_ipv4, tc_pico_sntp_sync_start_dns_ipv4);
    suite_add_tcase(s, TCase_pico_sntp_sync_start_dns_ipv4);
    tcase_add_test(TCase_pico_sntp_sync_start_dns_ipv6, tc_pico_sntp_sync_start_dns_ipv6);
    suite_add_tcase(s, TCase_pico_sntp_sync_start_dns_ipv6);
    tcase_add_test(TCase_pico_sntp_sync_start_ipv4, tc_pico_sntp_sync_start_ipv4);
    suite_add_tcase(s, TCase_pico_sntp_sync_start_ipv4);
    tcase_add_test(TCase_pico_sntp_sync_start_ipv6, tc_pico_sntp_sync_start_ipv6);
    suite_add_tcase(s, TCase_pico_sntp_sync_start_ipv6);
    return s;
}

int main(void)
{
    int fails;
    Suite *s = pico_suite();
    SRunner *sr = srunner_create(s);
    srunner_run_all(sr, CK_NORMAL);
    fails = srunner_ntests_failed(sr);
    srunner_free(sr);
    return fails;
}
Esempio n. 15
0
int
main (void)
{
    /* get the vm name to test against */
    //TODO allow a list of names in this variable
    testvm = getenv("LIBVMI_CHECK_TESTVM");
    if (NULL == testvm) {
        printf("!! Check requires VM name to test against.\n");
        printf("!! Store name in env variable 'LIBVMI_CHECK_TESTVM'.\n");
        return 1;
    }

    /* setup the test suite */
    int number_failed = 0;
    Suite *s = suite_create("LibVMI");

    /* add test cases */
    suite_add_tcase(s, init_tcase());
    suite_add_tcase(s, translate_tcase());
    suite_add_tcase(s, read_tcase());
    suite_add_tcase(s, write_tcase());
    suite_add_tcase(s, print_tcase());
    suite_add_tcase(s, accessor_tcase());
    suite_add_tcase(s, util_tcase());
    suite_add_tcase(s, peparse_tcase());
    suite_add_tcase(s, cache_tcase());
    suite_add_tcase(s, get_va_pages_tcase());

#if ENABLE_SHM_SNAPSHOT == 1
    suite_add_tcase(s, shm_snapshot_tcase());
#endif

    /* run the tests */
    SRunner *sr = srunner_create(s);
    srunner_run_all(sr, CK_VERBOSE);
    number_failed = srunner_ntests_failed(sr);
    srunner_free(sr);
    if (number_failed == 0) {
        return EXIT_SUCCESS;
    } else {
        return EXIT_FAILURE;
    }
}
Esempio n. 16
0
END_TEST

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

	s = suite_create("asn1");

	tc = tcase_create("algorithmIdentifier");
	tcase_add_test(tc, test_asn1_algorithmIdentifier);
	suite_add_tcase(s, tc);

	tc = tcase_create("parse_algorithmIdentifier");
	tcase_add_test(tc, test_asn1_parse_algorithmIdentifier);
	suite_add_tcase(s, tc);

	tc = tcase_create("known_oid");
	tcase_add_test(tc, test_asn1_known_oid);
	suite_add_tcase(s, tc);

	tc = tcase_create("build_known_oid");
	tcase_add_test(tc, test_asn1_build_known_oid);
	suite_add_tcase(s, tc);

	tc = tcase_create("oid_from_string");
	tcase_add_test(tc, test_asn1_oid_from_string);
	suite_add_tcase(s, tc);

	tc = tcase_create("oid_to_string");
	tcase_add_test(tc, test_asn1_oid_to_string);
	suite_add_tcase(s, tc);

	tc = tcase_create("length");
	tcase_add_test(tc, test_asn1_length);
	suite_add_tcase(s, tc);

	tc = tcase_create("unwrap");
	tcase_add_test(tc, test_asn1_unwrap);
	suite_add_tcase(s, tc);

	tc = tcase_create("is_asn1");
	tcase_add_test(tc, test_is_asn1);
	suite_add_tcase(s, tc);

	tc = tcase_create("is_printablestring");
	tcase_add_test(tc, test_asn1_is_printablestring);
	suite_add_tcase(s, tc);

	tc = tcase_create("to_time");
	tcase_add_test(tc, test_asn1_to_time);
	suite_add_tcase(s, tc);

	tc = tcase_create("from_time");
	tcase_add_test(tc, test_asn1_from_time);
	suite_add_tcase(s, tc);

	tc = tcase_create("parse_time");
	tcase_add_test(tc, test_asn1_parse_time);
	suite_add_tcase(s, tc);

	tc = tcase_create("build_object");
	tcase_add_test(tc, test_asn1_build_object);
	suite_add_tcase(s, tc);

	tc = tcase_create("simple_object");
	tcase_add_test(tc, test_asn1_simple_object);
	suite_add_tcase(s, tc);

	tc = tcase_create("parse_simple_object");
	tcase_add_test(tc, test_asn1_parse_simple_object);
	suite_add_tcase(s, tc);

	tc = tcase_create("bitstring");
	tcase_add_test(tc, test_asn1_bitstring);
	suite_add_tcase(s, tc);

	tc = tcase_create("integer");
	tcase_add_test(tc, test_asn1_integer);
	suite_add_tcase(s, tc);

	tc = tcase_create("parse_integer_uint64");
	tcase_add_test(tc, test_asn1_parse_integer_uint64);
	suite_add_tcase(s, tc);

	return s;
}
Esempio n. 17
0
END_TEST

/**
 * @brief Create the secsolve test suite
 */
Suite * secsolve_suite (int standard)
{
  Suite *s = suite_create ("secsolve");

  /* Create a test case for the standard MPSolve case and
   * one for the Gemignani's approach. */
  TCase *tc_secular = tcase_create ("Secular equation");

  /* Case of a_i = (-1)^(i+1) , b_i = i */
  tcase_add_test (tc_secular, test_secsolve_altern);
  tcase_add_test (tc_secular, test_secsolve_altern_ga);

  /* Integer parsing */
  tcase_add_test (tc_secular, test_secsolve_integer);

  /* Simple secular equation with cancellation problems */
  tcase_add_test (tc_secular, test_secsolve_simple);

  /* Wilkinson polynomials */
  tcase_add_test (tc_secular, test_secsolve_wilkinson);

  /* MONOMIAL TEST CASE */
  TCase *tc_monomial = tcase_create ("Monomial input");

  /* Roots of the unity */
  tcase_add_test (tc_monomial, test_secsolve_nroots);

  /* Kam polynomials */
  tcase_add_test (tc_monomial, test_secsolve_kam1_1);
  tcase_add_test (tc_monomial, test_secsolve_kam1_2);
  tcase_add_test (tc_monomial, test_secsolve_kam1_3);
  tcase_add_test (tc_monomial, test_secsolve_kam2_1);
  tcase_add_test (tc_monomial, test_secsolve_kam2_2);
  tcase_add_test (tc_monomial, test_secsolve_kam2_3);
  tcase_add_test (tc_monomial, test_secsolve_kam3_1);
  tcase_add_test (tc_monomial, test_secsolve_kam3_2);
  tcase_add_test (tc_monomial, test_secsolve_kam3_3);

  /* Exponentials */
  tcase_add_test (tc_monomial, test_secsolve_exp);

  /* Mandelbrot polynomials */
  tcase_add_test (tc_monomial, test_secsolve_mand);

  /* Chebyshev */
  tcase_add_test (tc_monomial, test_secsolve_mignotte);

  /* Wilkinson polynomials */
  tcase_add_test (tc_monomial, test_secsolve_wilkinson_monomial);

  /* Mult* polynomials */
  tcase_add_test (tc_monomial, test_secsolve_mult);
  tcase_add_test (tc_monomial, test_secsolve_mult_high_precision);

  /* Topelitz */
  tcase_add_test (tc_monomial, test_secsolve_toep);

  /* Traverso, polynomial generated by resolution of a polynomial
   * system using Groebner elimination. */
  tcase_add_test (tc_monomial, test_secsolve_trv);

  /* Kirinnis polynomials */
  tcase_add_test (tc_monomial, test_secsolve_kir1_10);
  tcase_add_test (tc_monomial, test_secsolve_kir1_10_hp);
  tcase_add_test (tc_monomial, test_secsolve_kir1_20);
  tcase_add_test (tc_monomial, test_secsolve_kir1_40);

  /* Spiral polynomials */
  tcase_add_test (tc_monomial, test_secsolve_spiral10);
  tcase_add_test (tc_monomial, test_secsolve_spiral20);
  tcase_add_test (tc_monomial, test_secsolve_spiral10_high_precision);

  /* Mig polynomial with high precision */
  tcase_add_test (tc_monomial, test_secsolve_mig1_200_high_precision);
  tcase_add_test (tc_monomial, test_secsolve_mig1_500_1);

  /* Add test case to the suite */
  suite_add_tcase (s, tc_secular);
  suite_add_tcase (s, tc_monomial);

  return s;
}
Esempio n. 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/binary/stream"),
       *tcase = NULL;

  /* Add tests to test case "create" */
  tcase = tcase_create("create");
  tcase_add_test(tcase, test_create);
  tcase_add_test(tcase, test_create_at);
  suite_add_tcase(suite, tcase);

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

  /* Add tests to test case "skip" */
  tcase = tcase_create("skip");
  tcase_add_test(tcase, test_skip);
  tcase_add_test(tcase, test_skip_underrun);
  tcase_add_test(tcase, test_skip_fixed32);
  tcase_add_test(tcase, test_skip_fixed64);
  tcase_add_test(tcase, test_skip_varint);
  tcase_add_test(tcase, test_skip_varint_underrun);
  tcase_add_test(tcase, test_skip_length);
  tcase_add_test(tcase, test_skip_length_zero);
  tcase_add_test(tcase, test_skip_length_underrun);
  tcase_add_test(tcase, test_skip_length_prefix_underrun);
  suite_add_tcase(suite, tcase);

  /* Add tests to test case "read" */
  tcase = tcase_create("read");
  tcase_add_test(tcase, test_read);
  tcase_add_test(tcase, test_read_underrun);
  tcase_add_test(tcase, test_read_fixed32);
  tcase_add_test(tcase, test_read_fixed32_underrun);
  tcase_add_test(tcase, test_read_fixed64);
  tcase_add_test(tcase, test_read_fixed64_underrun);
  tcase_add_test(tcase, test_read_varint8);
  tcase_add_test(tcase, test_read_varint8_underrun);
  tcase_add_test(tcase, test_read_varint8_overflow);
  tcase_add_test(tcase, test_read_varint32);
  tcase_add_test(tcase, test_read_varint32_underrun);
  tcase_add_test(tcase, test_read_varint32_overflow);
  tcase_add_test(tcase, test_read_varint64);
  tcase_add_test(tcase, test_read_varint64_underrun);
  tcase_add_test(tcase, test_read_varint64_overflow);
  tcase_add_test(tcase, test_read_svarint32);
  tcase_add_test(tcase, test_read_svarint32_underrun);
  tcase_add_test(tcase, test_read_svarint32_overflow);
  tcase_add_test(tcase, test_read_svarint64);
  tcase_add_test(tcase, test_read_svarint64_underrun);
  tcase_add_test(tcase, test_read_svarint64_overflow);
  tcase_add_test(tcase, test_read_length);
  tcase_add_test(tcase, test_read_length_zero);
  tcase_add_test(tcase, test_read_length_underrun);
  tcase_add_test(tcase, test_read_length_prefix_underrun);
  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;
}
Esempio n. 19
0
END_TEST

Suite *
query_suite(void)
{
    Suite *s = suite_create("Query");
    TCase *tc;

    tc = tcase_create("Core");
    tcase_add_unchecked_fixture(tc, fixture_system_only, teardown);
    tcase_add_test(tc, test_query_sanity);
    tcase_add_test(tc, test_query_run_set_sanity);
    tcase_add_test(tc, test_query_clear);
    tcase_add_test(tc, test_query_clone);
    tcase_add_test(tc, test_query_empty);
    tcase_add_test(tc, test_query_repo);
    tcase_add_test(tc, test_query_name);
    tcase_add_test(tc, test_query_evr);
    tcase_add_test(tc, test_query_epoch);
    tcase_add_test(tc, test_query_version);
    tcase_add_test(tc, test_query_release);
    tcase_add_test(tc, test_query_glob);
    tcase_add_test(tc, test_query_case);
    tcase_add_test(tc, test_query_anded);
    tcase_add_test(tc, test_query_neq);
    tcase_add_test(tc, test_query_in);
    tcase_add_test(tc, test_query_pkg);
    tcase_add_test(tc, test_query_provides);
    tcase_add_test(tc, test_query_fileprovides);
    tcase_add_test(tc, test_query_nevra);
    tcase_add_test(tc, test_query_nevra_glob);
    tcase_add_test(tc, test_query_multiple_flags);
    tcase_add_test(tc, test_query_apply);
    suite_add_tcase(s, tc);

    tc = tcase_create("Updates");
    tcase_add_unchecked_fixture(tc, fixture_with_updates, teardown);
    tcase_add_test(tc, test_upgrades_sanity);
    tcase_add_test(tc, test_upgrades);
    tcase_add_test(tc, test_upgradable);
    tcase_add_test(tc, test_filter_latest);
    tcase_add_test(tc, test_query_provides_in);
    tcase_add_test(tc, test_query_provides_in_not_found);
    suite_add_tcase(s, tc);

    tc = tcase_create("Main");
    tcase_add_unchecked_fixture(tc, fixture_with_main, teardown);
    tcase_add_test(tc, test_upgrade_already_installed);
    tcase_add_test(tc, test_downgrade);
    tcase_add_test(tc, test_downgradable);
    tcase_add_test(tc, test_query_provides_str);
    tcase_add_test(tc, test_query_recommends);
    tcase_add_test(tc, test_query_suggests);
    tcase_add_test(tc, test_query_supplements);
    tcase_add_test(tc, test_query_enhances);
    tcase_add_test(tc, test_query_reldep);
    tcase_add_test(tc, test_query_reldep_arbitrary);
    tcase_add_test(tc, test_query_requires);
    tcase_add_test(tc, test_query_conflicts);
    suite_add_tcase(s, tc);

    tc = tcase_create("Full");
    tcase_add_unchecked_fixture(tc, fixture_all, teardown);
    tcase_add_test(tc, test_filter_latest2);
    tcase_add_test(tc, test_filter_latest_archs);
    tcase_add_test(tc, test_filter_obsoletes);
    tcase_add_test(tc, test_filter_reponames);
    suite_add_tcase(s, tc);

    tc = tcase_create("Filelists etc.");
    tcase_add_unchecked_fixture(tc, fixture_yum, teardown);
    tcase_add_test(tc, test_filter_files);
    tcase_add_test(tc, test_filter_sourcerpm);
    tcase_add_test(tc, test_filter_description);
    tcase_add_test(tc, test_query_location);
    suite_add_tcase(s, tc);

    tc = tcase_create("Excluding");
    tcase_add_unchecked_fixture(tc, fixture_with_main, teardown);
    tcase_add_checked_fixture(tc, fixture_reset, NULL);
    tcase_add_test(tc, test_excluded);
    tcase_add_test(tc, test_disabled_repo);
    suite_add_tcase(s, tc);

    return s;
}
Esempio n. 20
0
END_TEST

/**
 * Image Control test case
 */

/*
START_TEST (test_image_bitblt)
{
    #include "image.c"
    struct point_t p;
    p.x = 0;
    p.y = 0;
    ulcd_image_bitblt(ulcd, &p, 480, 272, image);
}
END_TEST
*/

Suite *
ulcd_suite(void)
{
    Suite *s = suite_create("uLCD43");

    /* Util test case */
    TCase *tc_util = tcase_create("util");
    tcase_add_unchecked_fixture(tc_util, setup, teardown);
    tcase_add_test(tc_util, test_error);
    tcase_add_test(tc_util, test_make_polygon);
    tcase_add_test(tc_util, test_pack_polygon);
    suite_add_tcase(s, tc_util);

    /* Gfx test case */
    TCase *tc_gfx = tcase_create("gfx");
    tcase_add_unchecked_fixture(tc_gfx, setup, teardown);
    tcase_add_test(tc_gfx, test_gfx_cls);
    tcase_add_test(tc_gfx, test_gfx_circle);
    tcase_add_test(tc_gfx, test_gfx_filled_circle);
    tcase_add_test(tc_gfx, test_gfx_rectangle);
    tcase_add_test(tc_gfx, test_gfx_filled_rectangle);
    tcase_add_test(tc_gfx, test_gfx_polygon);
    tcase_add_test(tc_gfx, test_gfx_filled_polygon);
    tcase_add_test(tc_gfx, test_gfx_contrast);
    tcase_add_test(tc_gfx, test_display_on_off);
    suite_add_tcase(s, tc_gfx);

    /* Serial test case */
    TCase *tc_serial = tcase_create("serial");
    tcase_add_unchecked_fixture(tc_serial, setup, teardown);
    tcase_add_test(tc_serial, test_set_baud_rate);
    suite_add_tcase(s, tc_serial);

    /* Touch test case */
    TCase *tc_touch = tcase_create("touch");
    tcase_add_unchecked_fixture(tc_touch, setup, teardown);
    tcase_add_test(tc_touch, test_touch_set_detect_region);
    tcase_add_test(tc_touch, test_touch_set);
    tcase_add_test(tc_touch, test_touch_get);
    tcase_add_test(tc_touch, test_touch_get_event);
    suite_add_tcase(s, tc_touch);

    /* Text test case */
    TCase *tc_text = tcase_create("text");
    tcase_add_unchecked_fixture(tc_text, setup, teardown);
    tcase_add_test(tc_text, test_move_cursor);
    tcase_add_test(tc_text, test_txt_putch);
    tcase_add_test(tc_text, test_txt_putstr);
    tcase_add_test(tc_text, test_txt_charwidth);
    tcase_add_test(tc_text, test_txt_charheight);
    tcase_add_test(tc_text, test_txt_set_color_fg);
    tcase_add_test(tc_text, test_txt_set_color_bg);
    tcase_add_test(tc_text, test_txt_set_font);
    tcase_add_test(tc_text, test_txt_set_width);
    tcase_add_test(tc_text, test_txt_set_height);
    tcase_add_test(tc_text, test_txt_set_xgap);
    tcase_add_test(tc_text, test_txt_set_ygap);
    tcase_add_test(tc_text, test_txt_set_bold);
    tcase_add_test(tc_text, test_txt_set_inverse);
    tcase_add_test(tc_text, test_txt_set_italic);
    tcase_add_test(tc_text, test_txt_set_underline);
    tcase_add_test(tc_text, test_txt_set_opacity);
    tcase_add_test(tc_text, test_txt_set_attributes);
    suite_add_tcase(s, tc_text);

    /* Image test case */
    /*
    TCase *tc_image = tcase_create("Image");
    tcase_add_unchecked_fixture(tc_image, setup, teardown);
    tcase_add_test(tc_image, test_image_bitblt);
    tcase_set_timeout(tc_image, 60);
    suite_add_tcase(s, tc_image);
    */

    return s;
}
Esempio n. 21
0
END_TEST


Suite * array_utils_suite(void) {
    Suite * s = suite_create("array_utils");

    TCase * tc_d_array = tcase_create("d_array_test_case");
    tcase_add_test(tc_d_array, test_init_free_d_array);
    tcase_add_test_raise_signal(tc_d_array, test_init_d_array_fail, SIGABRT);
    tcase_add_test(tc_d_array, test_expand_d_array);
    tcase_add_test(tc_d_array, test_append_d_array);
    tcase_add_test(tc_d_array, test_set_d_array);
    tcase_add_test_raise_signal(tc_d_array, test_set_d_array_fail, SIGABRT);
    tcase_add_test(tc_d_array, test_get_d_array);
    tcase_add_test_raise_signal(tc_d_array, test_get_d_array_fail, SIGABRT);
    suite_add_tcase(s, tc_d_array);

    TCase * tc_i_array = tcase_create("i_array_test_case");
    tcase_add_test(tc_i_array, test_init_free_i_array);
    tcase_add_test_raise_signal(tc_i_array, test_init_i_array_fail, SIGABRT);
    tcase_add_test(tc_i_array, test_expand_i_array);
    tcase_add_test(tc_i_array, test_append_i_array);
    tcase_add_test(tc_i_array, test_set_i_array);
    tcase_add_test_raise_signal(tc_i_array, test_set_i_array_fail, SIGABRT);
    tcase_add_test(tc_i_array, test_get_i_array);
    tcase_add_test_raise_signal(tc_i_array, test_get_i_array_fail, SIGABRT);
    suite_add_tcase(s, tc_i_array);
    
    TCase * tc_c_array = tcase_create("c_array_test_case");
    tcase_add_test(tc_c_array, test_init_free_c_array);
    tcase_add_test_raise_signal(tc_c_array, test_init_c_array_fail, SIGABRT);
    tcase_add_test(tc_c_array, test_expand_c_array);
    tcase_add_test(tc_c_array, test_assign_c_array);
    tcase_add_test(tc_c_array, test_get_c_array);
    suite_add_tcase(s, tc_c_array);

    TCase * tc_s_array = tcase_create("s_array_test_case");
    tcase_add_test(tc_s_array, test_init_free_s_array);
    tcase_add_test_raise_signal(tc_s_array, test_init_s_array_fail, SIGABRT);
    tcase_add_test(tc_s_array, test_expand_s_array);
    tcase_add_test(tc_s_array, test_append_s_array);
    tcase_add_test(tc_s_array, test_set_s_array);
    tcase_add_test_raise_signal(tc_s_array, test_set_s_array_fail, SIGABRT);
    tcase_add_test(tc_s_array, test_get_s_array);
    tcase_add_test_raise_signal(tc_s_array, test_get_s_array_fail, SIGABRT);
    suite_add_tcase(s, tc_s_array);

    TCase * tc_i_array_2d = tcase_create("i_array_2d_test_case");
    tcase_add_test(tc_i_array_2d, test_init_free_i_array_2d);
    tcase_add_test_raise_signal(tc_i_array_2d, test_init_i_array_2d_fail,
            SIGABRT);
    tcase_add_test(tc_i_array_2d, test_expand_i_array_2d);
    tcase_add_test(tc_i_array_2d, test_append_i_array_2d);
    tcase_add_test(tc_i_array_2d, test_append_el_i_array_2d);
    tcase_add_test(tc_i_array_2d, test_set_i_array_2d);
    tcase_add_test(tc_i_array_2d, test_set_el_i_array_2d);
    tcase_add_test_raise_signal(tc_i_array_2d, test_set_i_array_2d_fail,
            SIGABRT);
    tcase_add_test(tc_i_array_2d, test_get_i_array_2d);
    tcase_add_test(tc_i_array_2d, test_get_el_i_array_2d);
    tcase_add_test_raise_signal(tc_i_array_2d, test_get_i_array_2d_fail,
            SIGABRT);
    suite_add_tcase(s, tc_i_array_2d);

    TCase * tc_arrays_equal = tcase_create("arrays_equal_test_case");
    tcase_add_test(tc_arrays_equal, test_s_arrays_equal);
    tcase_add_test(tc_arrays_equal, test_i_arrays_equal);
    tcase_add_test(tc_arrays_equal, test_d_arrays_equal);
    suite_add_tcase(s, tc_arrays_equal);

    TCase * tc_get_matching_indices = tcase_create(
            "get_matching_indices_test_case");
    tcase_add_test(tc_get_matching_indices, test_get_matching_indices);
    tcase_add_exit_test(tc_get_matching_indices, test_get_matching_indices_fail,
            1);
    suite_add_tcase(s, tc_get_matching_indices);

    TCase * tc_get_doubles = tcase_create("get_doubles_test_case");
    tcase_add_test(tc_get_doubles, test_get_doubles);
    suite_add_tcase(s, tc_get_doubles);

    TCase * tc_split_str = tcase_create("split_str_test_case");
    tcase_add_test(tc_split_str, test_split_str);
    tcase_add_test(tc_split_str, test_split_str_d);
    tcase_add_test(tc_split_str, test_split_str_i);
    suite_add_tcase(s, tc_split_str);

    return s;
}
Esempio n. 22
0
/* This is called whenever the context status changes */
static void context_state_callback(pa_context *c, void *userdata) {
    fail_unless(c != NULL);

    switch (pa_context_get_state(c)) {
        case PA_CONTEXT_CONNECTING:
        case PA_CONTEXT_AUTHORIZING:
        case PA_CONTEXT_SETTING_NAME:
            break;

        case PA_CONTEXT_READY: {
            pa_stream_flags_t flags = PA_STREAM_AUTO_TIMING_UPDATE;
            pa_buffer_attr attr;
            static const pa_sample_spec ss = {
                .format = PA_SAMPLE_S16LE,
                .rate = 44100,
                .channels = 2
            };

            pa_zero(attr);
            attr.maxlength = (uint32_t) -1;
            attr.tlength = latency > 0 ? (uint32_t) pa_usec_to_bytes(latency, &ss) : (uint32_t) -1;
            attr.prebuf = (uint32_t) -1;
            attr.minreq = (uint32_t) -1;
            attr.fragsize = (uint32_t) -1;

#ifdef INTERPOLATE
            flags |= PA_STREAM_INTERPOLATE_TIMING;
#endif

            if (latency > 0)
                flags |= PA_STREAM_ADJUST_LATENCY;

            pa_log("Connection established");

            stream = pa_stream_new(c, "interpol-test", &ss, NULL);
            fail_unless(stream != NULL);

            if (playback) {
                pa_assert_se(pa_stream_connect_playback(stream, NULL, &attr, flags, NULL, NULL) == 0);
                pa_stream_set_write_callback(stream, stream_write_cb, NULL);
            } else {
                pa_assert_se(pa_stream_connect_record(stream, NULL, &attr, flags) == 0);
                pa_stream_set_read_callback(stream, stream_read_cb, NULL);
            }

            pa_stream_set_latency_update_callback(stream, stream_latency_cb, NULL);

            break;
        }

        case PA_CONTEXT_TERMINATED:
            break;

        case PA_CONTEXT_FAILED:
        default:
            pa_log_error("Context error: %s", pa_strerror(pa_context_errno(c)));
            ck_abort();
    }
}

START_TEST (interpol_test) {
    pa_threaded_mainloop* m = NULL;
    int k;
    struct timeval start, last_info = { 0, 0 };
    pa_usec_t old_t = 0, old_rtc = 0;
#ifdef CORK
    bool corked = false;
#endif

    /* Set up a new main loop */
    m = pa_threaded_mainloop_new();
    fail_unless(m != NULL);
    mainloop_api = pa_threaded_mainloop_get_api(m);
    fail_unless(mainloop_api != NULL);
    context = pa_context_new(mainloop_api, bname);
    fail_unless(context != NULL);

    pa_context_set_state_callback(context, context_state_callback, NULL);

    fail_unless(pa_context_connect(context, NULL, 0, NULL) >= 0);

    pa_gettimeofday(&start);

    fail_unless(pa_threaded_mainloop_start(m) >= 0);

/* #ifdef CORK */
    for (k = 0; k < 20000; k++)
/* #else */
/*     for (k = 0; k < 2000; k++) */
/* #endif */
    {
        bool success = false, changed = false;
        pa_usec_t t, rtc, d;
        struct timeval now, tv;
        bool playing = false;

        pa_threaded_mainloop_lock(m);

        if (stream) {
            const pa_timing_info *info;

            if (pa_stream_get_time(stream, &t) >= 0 &&
                pa_stream_get_latency(stream, &d, NULL) >= 0)
                success = true;

            if ((info = pa_stream_get_timing_info(stream))) {
                if (memcmp(&last_info, &info->timestamp, sizeof(struct timeval))) {
                    changed = true;
                    last_info = info->timestamp;
                }
                if (info->playing)
                    playing = true;
            }
        }

        pa_threaded_mainloop_unlock(m);

        pa_gettimeofday(&now);

        if (success) {
#ifdef CORK
            bool cork_now;
#endif
            rtc = pa_timeval_diff(&now, &start);
            pa_log_info("%i\t%llu\t%llu\t%llu\t%llu\t%lli\t%u\t%u\t%llu\t%llu\n", k,
                   (unsigned long long) rtc,
                   (unsigned long long) t,
                   (unsigned long long) (rtc-old_rtc),
                   (unsigned long long) (t-old_t),
                   (signed long long) rtc - (signed long long) t,
                   changed,
                   playing,
                   (unsigned long long) latency,
                   (unsigned long long) d);

            fflush(stdout);
            old_t = t;
            old_rtc = rtc;

#ifdef CORK
            cork_now = (rtc / (2*PA_USEC_PER_SEC)) % 2 == 1;

            if (corked != cork_now) {
                pa_threaded_mainloop_lock(m);
                pa_operation_unref(pa_stream_cork(stream, cork_now, NULL, NULL));
                pa_threaded_mainloop_unlock(m);

                pa_log(cork_now ? "Corking" : "Uncorking");

                corked = cork_now;
            }
#endif
        }

        /* Spin loop, ugly but normal usleep() is just too badly grained */
        tv = now;
        while (pa_timeval_diff(pa_gettimeofday(&now), &tv) < 1000)
            pa_thread_yield();
    }

    if (m)
        pa_threaded_mainloop_stop(m);

    if (stream) {
        pa_stream_disconnect(stream);
        pa_stream_unref(stream);
    }

    if (context) {
        pa_context_disconnect(context);
        pa_context_unref(context);
    }

    if (m)
        pa_threaded_mainloop_free(m);
}
END_TEST

int main(int argc, char *argv[]) {
    int failed = 0;
    Suite *s;
    TCase *tc;
    SRunner *sr;

    if (!getenv("MAKE_CHECK"))
        pa_log_set_level(PA_LOG_DEBUG);

    bname = argv[0];
    playback = argc <= 1 || !pa_streq(argv[1], "-r");
    latency = (argc >= 2 && !pa_streq(argv[1], "-r")) ? atoi(argv[1]) : (argc >= 3 ? atoi(argv[2]) : 0);

    s = suite_create("Interpol");
    tc = tcase_create("interpol");
    tcase_add_test(tc, interpol_test);
    tcase_set_timeout(tc, 5 * 60);
    suite_add_tcase(s, tc);

    sr = srunner_create(s);
    srunner_run_all(sr, CK_NORMAL);
    failed = srunner_ntests_failed(sr);
    srunner_free(sr);

    return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
Esempio n. 23
0
END_TEST

/*
START_TEST(test_qrsolve_consistency) {
  u32 i, j, t;
  double norm;

  seed_rng();
  for (t = 0; t < LINALG_NUM; t++) {
    u32 n = sizerand(MSIZE_MAX);
    double x_gauss[n], x_qr[n];
    double A[n*n], Ainv[n*n], b[n];
    do {
      for (i = 0; i < n; i++) {
        b[i] = mrand;
        for (j = 0; j < n; j++)
          A[n*i + j] = mrand;
      }
    } while (matrix_inverse(n, A, Ainv) < 0);
    matrix_multiply(n, n, 1, Ainv, b, x_gauss);
    qrsolve(A, n, n, b, x_qr);

    norm = (vector_norm(n, x_qr) + vector_norm(n, x_gauss)) / 2;
    for (i = 0; i < n; i++)
      fail_unless(fabs(x_qr[i] - x_gauss[i]) < LINALG_TOL * norm,
                  "QR solve failure; difference was %lf for element %u",
                  x_qr[i] - x_gauss[i], i);
  }
}
END_TEST

START_TEST(test_qrsolve_rect) {
  s32 i;
  const double A[8] = {-0.0178505395610981, 1.4638781031761146,
                       -0.8242742209580581, -0.6843477128009663,
                       0.9155272861151404, -0.1651159277864960,
                       -0.9929037180867774, -0.1491537478964264};
  double Q[16], R[8];

  double buf[10] __attribute__((unused)) = {22, 22, 22, 22, 22,
                                            22, 22, 22, 22, 22};

  i = qrdecomp(A, 4, 2, Q, R);

  printf("i returned %d\n", i);

  MAT_PRINTF(A, 4, 2);
  MAT_PRINTF(Q, 4, 4);
  MAT_PRINTF(R, 4, 2);
}
END_TEST
*/

Suite* linear_algebra_suite(void) {
  Suite *s = suite_create("Linear algebra");

  /* Core test case */
  TCase *tc_core = tcase_create("Core");
  tcase_add_test(tc_core, test_matrix_eye);
  tcase_add_test(tc_core, test_matrix_triu);
  tcase_add_test(tc_core, test_matrix_reconstruct_udu);
  tcase_add_test(tc_core, test_matrix_udu_1);
  tcase_add_test(tc_core, test_matrix_udu_2);
  tcase_add_test(tc_core, test_matrix_udu_3);
  tcase_add_test(tc_core, test_matrix_add_sc);
  tcase_add_test(tc_core, test_matrix_copy);
  tcase_add_test(tc_core, test_matrix_transpose);
  tcase_add_test(tc_core, test_matrix_inverse_2x2);
  tcase_add_test(tc_core, test_matrix_inverse_3x3);
  tcase_add_test(tc_core, test_matrix_inverse_4x4);
  tcase_add_test(tc_core, test_matrix_inverse_5x5);

  tcase_add_test(tc_core, test_vector_dot);
  tcase_add_test(tc_core, test_vector_mean);
  tcase_add_test(tc_core, test_vector_norm);
  tcase_add_test(tc_core, test_vector_normalize);
  tcase_add_test(tc_core, test_vector_add_sc);
  tcase_add_test(tc_core, test_vector_add);
  tcase_add_test(tc_core, test_vector_subtract);
  tcase_add_test(tc_core, test_vector_cross);
  tcase_add_test(tc_core, test_vector_three);
  /*tcase_add_test(tc_core, test_qrsolve_consistency);*/
  /*tcase_add_test(tc_core, test_qrsolve_rect);*/
  suite_add_tcase(s, tc_core);

  return s;
}
Esempio n. 24
0
END_TEST

/**** And the suites are set up here ****/

void
lwc_basic_suite(SRunner *sr)
{
    Suite *s = suite_create("libwapcaplet: Basic tests");
    TCase *tc_basic = tcase_create("Creation/Destruction");

#ifndef NDEBUG
    tcase_add_test_raise_signal(tc_basic,
                                test_lwc_intern_string_aborts1,
                                SIGABRT);
    tcase_add_test_raise_signal(tc_basic,
                                test_lwc_intern_string_aborts2,
                                SIGABRT);
    tcase_add_test_raise_signal(tc_basic,
                                test_lwc_intern_substring_aborts1,
                                SIGABRT);
    tcase_add_test_raise_signal(tc_basic,
                                test_lwc_intern_substring_aborts2,
                                SIGABRT);
    tcase_add_test_raise_signal(tc_basic,
                                test_lwc_string_ref_aborts,
                                SIGABRT);
    tcase_add_test_raise_signal(tc_basic,
                                test_lwc_string_unref_aborts,
                                SIGABRT);
    tcase_add_test_raise_signal(tc_basic,
                                test_lwc_string_data_aborts,
                                SIGABRT);
    tcase_add_test_raise_signal(tc_basic,
                                test_lwc_string_length_aborts,
                                SIGABRT);
    tcase_add_test_raise_signal(tc_basic,
                                test_lwc_string_hash_value_aborts,
                                SIGABRT);
#endif

    suite_add_tcase(s, tc_basic);

    tc_basic = tcase_create("Ops with a context");

    tcase_add_checked_fixture(tc_basic, with_simple_context_setup,
                              with_simple_context_teardown);
    tcase_add_test(tc_basic, test_lwc_intern_string_ok);
    tcase_add_test(tc_basic, test_lwc_intern_string_twice_ok);
    tcase_add_test(tc_basic, test_lwc_intern_string_twice_same_ok);
    suite_add_tcase(s, tc_basic);

    tc_basic = tcase_create("Ops with a filled context");

    tcase_add_checked_fixture(tc_basic, with_filled_context_setup,
                              with_filled_context_teardown);
    tcase_add_test(tc_basic, test_lwc_interning_works);
    tcase_add_test(tc_basic, test_lwc_intern_substring);
    tcase_add_test(tc_basic, test_lwc_string_ref_ok);
    tcase_add_test(tc_basic, test_lwc_string_ref_unref_ok);
    tcase_add_test(tc_basic, test_lwc_string_unref_ok);
    tcase_add_test(tc_basic, test_lwc_string_isequal_ok);
    tcase_add_test(tc_basic, test_lwc_string_caseless_isequal_ok1);
    tcase_add_test(tc_basic, test_lwc_string_caseless_isequal_ok2);
    tcase_add_test(tc_basic, test_lwc_string_caseless_isequal_bad);
    tcase_add_test(tc_basic, test_lwc_extract_data_ok);
    tcase_add_test(tc_basic, test_lwc_string_hash_value_ok);
    tcase_add_test(tc_basic, test_lwc_string_is_nul_terminated);
    tcase_add_test(tc_basic, test_lwc_substring_is_nul_terminated);
    tcase_add_test(tc_basic, test_lwc_intern_substring_bad_size);
    tcase_add_test(tc_basic, test_lwc_intern_substring_bad_offset);
    tcase_add_test(tc_basic, test_lwc_string_iteration);
    suite_add_tcase(s, tc_basic);

    srunner_add_suite(sr, s);
}
Esempio n. 25
0
Suite *make_sub_suite(void)
{
  Suite *s;

  TCase *tc_simple;
  TCase *tc_signal;
#if TIMEOUT_TESTS_ENABLED
#if HAVE_WORKING_SETENV
  TCase *tc_timeout_env_int;
  TCase *tc_timeout_env_double;
#endif /* HAVE_WORKING_SETENV */
  TCase *tc_timeout_default;
  TCase *tc_timeout_usr_int;
  TCase *tc_timeout_usr_double;
#if HAVE_WORKING_SETENV
  TCase *tc_timeout_env_scale_int;
  TCase *tc_timeout_scale_int;
  TCase *tc_timeout_usr_scale_int;
  TCase *tc_timeout_env_scale_double;
  TCase *tc_timeout_scale_double;
  TCase *tc_timeout_usr_scale_double;
#endif /* HAVE_WORKING_SETENV */
#endif
  TCase *tc_limit;
  TCase *tc_messaging_and_fork;

  s = suite_create("Check Servant");

  tc_simple = tcase_create("Simple Tests");
  tc_signal = tcase_create("Signal Tests");
#if TIMEOUT_TESTS_ENABLED
#if HAVE_WORKING_SETENV
  setenv("CK_DEFAULT_TIMEOUT", "6", 1);
  tc_timeout_env_int = tcase_create("Environment Integer Timeout Tests");
  unsetenv("CK_DEFAULT_TIMEOUT");
  setenv("CK_DEFAULT_TIMEOUT", "0.5", 1);
  tc_timeout_env_double = tcase_create("Environment Double Timeout Tests");
  unsetenv("CK_DEFAULT_TIMEOUT");
#endif /* HAVE_WORKING_SETENV */
  tc_timeout_default = tcase_create("Default Timeout Tests");
  tc_timeout_usr_int = tcase_create("User Integer Timeout Tests");
  tc_timeout_usr_double = tcase_create("User Double Timeout Tests");
#if HAVE_WORKING_SETENV
  setenv("CK_TIMEOUT_MULTIPLIER", "2", 1);
  tc_timeout_scale_int = tcase_create("Timeout Integer Scaling Tests");
  tc_timeout_usr_scale_int = tcase_create("User Integer Timeout Scaling Tests");
  setenv("CK_DEFAULT_TIMEOUT", "6", 1);
  tc_timeout_env_scale_int = tcase_create("Environment Integer Timeout Scaling Tests");
  unsetenv("CK_DEFAULT_TIMEOUT");
  unsetenv("CK_TIMEOUT_MULTIPLIER");
  
  setenv("CK_TIMEOUT_MULTIPLIER", "0.4", 1);
  tc_timeout_scale_double = tcase_create("Timeout Double Scaling Tests");
  tc_timeout_usr_scale_double = tcase_create("User Double Timeout Scaling Tests");
  setenv("CK_DEFAULT_TIMEOUT", "0.9", 1);
  tc_timeout_env_scale_double = tcase_create("Environment Double Timeout Scaling Tests");
  unsetenv("CK_DEFAULT_TIMEOUT");
  unsetenv("CK_TIMEOUT_MULTIPLIER");
#endif /* HAVE_WORKING_SETENV */
#endif /* TIMEOUT_TESTS_ENABLED */
  tc_limit = tcase_create("Limit Tests");
  tc_messaging_and_fork = tcase_create("Msg and fork Tests");

  suite_add_tcase (s, tc_simple);
  suite_add_tcase (s, tc_signal);
#if TIMEOUT_TESTS_ENABLED
#if HAVE_WORKING_SETENV
  suite_add_tcase (s, tc_timeout_env_int);
  suite_add_tcase (s, tc_timeout_env_double);
#endif /* HAVE_WORKING_SETENV */
  suite_add_tcase (s, tc_timeout_default);
  suite_add_tcase (s, tc_timeout_usr_int);
  suite_add_tcase (s, tc_timeout_usr_double);

  /* Add a second time to make sure tcase_set_timeout doesn't contaminate it. */
  suite_add_tcase (s, tc_timeout_default);
#if HAVE_WORKING_SETENV
  suite_add_tcase (s, tc_timeout_env_scale_int);
  suite_add_tcase (s, tc_timeout_env_scale_double);
  suite_add_tcase (s, tc_timeout_scale_int);
  suite_add_tcase (s, tc_timeout_scale_double);
  suite_add_tcase (s, tc_timeout_usr_scale_int);
  suite_add_tcase (s, tc_timeout_usr_scale_double);
#endif
#endif
  suite_add_tcase (s, tc_limit);
  suite_add_tcase (s, tc_messaging_and_fork);

  tcase_add_test (tc_simple, test_lno);
  tcase_add_test (tc_simple, test_mark_lno);
  tcase_add_test (tc_simple, test_pass);
  tcase_add_test (tc_simple, test_fail_unless);
  tcase_add_test (tc_simple, test_fail_if_pass);
  tcase_add_test (tc_simple, test_fail_if_fail);
  tcase_add_test (tc_simple, test_fail_null_msg);
#if defined(__GNUC__)
  tcase_add_test (tc_simple, test_fail_no_msg);
#endif /* __GNUC__ */
  tcase_add_test (tc_simple, test_fail_if_null_msg);
#if defined(__GNUC__)
  tcase_add_test (tc_simple, test_fail_if_no_msg);
#endif /* __GNUC__ */
  tcase_add_test (tc_simple, test_fail_vararg_msg_1);
  tcase_add_test (tc_simple, test_fail_vararg_msg_2);
  tcase_add_test (tc_simple, test_fail_vararg_msg_3);
#if defined(__GNUC__)
  tcase_add_test (tc_simple, test_fail_empty);
#endif /* __GNUC__ */

  tcase_add_test (tc_simple, test_ck_abort);
  tcase_add_test (tc_simple, test_ck_abort_msg);
  tcase_add_test (tc_simple, test_ck_abort_msg_null);
  tcase_add_test (tc_simple, test_ck_assert);
  tcase_add_test (tc_simple, test_ck_assert_null);
  tcase_add_test (tc_simple, test_ck_assert_int_eq);
  tcase_add_test (tc_simple, test_ck_assert_int_ne);
  tcase_add_test (tc_simple, test_ck_assert_int_lt);
  tcase_add_test (tc_simple, test_ck_assert_int_le);
  tcase_add_test (tc_simple, test_ck_assert_int_gt);
  tcase_add_test (tc_simple, test_ck_assert_int_ge);
  tcase_add_test (tc_simple, test_ck_assert_int_expr);
  tcase_add_test (tc_simple, test_ck_assert_uint_eq);
  tcase_add_test (tc_simple, test_ck_assert_uint_ne);
  tcase_add_test (tc_simple, test_ck_assert_uint_lt);
  tcase_add_test (tc_simple, test_ck_assert_uint_le);
  tcase_add_test (tc_simple, test_ck_assert_uint_gt);
  tcase_add_test (tc_simple, test_ck_assert_uint_ge);
  tcase_add_test (tc_simple, test_ck_assert_uint_expr);
  tcase_add_test (tc_simple, test_ck_assert_str_eq);
  tcase_add_test (tc_simple, test_ck_assert_str_ne);
  tcase_add_test (tc_simple, test_ck_assert_str_lt);
  tcase_add_test (tc_simple, test_ck_assert_str_le);
  tcase_add_test (tc_simple, test_ck_assert_str_gt);
  tcase_add_test (tc_simple, test_ck_assert_str_ge);
  tcase_add_test (tc_simple, test_ck_assert_str_expr);
  tcase_add_test (tc_simple, test_ck_assert_ptr_eq);
  tcase_add_test (tc_simple, test_ck_assert_ptr_ne);

  tcase_add_test (tc_signal, test_segv);
  tcase_add_test_raise_signal (tc_signal, test_segv, 11); /* pass  */
  tcase_add_test_raise_signal (tc_signal, test_segv, 8);  /* error */
  tcase_add_test_raise_signal (tc_signal, test_pass, 8);  /* fail  */
  tcase_add_test_raise_signal (tc_signal, test_fail_unless, 8);  /* fail  */
  tcase_add_test (tc_signal, test_fpe);
  tcase_add_test (tc_signal, test_mark_point);

#if TIMEOUT_TESTS_ENABLED
#if HAVE_WORKING_SETENV
  tcase_add_test (tc_timeout_env_int, test_eternal);
  tcase_add_test (tc_timeout_env_int, test_sleep2);
  tcase_add_test (tc_timeout_env_int, test_sleep5);
  tcase_add_test (tc_timeout_env_int, test_sleep9);
  tcase_add_test (tc_timeout_env_double, test_eternal);
#ifdef HAVE_LIBRT
  tcase_add_test (tc_timeout_env_double, test_sleep0_025);
  tcase_add_test (tc_timeout_env_double, test_sleep1);
#endif /* HAVE_LIBRT */
  tcase_add_test (tc_timeout_env_double, test_sleep2);
  tcase_add_test (tc_timeout_env_double, test_sleep5);
  tcase_add_test (tc_timeout_env_double, test_sleep9);
#endif /* HAVE_WORKING_SETENV */

  tcase_add_test (tc_timeout_default, test_eternal);
#ifdef HAVE_LIBRT
  tcase_add_test (tc_timeout_default, test_sleep0_025);
  tcase_add_test (tc_timeout_default, test_sleep1);
#endif /* HAVE_LIBRT */
  tcase_add_test (tc_timeout_default, test_sleep2);
  tcase_add_test (tc_timeout_default, test_sleep5);
  tcase_add_test (tc_timeout_default, test_sleep9);

  tcase_set_timeout (tc_timeout_usr_int, 6);
  tcase_add_test (tc_timeout_usr_int, test_eternal);
  tcase_add_test (tc_timeout_usr_int, test_sleep2);
  tcase_add_test (tc_timeout_usr_int, test_sleep5);
  tcase_add_test (tc_timeout_usr_int, test_sleep9);

  tcase_set_timeout (tc_timeout_usr_double, 0.5);
  tcase_add_test (tc_timeout_usr_double, test_eternal);
#ifdef HAVE_LIBRT
  tcase_add_test (tc_timeout_usr_double, test_sleep0_025);
  tcase_add_test (tc_timeout_usr_double, test_sleep1);
#endif /* HAVE_LIBRT */
  tcase_add_test (tc_timeout_usr_double, test_sleep2);
  tcase_add_test (tc_timeout_usr_double, test_sleep5);
  tcase_add_test (tc_timeout_usr_double, test_sleep9);
  
#if HAVE_WORKING_SETENV
  tcase_add_test (tc_timeout_env_scale_int, test_eternal);
#ifdef HAVE_LIBRT
  tcase_add_test (tc_timeout_env_scale_int, test_sleep0_025);
  tcase_add_test (tc_timeout_env_scale_int, test_sleep1);
#endif /* HAVE_LIBRT */
  tcase_add_test (tc_timeout_env_scale_int, test_sleep2);
  tcase_add_test (tc_timeout_env_scale_int, test_sleep5);
  tcase_add_test (tc_timeout_env_scale_int, test_sleep9);
  tcase_add_test (tc_timeout_env_scale_int, test_sleep14);

  tcase_add_test (tc_timeout_env_scale_double, test_eternal);
#ifdef HAVE_LIBRT
  tcase_add_test (tc_timeout_env_scale_double, test_sleep0_025);
  tcase_add_test (tc_timeout_env_scale_double, test_sleep1);
#endif /* HAVE_LIBRT */
  tcase_add_test (tc_timeout_env_scale_double, test_sleep2);
  tcase_add_test (tc_timeout_env_scale_double, test_sleep5);
  tcase_add_test (tc_timeout_env_scale_double, test_sleep9);
  tcase_add_test (tc_timeout_env_scale_double, test_sleep14);

  tcase_add_test (tc_timeout_scale_int, test_eternal);
#ifdef HAVE_LIBRT
  tcase_add_test (tc_timeout_scale_int, test_sleep0_025);
  tcase_add_test (tc_timeout_scale_int, test_sleep1);
  tcase_add_test (tc_timeout_scale_int, test_sleep2);
#endif /* HAVE_LIBRT */
  tcase_add_test (tc_timeout_scale_int, test_sleep5);
  tcase_add_test (tc_timeout_scale_int, test_sleep9);

  tcase_add_test (tc_timeout_scale_double, test_eternal);
#ifdef HAVE_LIBRT
  tcase_add_test (tc_timeout_scale_double, test_sleep0_025);
  tcase_add_test (tc_timeout_scale_double, test_sleep1);
#endif /* HAVE_LIBRT */
  tcase_add_test (tc_timeout_scale_double, test_sleep2);
  tcase_add_test (tc_timeout_scale_double, test_sleep5);
  tcase_add_test (tc_timeout_scale_double, test_sleep9);
  
  setenv("CK_TIMEOUT_MULTIPLIER", "2", 1);
  tcase_set_timeout (tc_timeout_usr_scale_int, 6);
  unsetenv("CK_TIMEOUT_MULTIPLIER");
  tcase_add_test (tc_timeout_usr_scale_int, test_eternal);
#ifdef HAVE_LIBRT
  tcase_add_test (tc_timeout_usr_scale_int, test_sleep0_025);
  tcase_add_test (tc_timeout_usr_scale_int, test_sleep1);
#endif /* HAVE_LIBRT */
  tcase_add_test (tc_timeout_usr_scale_int, test_sleep2);
  tcase_add_test (tc_timeout_usr_scale_int, test_sleep5);
  tcase_add_test (tc_timeout_usr_scale_int, test_sleep9);
  tcase_add_test (tc_timeout_usr_scale_int, test_sleep14);
  
  setenv("CK_TIMEOUT_MULTIPLIER", "0.4", 1);
  tcase_set_timeout (tc_timeout_usr_scale_double, 0.9);
  unsetenv("CK_TIMEOUT_MULTIPLIER");
  tcase_add_test (tc_timeout_usr_scale_double, test_eternal);
#ifdef HAVE_LIBRT
  tcase_add_test (tc_timeout_usr_scale_double, test_sleep0_025);
  tcase_add_test (tc_timeout_usr_scale_double, test_sleep1);
#endif /* HAVE_LIBRT */
  tcase_add_test (tc_timeout_usr_scale_double, test_sleep2);
  tcase_add_test (tc_timeout_usr_scale_double, test_sleep5);
  tcase_add_test (tc_timeout_usr_scale_double, test_sleep9);
  tcase_add_test (tc_timeout_usr_scale_double, test_sleep14);
#endif
#endif

  tcase_add_test (tc_limit, test_early_exit);
  tcase_add_test (tc_limit, test_null);
  tcase_add_test (tc_limit, test_null_2);

#ifdef _POSIX_VERSION
  tcase_add_test (tc_messaging_and_fork, test_fork1p_pass);
  tcase_add_test (tc_messaging_and_fork, test_fork1p_fail);
  tcase_add_test (tc_messaging_and_fork, test_fork1c_pass);
  tcase_add_test (tc_messaging_and_fork, test_fork1c_fail);
  tcase_add_test (tc_messaging_and_fork, test_fork2_pass);
  tcase_add_test (tc_messaging_and_fork, test_fork2_fail);
#endif /* _POSIX_VERSION */

  return s;
}
Esempio n. 26
0
END_TEST


//  --------------------------------------------------------------------------
/// Self test this class.
void *
sam_msg_test ()
{
    Suite *s = suite_create ("sam_msg");

    TCase *tc = tcase_create("lifecycle (life)");
    tcase_add_test (tc, test_msg_life_basic);
    tcase_add_test (tc, test_msg_own);
    suite_add_tcase (s, tc);

    tc = tcase_create ("pop ()");
    tcase_add_test (tc, test_msg_pop_i);
    tcase_add_test (tc, test_msg_pop_s);
    tcase_add_test (tc, test_msg_pop_f);
    tcase_add_test (tc, test_msg_pop_p);
    tcase_add_test (tc, test_msg_pop_l);
    tcase_add_test (tc, test_msg_pop_l_empty);
    tcase_add_test (tc, test_msg_pop_l_double);
    tcase_add_test (tc, test_msg_pop);
    tcase_add_test (tc, test_msg_pop_insufficient_data);
    tcase_add_test (tc, test_msg_pop_successively);
    suite_add_tcase (s, tc);

    tc = tcase_create ("size ()");
    tcase_add_test (tc, test_msg_size);
    tcase_add_test (tc, test_msg_size_successively);
    suite_add_tcase (s, tc);

    tc = tcase_create ("free ()");
    tcase_add_test (tc, test_msg_free);
    suite_add_tcase (s, tc);

    tc = tcase_create ("get ()");
    tcase_add_test (tc, test_msg_get_i);
    tcase_add_test (tc, test_msg_get_s);
    tcase_add_test (tc, test_msg_get_f);
    tcase_add_test (tc, test_msg_get_p);
    tcase_add_test (tc, test_msg_get_l);
    tcase_add_test (tc, test_msg_get_l_empty);
    tcase_add_test (tc, test_msg_get_l_double);
    tcase_add_test (tc, test_msg_get_skipped);
    tcase_add_test (tc, test_msg_get_skipped_nonempty);
    tcase_add_test (tc, test_msg_get);
    tcase_add_test (tc, test_msg_get_insufficient_data);
    suite_add_tcase (s, tc);

    tc = tcase_create ("encode () and decode ()");
    tcase_add_test (tc, test_msg_code);
    tcase_add_test (tc, test_msg_code_pop);
    suite_add_tcase (s, tc);

    tc = tcase_create ("expect ()");
    tcase_add_test (tc, test_msg_expect_zero_noframe);
    tcase_add_test (tc, test_msg_expect_zero);
    tcase_add_test (tc, test_msg_expect_nonzero_empty);
    tcase_add_test (tc, test_msg_expect_nonzero_noframe);
    tcase_add_test (tc, test_msg_expect_list);
    tcase_add_test (tc, test_msg_expect_list_less);
    tcase_add_test (tc, test_msg_expect_list_noframe);
    tcase_add_test (tc, test_msg_expect);
    tcase_add_test (tc, test_msg_expect_nonzero);
    suite_add_tcase (s, tc);

    tc = tcase_create ("dup ()");
    tcase_add_test (tc, test_msg_dup);
    tcase_add_test (tc, test_msg_dup_refc);
    suite_add_tcase (s, tc);

    return s;
}
Esempio n. 27
0
END_TEST

static Suite *
litest_assert_macros_suite(void)
{
	TCase *tc;
	Suite *s;

	s = suite_create("litest:assert macros");
	tc = tcase_create("assert");
	tcase_add_test_raise_signal(tc, litest_assert_trigger, SIGABRT);
	tcase_add_test(tc, litest_assert_notrigger);
	tcase_add_test_raise_signal(tc, litest_assert_msg_trigger, SIGABRT);
	tcase_add_test_raise_signal(tc, litest_assert_msg_NULL_trigger, SIGABRT);
	tcase_add_test(tc, litest_assert_msg_notrigger);
	suite_add_tcase(s, tc);

	tc = tcase_create("abort");
	tcase_add_test_raise_signal(tc, litest_abort_msg_trigger, SIGABRT);
	tcase_add_test_raise_signal(tc, litest_abort_msg_NULL_trigger, SIGABRT);
	suite_add_tcase(s, tc);

	tc = tcase_create("int comparison ");
	tcase_add_test_raise_signal(tc, litest_int_eq_trigger, SIGABRT);
	tcase_add_test(tc, litest_int_eq_notrigger);
	tcase_add_test_raise_signal(tc, litest_int_ne_trigger, SIGABRT);
	tcase_add_test(tc, litest_int_ne_notrigger);
	tcase_add_test_raise_signal(tc, litest_int_le_trigger, SIGABRT);
	tcase_add_test(tc, litest_int_le_notrigger);
	tcase_add_test_raise_signal(tc, litest_int_lt_trigger_gt, SIGABRT);
	tcase_add_test_raise_signal(tc, litest_int_lt_trigger_eq, SIGABRT);
	tcase_add_test(tc, litest_int_lt_notrigger);
	tcase_add_test_raise_signal(tc, litest_int_ge_trigger, SIGABRT);
	tcase_add_test(tc, litest_int_ge_notrigger);
	tcase_add_test_raise_signal(tc, litest_int_gt_trigger_eq, SIGABRT);
	tcase_add_test_raise_signal(tc, litest_int_gt_trigger_lt, SIGABRT);
	tcase_add_test(tc, litest_int_gt_notrigger);
	suite_add_tcase(s, tc);

	tc = tcase_create("pointer comparison ");
	tcase_add_test_raise_signal(tc, litest_ptr_eq_trigger, SIGABRT);
	tcase_add_test_raise_signal(tc, litest_ptr_eq_trigger_NULL, SIGABRT);
	tcase_add_test_raise_signal(tc, litest_ptr_eq_trigger_NULL2, SIGABRT);
	tcase_add_test(tc, litest_ptr_eq_notrigger);
	tcase_add_test_raise_signal(tc, litest_ptr_ne_trigger, SIGABRT);
	tcase_add_test_raise_signal(tc, litest_ptr_ne_trigger_NULL, SIGABRT);
	tcase_add_test_raise_signal(tc, litest_ptr_ne_trigger_NULL2, SIGABRT);
	tcase_add_test(tc, litest_ptr_ne_notrigger);
	tcase_add_test_raise_signal(tc, litest_ptr_null_trigger, SIGABRT);
	tcase_add_test(tc, litest_ptr_null_notrigger);
	tcase_add_test_raise_signal(tc, litest_ptr_notnull_trigger, SIGABRT);
	tcase_add_test_raise_signal(tc, litest_ptr_notnull_trigger_NULL, SIGABRT);
	tcase_add_test(tc, litest_ptr_notnull_notrigger);
	suite_add_tcase(s, tc);

	tc = tcase_create("double comparison ");
	tcase_add_test(tc, ck_double_eq_and_ne);
	tcase_add_test(tc, ck_double_lt_gt);
	tcase_add_exit_test(tc, ck_double_eq_fails, 1);
	tcase_add_exit_test(tc, ck_double_ne_fails, 1);
	tcase_add_exit_test(tc, ck_double_lt_fails, 1);
	tcase_add_exit_test(tc, ck_double_gt_fails, 1);
	tcase_add_exit_test(tc, ck_double_le_fails, 1);
	tcase_add_exit_test(tc, ck_double_ge_fails, 1);
	suite_add_tcase(s, tc);

	return s;
}
Esempio n. 28
0
int main(void)
{
    setlogmask(LOG_UPTO(LOG_DEBUG));

    Suite *s1 = suite_create("Statsite");
    TCase *tc1 = tcase_create("hashmap");
    TCase *tc2 = tcase_create("quantile");
    TCase *tc3 = tcase_create("heap");
    TCase *tc4 = tcase_create("timer");
    TCase *tc5 = tcase_create("counter");
    TCase *tc6 = tcase_create("metrics");
    TCase *tc7 = tcase_create("streaming");
    TCase *tc8 = tcase_create("config");
    TCase *tc9 = tcase_create("radix");
    TCase *tc10 = tcase_create("hyperloglog");
    TCase *tc11 = tcase_create("set");
    SRunner *sr = srunner_create(s1);
    int nf;

    // Add the hashmap tests
    suite_add_tcase(s1, tc1);
    tcase_add_test(tc1, test_map_init_and_destroy);
    tcase_add_test(tc1, test_map_get_no_keys);
    tcase_add_test(tc1, test_map_put);
    tcase_add_test(tc1, test_map_put_get);
    tcase_add_test(tc1, test_map_delete_no_keys);
    tcase_add_test(tc1, test_map_put_delete);
    tcase_add_test(tc1, test_map_put_delete_get);
    tcase_add_test(tc1, test_map_clear_no_keys);
    tcase_add_test(tc1, test_map_put_clear_get);
    tcase_add_test(tc1, test_map_iter_no_keys);
    tcase_add_test(tc1, test_map_put_iter_break);
    tcase_add_test(tc1, test_map_put_grow);

    // Add the quantile tests
    suite_add_tcase(s1, tc2);
    tcase_add_test(tc2, test_cm_init_and_destroy);
    tcase_add_test(tc2, test_cm_init_no_quants);
    tcase_add_test(tc2, test_cm_init_bad_quants);
    tcase_add_test(tc2, test_cm_init_bad_eps);
    tcase_add_test(tc2, test_cm_init_add_destroy);
    tcase_add_test(tc2, test_cm_init_add_loop_destroy);
    tcase_add_test(tc2, test_cm_init_query_destroy);
    tcase_add_test(tc2, test_cm_init_add_query_destroy);
    tcase_add_test(tc2, test_cm_init_add_negative_query_destroy);
    tcase_add_test(tc2, test_cm_init_add_loop_query_destroy);
    tcase_add_test(tc2, test_cm_init_add_loop_rev_query_destroy);
    tcase_add_test(tc2, test_cm_init_add_loop_random_query_destroy);

    // Add the heap tests
    suite_add_tcase(s1, tc3);
    tcase_add_test(tc3, test_heap_init_and_destroy);
    tcase_add_test(tc3, test_heap_insert);
    tcase_add_test(tc3, test_heap_insert_delete);
    tcase_add_test(tc3, test_heap_delete_order);
    tcase_add_test(tc3, test_heap_for_each);
    tcase_add_test(tc3, test_heap_del_empty);

    // Add the timer tests
    suite_add_tcase(s1, tc4);
    tcase_add_test(tc4, test_timer_init_and_destroy);
    tcase_add_test(tc4, test_timer_init_add_destroy);
    tcase_add_test(tc4, test_timer_add_loop);
    tcase_add_test(tc4, test_timer_sample_rate);

    // Add the counter tests
    suite_add_tcase(s1, tc5);
    tcase_add_test(tc5, test_counter_init);
    tcase_add_test(tc5, test_counter_init_add);
    tcase_add_test(tc5, test_counter_add_loop);
    tcase_add_test(tc5, test_counter_sample_rate);

    // Add the counter tests
    suite_add_tcase(s1, tc6);
    tcase_add_test(tc6, test_metrics_init_and_destroy);
    tcase_add_test(tc6, test_metrics_init_defaults_and_destroy);
    tcase_add_test(tc6, test_metrics_empty_iter);
    tcase_add_test(tc6, test_metrics_add_iter);
    tcase_add_test(tc6, test_metrics_add_all_iter);
    tcase_add_test(tc6, test_metrics_histogram);
    tcase_add_test(tc6, test_metrics_gauges);

    // Add the streaming tests
    suite_add_tcase(s1, tc7);
    tcase_add_test(tc7, test_stream_empty);
    tcase_add_test(tc7, test_stream_some);
    tcase_add_test(tc7, test_stream_bad_cmd);
    tcase_add_test(tc7, test_stream_sigpipe);

    // Add the config tests
    suite_add_tcase(s1, tc8);
    tcase_add_test(tc8, test_config_get_default);
    tcase_add_test(tc8, test_config_bad_file);
    tcase_add_test(tc8, test_config_empty_file);
    tcase_add_test(tc8, test_config_basic_config);
    tcase_add_test(tc8, test_validate_default_config);
    tcase_add_test(tc8, test_validate_bad_config);
    tcase_add_test(tc8, test_join_path_no_slash);
    tcase_add_test(tc8, test_join_path_with_slash);
    tcase_add_test(tc8, test_sane_log_level);
    tcase_add_test(tc8, test_sane_log_facility);
    tcase_add_test(tc8, test_sane_timer_eps);
    tcase_add_test(tc8, test_sane_flush_interval);
    tcase_add_test(tc8, test_sane_histograms);
    tcase_add_test(tc8, test_sane_set_eps);
    tcase_add_test(tc8, test_config_histograms);
    tcase_add_test(tc8, test_build_radix);
    tcase_add_test(tc8, test_sane_prefixes);
    tcase_add_test(tc8, test_sane_global_prefix);
    tcase_add_test(tc8, test_sane_quantiles);
    tcase_add_test(tc8, test_extended_counters_include_count_only);
    tcase_add_test(tc8, test_extended_counters_include_count_rate);
    tcase_add_test(tc8, test_extended_counters_include_all_selected);
    tcase_add_test(tc8, test_extended_counters_include_all_by_default);
    tcase_add_test(tc8, test_timers_include_count_only);
    tcase_add_test(tc8, test_timers_include_count_rate);
    tcase_add_test(tc8, test_timers_include_all_selected);

    // Add the radix tests
    suite_add_tcase(s1, tc9);
    tcase_add_test(tc9, test_radix_init_and_destroy);
    tcase_add_test(tc9, test_radix_insert);
    tcase_add_test(tc9, test_radix_search);
    tcase_add_test(tc9, test_radix_longest_prefix);
    tcase_add_test(tc9, test_radix_foreach);

    // Add the hll tests
    suite_add_tcase(s1, tc10);
    tcase_add_test(tc10, test_hll_init_bad);
    tcase_add_test(tc10, test_hll_init_and_destroy);
    tcase_add_test(tc10, test_hll_add);
    tcase_add_test(tc10, test_hll_add_hash);
    tcase_add_test(tc10, test_hll_add_size);
    tcase_add_test(tc10, test_hll_size);
    tcase_add_test(tc10, test_hll_error_bound);
    tcase_add_test(tc10, test_hll_precision_for_error);

    // Add the set tests
    suite_add_tcase(s1, tc11);
    tcase_add_test(tc11, test_set_init_destroy);
    tcase_add_test(tc11, test_set_add_size_exact);
    tcase_add_test(tc11, test_set_add_size_exact_dedup);
    tcase_add_test(tc11, test_set_error_bound);


    srunner_run_all(sr, CK_ENV);
    nf = srunner_ntests_failed(sr);
    srunner_free(sr);

    return nf == 0 ? 0 : 1;
}
Esempio n. 29
0
} END_TEST

Suite *analyzer_typecheck_suite_create(void)
{
    Suite *s = suite_create("analyzer_type_check");

    TCase *t_typecheck_misc = tcase_create("typecheck_misc");
    tcase_add_checked_fixture(t_typecheck_misc,
                              setup_analyzer_tests,
                              teardown_analyzer_tests);
    tcase_add_test(t_typecheck_misc, test_typecheck_variable_declarations);
    tcase_add_test(t_typecheck_misc, test_typecheck_negative_int_variable_declarations);
    tcase_add_test(t_typecheck_misc, test_typecheck_complex_type_in_variable_declaration);
    tcase_add_test(t_typecheck_misc, test_typecheck_foreign_import);
    // TODO: Test where there are errors in two different parts of the code
    //       to assert the continuation of the traversal works

    TCase *t_custom_types_val = tcase_create("typecheck_valid_custom_types");
    tcase_add_checked_fixture(t_custom_types_val,
                              setup_analyzer_tests,
                              teardown_analyzer_tests);
    tcase_add_test(t_custom_types_val, test_typecheck_valid_custom_type_and_fncall1);
    tcase_add_test(t_custom_types_val, test_typecheck_valid_custom_type_and_fncall2);
    tcase_add_test(t_custom_types_val, test_typecheck_valid_custom_type_constructor);
    tcase_add_test(t_custom_types_val, test_typecheck_valid_custom_sum_type_constructor);
    tcase_add_test(t_custom_types_val, test_typecheck_valid_custom_sum_type_constructor2);

    TCase *t_custom_types_inv = tcase_create("typecheck_invalid_custom_types");
    tcase_add_checked_fixture(t_custom_types_inv,
                              setup_analyzer_tests_with_filelog,
                              teardown_analyzer_tests);
    tcase_add_test(t_custom_types_inv, test_typecheck_invalid_custom_type_constructor);
    tcase_add_test(t_custom_types_inv, test_typecheck_invalid_type_in_typedecl);

    TCase *t_block_val = tcase_create("typecheck_valid_blocks");
    tcase_add_checked_fixture(t_block_val,
                              setup_analyzer_tests,
                              teardown_analyzer_tests);
    tcase_add_test(t_block_val, test_typecheck_valid_assignment_from_block1);
    tcase_add_test(t_block_val, test_typecheck_valid_assignment_from_block2);


    TCase *t_block_inv = tcase_create("typecheck_invalid_blocks");
    tcase_add_checked_fixture(t_block_inv,
                              setup_analyzer_tests_with_filelog,
                              teardown_analyzer_tests);
    tcase_add_test(t_block_inv, test_typecheck_invalid_assignment_from_block1);
    tcase_add_test(t_block_inv, test_typecheck_invalid_assignment_from_block2);

    TCase *t_if_val = tcase_create("typecheck_valid_if");
    tcase_add_checked_fixture(t_if_val,
                              setup_analyzer_tests,
                              teardown_analyzer_tests);
    tcase_add_test(t_if_val, test_typecheck_valid_if_stmt);

    suite_add_tcase(s, t_typecheck_misc);
    suite_add_tcase(s, t_custom_types_val);
    suite_add_tcase(s, t_custom_types_inv);
    suite_add_tcase(s, t_block_val);
    suite_add_tcase(s, t_block_inv);
    suite_add_tcase(s, t_if_val);

    return s;
}
Esempio n. 30
0
void register_type_support_tests(Suite *s)
{
    TCase *tc = tcase_create("type support tests");
    tcase_addtests(tc, tests);
    suite_add_tcase (s, tc);
}