source_file *
add_c()
{
static char args_double[256];
static char args_float[256];
static source_file s = { " @(#) add.c:1.9 3/4/94 17:16:58", /* SCCS info */
__FILE__, __DATE__, __TIME__
};
sprintf(args_double, "%g %g 1500000", PI, -PI); /* arbitrary use of pi */
register_test("add_double", args_double, add_double,
1500 * OPS_PER_LOOP,
"Thousand Double Precision Additions");
sprintf(args_float, "%g %g 1000000", 3.5, -3.5); /* 3.5 to minimize round-off error */
register_test("add_float", args_float, add_float, 1000 * OPS_PER_LOOP,
"Thousand Single Precision Additions");
register_test("add_long", "3 -3 5000000", add_long,
5000 * OPS_PER_LOOP, "Thousand Long Integer Additions");
register_test("add_int", "3 -3 5000000", add_int, 5000 * OPS_PER_LOOP,
"Thousand Integer Additions");
register_test("add_short", "3 -3 2000000", add_short,
2000 * OPS_PER_LOOP, "Thousand Short Integer Additions");
return &s;
}
source_file *div_c()
{
static char args_double[256];
static char args_float[256];
static source_file s = { " @(#) div.c:1.7 3/4/94 17:17:14", /* SCCS info */
__FILE__, __DATE__, __TIME__
};
sprintf(args_double, "%g %g 250000", 4.0, 1.0 / 4.0); /* using .25 decreases round-off error */
register_test("div_double", 3, args_double, div_double,
250 * OPS_PER_LOOP,
"Thousand Double Precision Divides");
sprintf(args_float, "%g %g 250000", 4.0, 1.0 / 4.0); /* using .25 decreases round-off error */
register_test("div_float", 3, args_float, div_float,
250 * OPS_PER_LOOP,
"Thousand Single Precision Divides");
register_test("div_long", 3, "1 1 75000", div_long,
75 * OPS_PER_LOOP, "Thousand Long Integer Divides");
register_test("div_int", 3, "1 1 75000", div_int,
75 * OPS_PER_LOOP, "Thousand Integer Divides");
register_test("div_short", 3, "1 1 75000", div_short,
75 * OPS_PER_LOOP, "Thousand Short Integer Divides");
return &s;
}
index_types_test_suite()
{
register_test(test_bad_string_empty);
register_test(test_bad_string_too_long);
register_test(test_bad_string_numbers);
register_test(test_bad_index_zero);
register_test(test_column_operators);
}
void dram_4mbit_test ()
{
unregister_all_tests();
register_test(&test_dram_4mbit_init, "Init check");
register_test(&test_dram_4mbit_range, "4MB range check");
do_tests("DRAM 4MB tests", 0, 0);
}
int main(int argc, char *argv[])
{
root_test_t rt[1] = {{{ SU_HOME_INIT(rt) }}};
int retval = 0;
int i;
rt->rt_family = AF_INET;
for (i = 1; argv[i]; i++) {
if (strcmp(argv[i], "-v") == 0)
rt->rt_flags |= tst_verbatim;
else if (strcmp(argv[i], "-a") == 0)
rt->rt_flags |= tst_abort;
#if SU_HAVE_IN6
else if (strcmp(argv[i], "-6") == 0)
rt->rt_family = AF_INET6;
#endif
else
usage(1);
}
retval |= init_test(rt);
retval |= register_test(rt);
retval |= clone_test(rt);
su_root_threading(rt->rt_root, 0);
retval |= clone_test(rt);
retval |= deinit_test(rt);
return retval;
}
static void register_tests(void)
{
tests = NULL;
/*register_test("add_test1", add_test, 1);
register_test("add_test5", add_test, 5);
register_test("add_test10", add_test, 10);
register_test("add_test20", add_test, 20);*/
/*register_test("add_test50", add_test, 50);
register_test("add_test100", add_test, 100);
register_test("add_test200", add_test, 200);*/
/*register_test("modify_test1", modify_test, 1);
register_test("modify_test5", modify_test, 5);
register_test("modify_test10", modify_test, 10);
register_test("modify_test20", modify_test, 20);
register_test("modify_test50", modify_test, 50);*/
register_test("modify_test100", modify_test, 100);
//register_test("modify_test200", modify_test, 200);
/*register_test("delete_test1", delete_test, 1);
register_test("delete_test5", delete_test, 5);
register_test("delete_test10", delete_test, 10);
register_test("delete_test20", delete_test, 20);
register_test("delete_test50", delete_test, 50);*/
//register_test("delete_test100", delete_test, 100);
//register_test("delete_test200", delete_test, 200);
}
void
_test_suite::register_test(
__in test &tst
)
{
register_test(tst.get_name(), tst);
}
void register_all_tests() {
register_test(test_split_tet_thru_centroid, "split_tet_thru_centroid");
register_test(test_split_nonconvex, "split_nonconvex");
register_test(test_recursive_splitting_nondegenerate, "recursive_splitting_nondegenerate");
register_test(test_recursive_splitting_degenerate, "recursive_splitting_degenerate");
register_test(test_recursive_splitting_degenerate_perturbed, "recursive_splitting_degenerate_perturbed");
register_test(test_tet_tet_timing, "tet_tet_timing");
register_test(test_torus_load_and_chop, "torus_load_and_chop");
register_test(test_moments, "moments");
register_test(test_voxelization, "voxelization");
}
void scsp_misc_test()
{
scsp_minimal_init();
unregister_all_tests();
register_test(&scsp_int_on_timer_enable_test, "Int on Timer enable behaviour");
register_test(&scsp_int_on_timer_reset_test, "Int on Timer reset behaviour");
register_test(&scsp_int_dup_test, "No second Int after Timer done");
// register_test(&scsp_mcipd_test, "MCIPD bit cleared after Timer Int");
register_test(&scsp_scipd_test, "Timers start after SCIRE write");
register_test(&scsp_scipd_test, "Timers start after MCIRE write");
// DMA tests here
// MSLC/CA tests here
do_tests("SCSP Interrupt tests", 0, 0);
}
source_file *int_fcns_c()
{
static source_file s = { " @(#) int_fcns.c:1.6 8/13/93 11:07:18", /* SCCS info */
__FILE__, __DATE__, __TIME__
};
register_test("sieve", 2, "1000000 5", sieve, 5, "Integer Sieves");
return &s;
}
source_file *ram_c()
{
static source_file s = { " @(#) ram.c:1.4 7/26/93 16:48:37", /* SCCS info */
__FILE__, __DATE__, __TIME__
};
register_test("ram_copy", 1, "100", ram_copy, 25020,
"Memory to Memory Copy");
return &s;
}
void scsp_slot_test()
{
scsp_minimal_init();
unregister_all_tests();
register_test(&scu_interrupt_test, "Key On/Off");
register_test(&scsp_timer_a_test, "8/16-bit/Noise samples");
register_test(&scsp_timer_a_test, "Source bit");
register_test(&scsp_timer_a_test, "Looping");
register_test(&scsp_timer_a_test, "Octaves"); // not sure I can easily test this
register_test(&scsp_timer_a_test, "Attack rate"); // not sure I can easily test this
register_test(&scsp_timer_a_test, "Decay rate"); // not sure I can easily test this
register_test(&scsp_timer_a_test, "Decay level"); // not sure I can easily test this
register_test(&scsp_timer_a_test, "Release rate"); // not sure I can easily test this
register_test(&scsp_timer_a_test, "Total level");
// modulation test here
// LFO tests here
// direct pan/sdl tests here
do_tests("SCSP Timer tests", 0, 0);
}
void scsp_timing_test()
{
scsp_minimal_init();
unregister_all_tests();
register_test(&scu_interrupt_test, "Sound Request Interrupt");
register_test(&scsp_timer_a_test, "Timer A");
register_test(&scsp_timer_b_test, "Timer B");
register_test(&scsp_timer_c_test, "Timer C");
/*
register_test(&ScspTimerTimingTest0, "Timer timing w/1 sample inc");
register_test(&ScspTimerTimingTest1, "Timer timing w/2 sample inc");
register_test(&ScspTimerTimingTest2, "Timer timing w/4 sample inc");
register_test(&ScspTimerTimingTest3, "Timer timing w/8 sample inc");
register_test(&ScspTimerTimingTest4, "Timer timing w/16 sample inc");
register_test(&ScspTimerTimingTest5, "Timer timing w/32 sample inc");
register_test(&ScspTimerTimingTest6, "Timer timing w/64 sample inc");
register_test(&ScspTimerTimingTest7, "Timer timing w/128 sample inc");
*/
do_tests("SCSP Timer tests", 0, 0);
}
static void test_register_channel_inactive(void){
belle_sip_listening_point_t *lp=belle_sip_provider_get_listening_point(prov,"TCP");
CU_ASSERT_PTR_NOT_NULL_FATAL(lp);
belle_sip_stack_set_inactive_transport_timeout(stack,5);
belle_sip_listening_point_clean_channels(lp);
CU_ASSERT_EQUAL(belle_sip_listening_point_get_channel_count(lp),0);
register_test("tcp",1);
CU_ASSERT_EQUAL(belle_sip_listening_point_get_channel_count(lp),1);
belle_sip_stack_sleep(stack,5000);
CU_ASSERT_EQUAL(belle_sip_listening_point_get_channel_count(lp),0);
belle_sip_stack_set_inactive_transport_timeout(stack,3600);
}
datetime_test_suite()
{
register_test(test_from_string);
register_test(test_to_string);
register_test(test_carry);
register_test(test_leap_year_bug);
register_test(test_early_date);
register_test(test_mac_calendar);
register_test(test_operators);
}
void sh2_test()
{
interrupt_set_level_mask(0xF);
init_iapetus(RES_320x224);
// Setup a screen for us draw on
vdp_rbg0_init(&test_disp_settings);
vdp_set_default_palette();
// Display On
vdp_disp_on();
unregister_all_tests();
register_test(&div_mirror_test, "DIV register access");
register_test(&div_operation_test, "DIV operations");
register_test(&div_interrupt_test, "DIV overflow interrupt");
do_tests("SH2 tests", 0, 0);
// Other tests to do: instruction tests, check all register accesses,
// onchip functions
}
// XXX: hack to use nm command-line utility for now. Use libelf later.
// XXX: but nm is more portable across object formats...
static int discover_tests_in(const char* test_library, TestItem* test_items, const uint32_t maximum_number_of_test_items, bool verbose)
{
int ret = 0;
char cmd[2048];
strcpy(cmd, "/usr/bin/nm ");
strcat(cmd, test_library);
/* Open the command for reading. */
FILE *nm_output_pipe = popen(cmd, "r");
if (nm_output_pipe == NULL) {
printf("\nERROR: Failed to run command ('/usr/bin/nm')\n" );
return -1;
}
char line[1024];
while (fgets(line, sizeof(line)-1, nm_output_pipe) != NULL) {
if (is_cgreen_spec(line)) {
char *pos = strstr(line, NM_OUTPUT_COLUMN_SEPARATOR1);
int len = strlen(NM_OUTPUT_COLUMN_SEPARATOR1);
if (pos == NULL) {
pos = strstr(line, NM_OUTPUT_COLUMN_SEPARATOR2);
len = strlen(NM_OUTPUT_COLUMN_SEPARATOR2);
}
char *specification_name = pos + len;
specification_name[strlen(specification_name) - 1] = 0; /* remove newline */
if (verbose) {
char *suite_name = context_name_from_specname(specification_name);
char *test_name = test_name_from_specname(specification_name);
char *function_name = function_name_from_specname(specification_name);
printf("Discovered %s:%s (%s)\n", suite_name, test_name, function_name);
free(suite_name);
free(test_name);
free(function_name);
}
if (register_test(test_items, maximum_number_of_test_items, specification_name) < 0) {
ret = -1;
break;
}}
}
pclose(nm_output_pipe);
return ret;
}
cell_test_suite()
{
register_test(test_infer_numeric);
register_test(test_constructor);
register_test(test_null);
register_test(test_string);
register_test(test_formula1);
register_test(test_formula2);
register_test(test_formula3);
register_test(test_not_formula);
register_test(test_boolean);
register_test(test_error_codes);
register_test(test_insert_datetime);
register_test(test_insert_date);
register_test(test_insert_time);
register_test(test_cell_formatted_as_date1);
register_test(test_cell_formatted_as_date2);
register_test(test_cell_formatted_as_date3);
register_test(test_illegal_characters);
register_test(test_timedelta);
register_test(test_cell_offset);
register_test(test_font);
register_test(test_fill);
register_test(test_border);
register_test(test_number_format);
register_test(test_alignment);
register_test(test_protection);
register_test(test_style);
register_test(test_print);
register_test(test_values);
register_test(test_reference);
register_test(test_anchor);
register_test(test_hyperlink);
register_test(test_comment);
}
int ignore_test(test_func_t*)
{
return register_test(&_ignore_test);
}
static void stateful_register_tls(void){
register_test("tls",1);
}
static void stateful_register_tcp(void){
register_test("tcp",1);
}
void TestSuite_Pool::load_tests()
{
register_test("P-tB1601",
new TestPool_ThriceFill());
register_test("P-tB1601*",
new TestPool_ThriceFillAlloc(), false);
register_test("P-tB1602",
new TestPool_Create(TestPool_Create::DFLT));
register_test("P-tB1603",
new TestPool_Create(TestPool_Create::COPY));
register_test("P-tB1604",
new TestPool_Create(TestPool_Create::DFLT_FAILSAFE));
register_test("P-tB1605",
new TestPool_Create(TestPool_Create::COPY_FAILSAFE));
register_test("P-tB1606",
new TestPool_Access());
register_test("P-tB1607",
new TestPool_Access());
register_test("P-tB1608",
new TestPool_Exception(TestPool_Exception::POOL_FULL_ASGN));
register_test("P-tB1609",
new TestPool_Exception(TestPool_Exception::POOL_FULL_ASGN_CPY));
register_test("P-tB160A",
new TestPool_Exception(TestPool_Exception::POOL_ACC_DELETED_REF));
register_test("P-tB160B",
new TestPool_Exception(TestPool_Exception::POOL_DES_FOREIGN_REF));
register_test("P-tB160C",
new TestPool_Exception(TestPool_Exception::POOL_DES_DELETED_REF));
register_test("P-tB160D",
new TestPool_Exception(TestPool_Exception::POOL_DES_FOREIGN_REF));
}
rich_text_test_suite()
{
register_test(test_operators);
register_test(test_runs);
}
void register_all_from_test_string_utils(void)
{
register_test(test_str_is_prefix, "str_is_prefix()");
register_test(test_str_is_suffix, "str_is_suffix()");
register_test(test_is_spaces_only, "is_spaces_only()");
register_test(test_my_stristr, "my_stristr()");
register_test(test_filename_append_dvi, "filename_append_dvi()");
/* TODO: expand_filename_append_dvi */
register_test(test_canonicalize_path, "canonicalize_path()");
register_test(test_format_arg, "format_arg()");
register_test(test_escape_format_arg, "escape_format_arg()");
register_test(test_expand_filename, "expand_filename()");
register_test(test_get_separated_list, "get_separated_list");
register_test(test_length_of_int, "length_of_int()");
register_test(test_get_extension, "Filename extensions");
}
void TestSuite_Pawsort::load_tests()
{
register_test("P-tB3001",
new TestPawSort(TestSort::ARRAY_SORTED));
register_test("P-tB3001*",
new TestStdSort(TestSort::ARRAY_SORTED), false);
register_test("P-tB3002",
new TestPawSort(TestSort::ARRAY_REVERSED));
register_test("P-tB3002*",
new TestStdSort(TestSort::ARRAY_REVERSED), false);
register_test("P-tB3003",
new TestPawSort(TestSort::ARRAY_NEARLY_2));
register_test("P-tB3003*",
new TestStdSort(TestSort::ARRAY_NEARLY_2), false);
register_test("P-tB3004",
new TestPawSort(TestSort::ARRAY_NEARLY_5));
register_test("P-tB3004*",
new TestStdSort(TestSort::ARRAY_NEARLY_5), false);
register_test("P-tB3005",
new TestPawSort(TestSort::ARRAY_FEW_UNIQUE));
register_test("P-tB3005*",
new TestStdSort(TestSort::ARRAY_FEW_UNIQUE), false);
register_test("P-tB3006",
new TestPawSort(TestSort::ARRAY_BLACK_SHEEP));
register_test("P-tB3006*",
new TestStdSort(TestSort::ARRAY_BLACK_SHEEP), false);
register_test("P-tB3007",
new TestPawSort(TestSort::ARRAY_DOUBLE_CLIMB));
register_test("P-tB3007*",
new TestStdSort(TestSort::ARRAY_DOUBLE_CLIMB), false);
register_test("P-tB3008",
new TestPawSort(TestSort::ARRAY_DOUBLE_DROP));
register_test("P-tB3008*",
new TestStdSort(TestSort::ARRAY_DOUBLE_DROP), false);
register_test("P-tB3009",
new TestPawSort(TestSort::ARRAY_STAIRS));
register_test("P-tB3009*",
new TestStdSort(TestSort::ARRAY_STAIRS), false);
register_test("P-tB3010*",
new TestStdSort(TestSort::ARRAY_MOUNTAIN));
register_test("P-tB3010",
new TestPawSort(TestSort::ARRAY_MOUNTAIN), false);
register_test("P-tB3011",
new TestPawSort(TestSort::ARRAY_DOUBLE_MOUNTAIN));
register_test("P-tB3011*",
new TestStdSort(TestSort::ARRAY_DOUBLE_MOUNTAIN), false);
register_test("P-tB3012",
new TestPawSort(TestSort::ARRAY_EVEREST));
register_test("P-tB3012*",
new TestStdSort(TestSort::ARRAY_EVEREST), false);
register_test("P-tB3013",
new TestPawSort(TestSort::ARRAY_CLIFF));
register_test("P-tB3013*",
new TestStdSort(TestSort::ARRAY_CLIFF), false);
register_test("P-tB3014",
new TestPawSort(TestSort::ARRAY_SPIKE));
register_test("P-tB3014*",
new TestStdSort(TestSort::ARRAY_SPIKE), false);
register_test("P-tB3015",
new TestPawSort(TestSort::ARRAY_CLIFF));
register_test("P-tB3015*",
new TestStdSort(TestSort::ARRAY_CLIFF), false);
register_test("P-tB3016",
new TestPawSort(TestSort::ARRAY_NIGHTMARE));
register_test("P-tB3016*",
new TestStdSort(TestSort::ARRAY_NIGHTMARE), false);
}
static void stateful_register_udp_delayed(void){
belle_sip_stack_set_tx_delay(stack,3000);
register_test(NULL,1);
belle_sip_stack_set_tx_delay(stack,0);
}
void
register_all_from_test_util(void)
{
register_test(test_src_format_arguments, "src_format_arguments");
}
int registerFileInstallerTests() {
if (!register_test(test_jad_1,testReadJadFile_1)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n", test_jad_1);
}
if (!register_test(test_jad_2,testReadJadFile_2)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",test_jad_2);
}
if (!register_test(testCreateRelativeURL_1m,testCreateRelativeURL_1)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testCreateRelativeURL_1m);
}
if (!register_test(testCreateRelativeURL_2m,testCreateRelativeURL_2)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testCreateRelativeURL_2m);
}
if (!register_test(testMidpGetVersion_1m,testMidpGetVersion_1)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testMidpGetVersion_1m);
}
if (!register_test(testMidpGetVersion_2m,testMidpGetVersion_2)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testMidpGetVersion_2m);
}
if (!register_test(testMidpGetVersion_3m,testMidpGetVersion_3)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testMidpGetVersion_3m);
}
if (!register_test(testMidpGetVersion_4m,testMidpGetVersion_4)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testMidpGetVersion_4m);
}
if (!register_test(testMidpCompareVersion_1m,testMidpCompareVersion_1)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testMidpCompareVersion_1m);
}
if (!register_test(testMidpCompareVersion_2m,testMidpCompareVersion_2)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testMidpCompareVersion_2m);
}
if (!register_test(testMidpCompareVersion_3m,testMidpCompareVersion_3)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testMidpCompareVersion_3m);
}
/*
if (!register_test(fileInstallerTest,testInstalFileUsingJad)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",fileInstallerTest);
}
if (!register_test(fileInstallerTestJar,testInstalFileUsingJar)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",fileInstallerTestJar);
}
if (!register_test(fileInstallerTestBadJad,testInstalFileUsingBadJad)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",fileInstallerTestBadJad);
}
*/
/*
if (!register_test(testParseJad_1m,testParseJad_1)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testParseJad_1m);
}
if (!register_test(testParseJad_2m,testParseJad_2)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testParseJad_2m);
}
if (!register_test(testParseManifest_1m,testParseManifest_1)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testParseManifest_1m);
}
if (!register_test(testParseManifest_2m,testParseManifest_2)) {
REPORT_WARN1(LC_AMS, "Registration of test %s failed.\n",testParseManifest_2);
}
*/
return 1;
} /* end of registerFileInstallerTests */
range_test_suite()
{
register_test(test_batch_formatting);
}
protection_test_suite()
{
register_test(test_all);
}
