int main(void)
{
test_vector(password1, salt1, N1, r1, p1);
test_vector(password2, salt2, N2, r2, p2);
test_vector(password3, salt3, N3, r3, p3);
return 0;
}
int test_main( int /* argc */, char* /* argv */[] )
{
int res = test_vector(A());
// test an int vector for which optimized versions should be available
if (res == EXIT_SUCCESS)
res = test_vector(0);
// test a bool vector
if (res == EXIT_SUCCESS)
res = test_vector(false);
return res;
}
enum piglit_result
piglit_display(void)
{
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
test_matrix();
test_vector("float", ", 0, 0, 0", glUniform1fvARB);
test_vector("vec2", ", 0, 0", glUniform2fvARB);
test_vector("vec3", ", 0", glUniform3fvARB);
test_vector("vec4", "", glUniform4fvARB);
return PIGLIT_PASS;
}
void nessie_first(void){
uint8_t key[16];
uint8_t iv[8];
memset(iv, 0, 8);
memset(key, 0, 16);
key[0] = 0x80;
test_vector(key, iv, NULL);
key[0] = 0x00;
key[15] = 0x80;
test_vector(key, iv, NULL);
}
int main() {
test_map();
test_vector();
return 0;
}
int main(void)
{
vbx_test_init();
vbx_mxp_t *this_mxp = VBX_GET_THIS_MXP();
const int VBX_SCRATCHPAD_SIZE = this_mxp->scratchpad_size;
const int required_vectors = 4;
int N = VBX_SCRATCHPAD_SIZE / sizeof(vbx_mm_t) / required_vectors;
int PRINT_LENGTH = min( N, MAX_PRINT_LENGTH );
double scalar_time, vector_time;
int errors=0;
vbx_mxp_print_params();
printf( "\nAdd test...\n" );
printf( "Vector length: %d\n", N );
vbx_mm_t *scalar_in1 = malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *scalar_in2 = malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *scalar_out = malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *vector_in1 = vbx_shared_malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *vector_in2 = vbx_shared_malloc( N*sizeof(vbx_mm_t) );
vbx_mm_t *vector_out = vbx_shared_malloc( N*sizeof(vbx_mm_t) );
// vbx_mm_t *vector_out = vector_in2 - 5;
vbx_sp_t *v_in1 = vbx_sp_malloc( N*sizeof(vbx_sp_t) );
vbx_sp_t *v_in2 = vbx_sp_malloc( N*sizeof(vbx_sp_t) );
vbx_sp_t *v_out = vbx_sp_malloc( N*sizeof(vbx_sp_t) );
// vbx_sp_t *v_out = v_in2-5;
VBX_T(test_zero_array)( scalar_out, N );
VBX_T(test_zero_array)( vector_out, N );
VBX_T(test_init_array)( scalar_in1, N, 1 );
VBX_T(test_copy_array)( vector_in1, scalar_in1, N );
VBX_T(test_init_array)( scalar_in2, N, 1 );
VBX_T(test_copy_array)( vector_in2, scalar_in2, N );
VBX_T(test_print_array)( scalar_in1, PRINT_LENGTH );
VBX_T(test_print_array)( scalar_in2, PRINT_LENGTH );
scalar_time = test_scalar( scalar_out, scalar_in1, scalar_in2, N );
VBX_T(test_print_array)( scalar_out, PRINT_LENGTH);
vbx_dma_to_vector( v_in1, (void *)vector_in1, N*sizeof(vbx_sp_t) );
vbx_dma_to_vector( v_in2, (void *)vector_in1, N*sizeof(vbx_sp_t) );
vector_time = test_vector( v_out, v_in1, v_in2, N, scalar_time );
vbx_dma_to_host( (void *)vector_out, v_out, N*sizeof(vbx_sp_t) );
vbx_sync();
VBX_T(test_print_array)( vector_out, PRINT_LENGTH );
errors += VBX_T(test_verify_array)( scalar_out, vector_out, N );
VBX_TEST_END(errors);
return 0;
}
int main(int argc,const char** argv)
{
//
error_examples();
//
example1_main();
//
test_refvarval_1();
test_bboard_1();
test_bboard_2();
test_bboard_3();
//
//test_biotypes();
//
test_parent();
test_vector();
test_malloc();
test_pnode_1();
//
test_dao_1();
test_dao_2();
//
test_io_1();
test_io_2();
test_io_3();
//
return 0;
}
int main()
{
test_vector();
test_tolerance_predicate();
return boost::report_errors();
}
int main() {
test_vector();
//test_int();
return 0;
}
void perform_test_trivial() {
{
typedef int T;
typedef Id<T> id_type;
id_type p;
typedef std::vector<T> vector_t;
const T number_elements = 100;
vector_t test_vector(boost::make_counting_iterator(0), boost::make_counting_iterator(number_elements));
typedef vector_t::const_iterator iterator;
typedef iterator T2;
typedef Id<T2> id2_type;
id2_type p2;
const iterator& begin(test_vector.begin());
const iterator& end(test_vector.end());
for (iterator i = begin; i != end; ++i)
for (iterator j = begin; j != end; ++j) {
OKLIB_TEST_EQUAL(p(*i,*j), p2(i,j));
OKLIB_TEST_EQUAL(p(*i,*j), i == j);
OKLIB_TEST_EQUAL(p2(i,j), i == j);
}
}
}
double time_copy_into_vector(I first, I last, size_t iterations) {
std::vector<ValueType<I>> test_vector(first, last);
timer t;
t.start();
while (iterations--) std::copy(first, last, begin(test_vector));
return t.stop();
}
int main(int argc, const char * const *argv)
{
// if VALGRIND testing is enabled, we have to call ourselves with valgrind checking
const char *valgrind = getenv("VALGRIND_TESTS");
if (!valgrind || !*valgrind || !strcmp(valgrind, "0")) {
// fallthrough
}
else if (!strcmp(valgrind, "1")) {
char cmd[strlen(argv[0]) + 256];
snprintf(cmd, sizeof(cmd), "VALGRIND_TESTS=\"\" valgrind --error-exitcode=301 --leak-check=yes --show-reachable=yes --track-origins=yes %s", argv[0]);
return system(cmd) != 0;
} else {
char cmd[strlen(valgrind) + strlen(argv[0]) + 32];
snprintf(cmd, sizeof(cmd), "VALGRIND_TESTS="" %s %s", valgrind, argv[0]);
return system(cmd) != 0;
}
init(argc, argv); // allows us to test with options (e.g. with --debug)
srand((unsigned int) time(NULL));
// testing basic library functionality
test_buffer();
test_buffer_printf();
test_utils();
test_strcasecmp_ascii();
test_vector();
test_stringmap();
if (failed) {
info_printf("ERROR: %d out of %d basic tests failed\n", failed, ok + failed);
info_printf("This may completely break Mget functionality !!!\n");
return 1;
}
test_iri_parse();
test_iri_relative_to_absolute();
test_iri_compare();
test_parser();
test_cookies();
test_hsts();
test_parse_challenge();
selftest_options() ? failed++ : ok++;
deinit(); // free resources allocated by init()
if (failed) {
info_printf("Summary: %d out of %d tests failed\n", failed, ok + failed);
return 1;
}
info_printf("Summary: All %d tests passed\n", ok + failed);
return 0;
}
bool const test_main()
{
bool result = true;
result &= test_vector();
return result;
}
int main(void) {
test_vector();
test_base();
test_scalarmult();
test_random();
_exit(0);
}
bool unit_test()
{
bool test_result = true; // true == passed
CHECK(test_vector(), "Unit test test_vector failed\n");
CHECK(test_list(), "Unit test test_list failed\n");
return test_result;
}
void moa_test_run_all(void)
{
test_vector();
test_saturating_int();
test_gui_labeled_button();
test_gui_panel_vertical_layout();
test_gui_padding();
test_serialization_1();
test_serialization_2();
}
void test2()
{
std::vector <std::string> m_ControlUUIDList;
std::string controlUUID;
for (int i = 0; i < 32; ++i)
{
controlUUID = controlUUID + ((i % 2) ? "" :"a");
test_vector(m_ControlUUIDList, controlUUID);
}
}
int main()
{
switch(nondet_int())
{
case 0: test_vector(); break;
case 1: test_list(); break;
case 2: test_set(); break;
default:;
}
}
int main(void)
{
double scalar_time, vector_time;
int errors=0;
vbx_test_init();
vbx_mxp_print_params();
printf("\nVector FIR test...\n");
vbx_mm_t *scalar_sample = malloc( (SAMP_SIZE+NTAPS)*sizeof(vbx_mm_t) );
vbx_mm_t *scalar_coeffs = malloc( NTAPS*sizeof(vbx_mm_t) );
vbx_mm_t *scalar_out = malloc( SAMP_SIZE*sizeof(vbx_mm_t) );
vbx_mm_t *sample = vbx_shared_malloc( (SAMP_SIZE+NTAPS)*sizeof(vbx_mm_t) );
vbx_mm_t *coeffs = vbx_shared_malloc( NTAPS*sizeof(vbx_mm_t) );
vbx_mm_t *vector_out = vbx_shared_malloc( SAMP_SIZE*sizeof(vbx_mm_t) );
VBX_T(test_zero_array)( scalar_out, SAMP_SIZE );
VBX_T(test_zero_array)( vector_out, SAMP_SIZE );
VBX_T(test_init_array)( scalar_sample, SAMP_SIZE, 0xff );
VBX_T(test_copy_array)( sample, scalar_sample, SAMP_SIZE );
VBX_T(test_init_array)( scalar_coeffs, NTAPS, 1 );
VBX_T(test_copy_array)( coeffs, scalar_coeffs, NTAPS );
VBX_T(test_zero_array)( scalar_sample+SAMP_SIZE, NTAPS );
VBX_T(test_zero_array)( sample+SAMP_SIZE, NTAPS );
printf("\nSamples:\n");
VBX_T(test_print_array)( scalar_sample, min(SAMP_SIZE,MAX_PRINT_LENGTH) );
printf("\nCoefficients:\n");
VBX_T(test_print_array)( scalar_coeffs, min(NTAPS,MAX_PRINT_LENGTH) );
scalar_time = test_scalar( scalar_out, scalar_sample, scalar_coeffs);
VBX_T(test_print_array)( scalar_out, min(SAMP_SIZE,MAX_PRINT_LENGTH) );
#ifdef USE_TRANSPOSE
vector_time = test_vector_transpose( vector_out, sample, coeffs, scalar_time );
VBX_T(test_print_array)( vector_out, min(SAMP_SIZE,MAX_PRINT_LENGTH) );
errors += VBX_T(test_verify_array)( scalar_out, vector_out, SAMP_SIZE-NTAPS );
#endif //USE_TRANSPOSE
#ifdef USE_2D
vector_time = test_vector( vector_out, sample, coeffs, scalar_time );
VBX_T(test_print_array)( vector_out, min(SAMP_SIZE,MAX_PRINT_LENGTH) );
errors += VBX_T(test_verify_array)( scalar_out, vector_out, SAMP_SIZE-NTAPS );
#endif //USE_2D
VBX_TEST_END(errors);
return 0;
}
void spec_test(void){
uint8_t key[16];
uint8_t iv[8];
const uint8_t *ref;
ref = spec_ref;
memset(key, 0, 16);
test_vector(key, NULL, ref);
memcpy_P(key, spec_key1, 16);
ref += 48;
test_vector(key, NULL, ref);
memcpy_P(key, spec_key2, 16);
ref += 48;
test_vector(key, NULL, ref);
memset(key, 0, 16);
memset(iv, 0, 8);
ref += 48;
test_vector(key, iv, ref);
memcpy_P(iv, spec_iv1, 8);
ref += 48;
test_vector(key, iv, ref);
memcpy_P(iv, spec_iv2, 8);
ref += 48;
test_vector(key, iv, ref);
}
main()
{
AES_set_encrypt_key(test_key,128,&encks);
AES_set_decrypt_key(test_key,128,&decks);
test_vector(vector_17,sizeof(vector_17));
test_vector(vector_31,sizeof(vector_31));
test_vector(vector_32,sizeof(vector_32));
test_vector(vector_47,sizeof(vector_47));
test_vector(vector_48,sizeof(vector_48));
test_vector(vector_64,sizeof(vector_64));
exit(0);
}
int main (int , char **)
{
test_vector ();
test_map ();
test_integer_vector ();
test_double_vector ();
test_string_vector ();
test_integer ();
test_double ();
test_map_exchanges ();
test_vector_exchanges ();
test_native_vectors ();
test_queue ();
test_vector_transfer ();
test_flex_map ();
test_collection ();
return 0;
}
int main()
{
AES_set_encrypt_key(test_key, 128, &encks);
AES_set_decrypt_key(test_key, 128, &decks);
test_vector(vector_17, sizeof(vector_17));
test_vector(vector_31, sizeof(vector_31));
test_vector(vector_32, sizeof(vector_32));
test_vector(vector_47, sizeof(vector_47));
test_vector(vector_48, sizeof(vector_48));
test_vector(vector_64, sizeof(vector_64));
test_nistvector(vector_17, sizeof(vector_17));
test_nistvector(vector_31, sizeof(vector_31));
test_nistvector(vector_32, sizeof(vector_32));
test_nistvector(vector_47, sizeof(vector_47));
test_nistvector(vector_48, sizeof(vector_48));
test_nistvector(vector_64, sizeof(vector_64));
return 0;
}
static void test_vectors(grpc_slice_split_mode mode) {
grpc_chttp2_hpack_parser parser;
grpc_chttp2_hpack_parser_init(&parser);
/* D.2.1 */
test_vector(&parser, mode,
"400a 6375 7374 6f6d 2d6b 6579 0d63 7573"
"746f 6d2d 6865 6164 6572",
"custom-key", "custom-header", NULL);
/* D.2.2 */
test_vector(&parser, mode, "040c 2f73 616d 706c 652f 7061 7468", ":path",
"/sample/path", NULL);
/* D.2.3 */
test_vector(&parser, mode,
"1008 7061 7373 776f 7264 0673 6563 7265"
"74",
"password", "secret", NULL);
/* D.2.4 */
test_vector(&parser, mode, "82", ":method", "GET", NULL);
grpc_chttp2_hpack_parser_destroy(&parser);
grpc_chttp2_hpack_parser_init(&parser);
/* D.3.1 */
test_vector(&parser, mode,
"8286 8441 0f77 7777 2e65 7861 6d70 6c65"
"2e63 6f6d",
":method", "GET", ":scheme", "http", ":path", "/", ":authority",
"www.example.com", NULL);
/* D.3.2 */
test_vector(&parser, mode, "8286 84be 5808 6e6f 2d63 6163 6865", ":method",
"GET", ":scheme", "http", ":path", "/", ":authority",
"www.example.com", "cache-control", "no-cache", NULL);
/* D.3.3 */
test_vector(&parser, mode,
"8287 85bf 400a 6375 7374 6f6d 2d6b 6579"
"0c63 7573 746f 6d2d 7661 6c75 65",
":method", "GET", ":scheme", "https", ":path", "/index.html",
":authority", "www.example.com", "custom-key", "custom-value",
NULL);
grpc_chttp2_hpack_parser_destroy(&parser);
grpc_chttp2_hpack_parser_init(&parser);
/* D.4.1 */
test_vector(&parser, mode,
"8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4"
"ff",
":method", "GET", ":scheme", "http", ":path", "/", ":authority",
"www.example.com", NULL);
/* D.4.2 */
test_vector(&parser, mode, "8286 84be 5886 a8eb 1064 9cbf", ":method", "GET",
":scheme", "http", ":path", "/", ":authority", "www.example.com",
"cache-control", "no-cache", NULL);
/* D.4.3 */
test_vector(&parser, mode,
"8287 85bf 4088 25a8 49e9 5ba9 7d7f 8925"
"a849 e95b b8e8 b4bf",
":method", "GET", ":scheme", "https", ":path", "/index.html",
":authority", "www.example.com", "custom-key", "custom-value",
NULL);
grpc_chttp2_hpack_parser_destroy(&parser);
grpc_chttp2_hpack_parser_init(&parser);
grpc_chttp2_hptbl_set_max_bytes(&parser.table, 256);
grpc_chttp2_hptbl_set_current_table_size(&parser.table, 256);
/* D.5.1 */
test_vector(&parser, mode,
"4803 3330 3258 0770 7269 7661 7465 611d"
"4d6f 6e2c 2032 3120 4f63 7420 3230 3133"
"2032 303a 3133 3a32 3120 474d 546e 1768"
"7474 7073 3a2f 2f77 7777 2e65 7861 6d70"
"6c65 2e63 6f6d",
":status", "302", "cache-control", "private", "date",
"Mon, 21 Oct 2013 20:13:21 GMT", "location",
"https://www.example.com", NULL);
/* D.5.2 */
test_vector(&parser, mode, "4803 3330 37c1 c0bf", ":status", "307",
"cache-control", "private", "date",
"Mon, 21 Oct 2013 20:13:21 GMT", "location",
"https://www.example.com", NULL);
/* D.5.3 */
test_vector(&parser, mode,
"88c1 611d 4d6f 6e2c 2032 3120 4f63 7420"
"3230 3133 2032 303a 3133 3a32 3220 474d"
"54c0 5a04 677a 6970 7738 666f 6f3d 4153"
"444a 4b48 514b 425a 584f 5157 454f 5049"
"5541 5851 5745 4f49 553b 206d 6178 2d61"
"6765 3d33 3630 303b 2076 6572 7369 6f6e"
"3d31",
":status", "200", "cache-control", "private", "date",
"Mon, 21 Oct 2013 20:13:22 GMT", "location",
"https://www.example.com", "content-encoding", "gzip",
"set-cookie",
"foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1", NULL);
grpc_chttp2_hpack_parser_destroy(&parser);
grpc_chttp2_hpack_parser_init(&parser);
grpc_chttp2_hptbl_set_max_bytes(&parser.table, 256);
grpc_chttp2_hptbl_set_current_table_size(&parser.table, 256);
/* D.6.1 */
test_vector(&parser, mode,
"4882 6402 5885 aec3 771a 4b61 96d0 7abe"
"9410 54d4 44a8 2005 9504 0b81 66e0 82a6"
"2d1b ff6e 919d 29ad 1718 63c7 8f0b 97c8"
"e9ae 82ae 43d3",
":status", "302", "cache-control", "private", "date",
"Mon, 21 Oct 2013 20:13:21 GMT", "location",
"https://www.example.com", NULL);
/* D.6.2 */
test_vector(&parser, mode, "4883 640e ffc1 c0bf", ":status", "307",
"cache-control", "private", "date",
"Mon, 21 Oct 2013 20:13:21 GMT", "location",
"https://www.example.com", NULL);
/* D.6.3 */
test_vector(&parser, mode,
"88c1 6196 d07a be94 1054 d444 a820 0595"
"040b 8166 e084 a62d 1bff c05a 839b d9ab"
"77ad 94e7 821d d7f2 e6c7 b335 dfdf cd5b"
"3960 d5af 2708 7f36 72c1 ab27 0fb5 291f"
"9587 3160 65c0 03ed 4ee5 b106 3d50 07",
":status", "200", "cache-control", "private", "date",
"Mon, 21 Oct 2013 20:13:22 GMT", "location",
"https://www.example.com", "content-encoding", "gzip",
"set-cookie",
"foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1", NULL);
grpc_chttp2_hpack_parser_destroy(&parser);
}
int _STLP_CALL main(int argc, char** argv)
{
#if defined(_WIN32_WCE) || defined(__SYMBIAN32__)
std::ofstream file( "c:\\eh_test.txt" );
std::streambuf* old_cout_buf = cout.rdbuf(file.rdbuf());
std::streambuf* old_cerr_buf = cerr.rdbuf(file.rdbuf());
#endif
#if defined( __MWERKS__ ) && defined( macintosh ) // Get command line.
argc = ccommand(&argv);
// Allow the i/o window to be repositioned.
// EH_STD::string s;
// getline(EH_STD::cin, s);
#endif
unsigned int niters=2;
bool run_all=true;
bool run_slist = false;
bool run_list = false;
bool run_vector = false;
bool run_bit_vector = false;
bool run_deque = false;
bool run_hash_map = false;
bool run_hash_set = false;
bool run_set = false;
bool run_map = false;
bool run_algo = false;
bool run_algobase = false;
bool run_rope = false;
bool run_string = false;
bool run_bitset = false;
bool run_valarray = false;
int cur_argv;
char *p, *p1;
#if defined (EH_NEW_IOSTREAMS)
std::ios_base::sync_with_stdio(false);
#endif
cerr << argv[0]<<" : Exception handling testsuite.\n";
cerr.flush();
bool track_allocations = false;
// parse parameters :
// leak_test [-iterations] [-test] ...
for (cur_argv=1; cur_argv<argc; cur_argv++) {
p = argv[cur_argv];
if (*p == '-') {
switch (p[1]) {
case 'q':
gTestController.SetVerbose(false);
break;
case 'v':
gTestController.SetVerbose(true);
break;
#if 0 // This option was never actually used -- dwa 9/22/97
case 'i':
gTestController.IgnoreLeaks(true);
break;
#endif
case 'n':
p1 = argv[++cur_argv];
if (p1 && EH_CSTD::sscanf(p1, "%i", &niters)==1)
cerr <<" Doing "<<niters<<" iterations\n";
else
usage(argv[0]);
break;
case 't':
track_allocations = true;
break;
case 'e':
gTestController.TurnOffExceptions();
break;
case 's':
p1 = argv[++cur_argv];
if (p1 && EH_CSTD::sscanf(p1, "%i", &random_base)==1)
cerr <<" Setting "<<random_base<<" as base for random sizes.\n";
else
usage(argv[0]);
break;
default:
usage(argv[0]);
break;
}
} else {
run_all = false;
// test name
if (EH_CSTD::strcmp(p, "algo")==0) {
run_algo=true;
} else if (EH_CSTD::strcmp(p, "vector")==0) {
run_vector=true;
} else if (EH_CSTD::strcmp(p, "bit_vector")==0) {
run_bit_vector=true;
} else if (EH_CSTD::strcmp(p, "list")==0) {
run_list=true;
} else if (EH_CSTD::strcmp(p, "slist")==0) {
run_slist=true;
} else if (EH_CSTD::strcmp(p, "deque")==0) {
run_deque=true;
} else if (EH_CSTD::strcmp(p, "set")==0) {
run_set=true;
} else if (EH_CSTD::strcmp(p, "map")==0) {
run_map=true;
} else if (EH_CSTD::strcmp(p, "hash_set")==0) {
run_hash_set=true;
} else if (EH_CSTD::strcmp(p, "hash_map")==0) {
run_hash_map=true;
} else if (EH_CSTD::strcmp(p, "rope")==0) {
run_rope=true;
} else if (EH_CSTD::strcmp(p, "string")==0) {
run_string=true;
} else if (EH_CSTD::strcmp(p, "bitset")==0) {
run_bitset=true;
} else if (EH_CSTD::strcmp(p, "valarray")==0) {
run_valarray=true;
} else {
usage(argv[0]);
}
}
}
gTestController.TrackAllocations( track_allocations );
// Over and over...
for ( unsigned i = 0; i < niters ; i++ )
{
cerr << "iteration #" << i << "\n";
if (run_all || run_algobase) {
gTestController.SetCurrentContainer("algobase");
cerr << "EH test : algobase" << endl;
test_algobase();
}
if (run_all || run_algo) {
gTestController.SetCurrentContainer("algo");
cerr << "EH test : algo" << endl;
test_algo();
}
if (run_all || run_vector) {
gTestController.SetCurrentContainer("vector");
cerr << "EH test : vector" << endl;
test_vector();
}
#if defined( EH_BIT_VECTOR_IMPLEMENTED )
if (run_all || run_bit_vector) {
gTestController.SetCurrentContainer("bit_vector");
cerr << "EH test : bit_vector" << endl;
test_bit_vector();
}
#endif
if (run_all || run_list) {
gTestController.SetCurrentContainer("list");
cerr << "EH test : list" << endl;
test_list();
}
#if defined( EH_SLIST_IMPLEMENTED )
if (run_all || run_slist) {
gTestController.SetCurrentContainer("slist");
cerr << "EH test : slist" << endl;
test_slist();
}
#endif // EH_SLIST_IMPLEMENTED
if (run_all || run_deque) {
gTestController.SetCurrentContainer("deque");
cerr << "EH test : deque" << endl;
test_deque();
}
if (run_all || run_set) {
gTestController.SetCurrentContainer("set");
cerr << "EH test : set" << endl;
test_set();
gTestController.SetCurrentContainer("multiset");
cerr << "EH test : multiset" << endl;
test_multiset();
}
if (run_all || run_map) {
gTestController.SetCurrentContainer("map");
cerr << "EH test : map" << endl;
test_map();
gTestController.SetCurrentContainer("multimap");
cerr << "EH test : multimap" << endl;
test_multimap();
}
#if defined( EH_HASHED_CONTAINERS_IMPLEMENTED )
if (run_all || run_hash_map) {
gTestController.SetCurrentContainer("hash_map");
cerr << "EH test : hash_map" << endl;
test_hash_map();
gTestController.SetCurrentContainer("hash_multimap");
cerr << "EH test : hash_multimap" << endl;
test_hash_multimap();
}
if (run_all || run_hash_set) {
gTestController.SetCurrentContainer("hash_set");
cerr << "EH test : hash_set" << endl;
test_hash_set();
gTestController.SetCurrentContainer("hash_multiset");
cerr << "EH test : hash_multiset" << endl;
test_hash_multiset();
}
#endif // EH_HASHED_CONTAINERS_IMPLEMENTED
#if defined( EH_ROPE_IMPLEMENTED )
// CW1.8 can't compile this for some reason!
#if !( defined(__MWERKS__) && __MWERKS__ < 0x1900 )
if (run_all || run_rope) {
gTestController.SetCurrentContainer("rope");
cerr << "EH test : rope" << endl;
test_rope();
}
#endif
#endif // EH_ROPE_IMPLEMENTED
#if defined( EH_STRING_IMPLEMENTED )
if (run_all || run_string) {
gTestController.SetCurrentContainer("string");
cerr << "EH test : string" << endl;
test_string();
}
#endif
#if defined( EH_BITSET_IMPLEMENTED )
if (run_all || run_bitset) {
gTestController.SetCurrentContainer("bitset");
cerr << "EH test : bitset" << endl;
test_bitset();
}
#endif
#if defined( EH_VALARRAY_IMPLEMENTED )
if (run_all || run_bitset) {
gTestController.SetCurrentContainer("valarray");
cerr << "EH test : valarray" << endl;
test_valarray();
}
#endif
}
gTestController.TrackAllocations( false );
cerr << "EH test : Done\n";
#if defined(_WIN32_WCE) || defined(__SYMBIAN32__)
cout.rdbuf(old_cout_buf);
cerr.rdbuf(old_cerr_buf);
file.close();
#endif
return 0;
}
int main(int argc, char **argv)
{
//data
CUdeviceptr d_data0 = 0;
CUdeviceptr d_data1 = 0;
DataStruct *h_data0 = 0;
DataStruct *h_data1 = 0;
DataStruct h_data_reference0;
DataStruct h_data_reference1;
unsigned int memSize = sizeof(DataStruct);
//device references
CUcontext hContext = 0;
CUdevice hDevice = 0;
CUmodule hModule = 0;
CUstream hStream = 0;
// Initialize the device and get a handle to the kernel
CUresult status = initialize(0, &hContext, &hDevice, &hModule, &hStream);
// Allocate memory on host and device
if ((h_data0 = (DataStruct *)malloc(memSize)) == NULL)
{
std::cerr << "Could not allocate host memory" << std::endl;
exit(-1);
}
status = cuMemAlloc(&d_data0, memSize);
if ((h_data1 = (DataStruct *)malloc(memSize)) == NULL)
{
std::cerr << "Could not allocate host memory" << std::endl;
exit(-1);
}
status = cuMemAlloc(&d_data1, memSize);
if (status != CUDA_SUCCESS)
printf("ERROR: during cuMemAlloc\n");
///////////////////////////////////////////////////////////////////////////////
//======================= test cases ========================================//
///////////////////////////////////////////////////////////////////////////////
std::string name = "";
unsigned int testnum=0;
unsigned int passed=0;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/////////////////////// Ralf ///////////////////////////////////////////////////
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if(runRalfFunction("test_phi_scalar", test_phi_scalar, &hModule, d_data0, h_data0, &h_data_reference0, memSize))
passed++;
testnum++;
if(runRalfFunction("test_phi2_scalar", test_phi2_scalar, &hModule, d_data0, h_data0, &h_data_reference0, memSize))
passed++;
testnum++;
if(runRalfFunction("test_phi3_scalar", test_phi3_scalar, &hModule, d_data0, h_data0, &h_data_reference0, memSize))
passed++;
testnum++;
if(runRalfFunction("test_phi4_scalar", test_phi4_scalar, &hModule, d_data0, h_data0, &h_data_reference0, memSize))
passed++;
testnum++;
if(runRalfFunction("test_phi5_scalar", test_phi5_scalar, &hModule, d_data0, h_data0, &h_data_reference0, memSize))
passed++;
testnum++;
if(runRalfFunction("test_phi6_scalar", test_phi6_scalar, &hModule, d_data0, h_data0, &h_data_reference0, memSize))
passed++;
testnum++;
if(runRalfFunction("test_phi7_scalar", test_phi7_scalar, &hModule, d_data0, h_data0, &h_data_reference0, memSize))
passed++;
testnum++;
if(runRalfFunction("test_phi8_scalar", test_phi8_scalar, &hModule, d_data0, h_data0, &h_data_reference0, memSize))
passed++;
testnum++;
if(runRalfFunction("test_phi9_scalar", test_phi9_scalar, &hModule, d_data0, h_data0, &h_data_reference0, memSize))
passed++;
testnum++;
if(runRalfFunction("test_loopbad_scalar", test_loopbad_scalar, &hModule, d_data0, h_data0, &h_data_reference0, memSize))
passed++;
testnum++;
if(runRalfFunction("test_loop23_scalar", test_loop23_scalar, &hModule, d_data0, h_data0, &h_data_reference0, memSize))
passed++;
testnum++;
if(runRalfFunction("test_loop13_scalar", test_loop13_scalar, &hModule, d_data0, h_data0, &h_data_reference0, memSize))
passed++;
testnum++;
////////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_GetElementPointer_constant"; /////////////////////
setZero(h_data0,&h_data_reference0);
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_GetElementPointer_constant(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
///////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_calculate"; /////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 3;
h_data0->f = h_data_reference0.f = 3.2;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_calculate(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
///////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_parquetShader"; /////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->f = h_data_reference0.f = 1;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_parquetShader(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
///////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_GetElementPointer_dyn"; /////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 3;
h_data0->u = h_data_reference0.u = 7;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_GetElementPointer_dyn(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
///////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_branch_simple"; // Branch 1 /////////////////
setZero(h_data0,&h_data_reference0);
h_data0->f = h_data_reference0.f = -4;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_branch_simple(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
///////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_branch_simple"; // Branch 2 /////////////////
setZero(h_data0,&h_data_reference0);
h_data0->f = h_data_reference0.f = 8;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_branch_simple(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_branch_simplePHI"; // Branch 1 /////////////////
setZero(h_data0,&h_data_reference0);
h_data0->f = h_data_reference0.f = -10;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_branch_simplePHI(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_branch_loop"; //////////////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 100;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_branch_loop(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_math"; //////////////////////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->f = h_data_reference0.f = 1.4;
h_data0->i = h_data_reference0.i = 3;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_math(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_signedOperands"; //////////////////////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 3;
h_data0->f = h_data_reference0.f = -7;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_signedOperands(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_constantOperands"; //////////////////////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 3;
h_data0->f = h_data_reference0.f = -1.44;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_constantOperands(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_branch_loop_semihard"; /////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 10;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_branch_loop_semihard(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_branch_loop_hard"; // Branch 1 /////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 1;
h_data0->u = h_data_reference0.u = 3;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_branch_loop_hard(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*////////////*/ name = "test_branch_loop_hard"; // Branch 2 /////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 7;
h_data0->u = h_data_reference0.u = 10;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_branch_loop_hard(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_binaryInst"; /////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 5;
h_data0->f = h_data_reference0.f = -121.23;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_binaryInst(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_selp"; /////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = -15;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_selp(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_GetElementPointer_complicated"; /////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 1;
h_data_reference0.s.s.f = h_data0->s.s.f = 3.11;
h_data_reference0.s.sa[2].f = h_data0->s.sa[2].f = -4.32;
h_data_reference0.s.sa[h_data0->i].f = h_data0->s.sa[h_data0->i].f = 111.3;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_GetElementPointer_complicated(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_call"; /////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 10;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_call(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*/////////////*/ name = "test_alloca"; /////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 1;
h_data0->f = h_data_reference0.f = -3.23;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_alloca(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_alloca_complicated"; /////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->i = h_data_reference0.i = 1;
h_data0->f = h_data_reference0.f = 23.213;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_alloca_complicated(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_globalVariables"; /////////////////////////
setZero(h_data0,&h_data_reference0);
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_globalVariables(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_specialRegisters_x"; /////////////////////////
setZero(h_data0,&h_data_reference0);
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize, 2,3,4, 2,3); //run device function
runHostTestFunction(test_specialRegisters_x, &h_data_reference0, 2,3,4, 2,3); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_specialRegisters_y"; /////////////////////////
setZero(h_data0,&h_data_reference0);
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize, 2,3,4, 2,3); //run device function
runHostTestFunction(test_specialRegisters_x, &h_data_reference0, 2,3,4, 2,3); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_dualArgument"; /////////////////////////
setZero(h_data0,&h_data_reference0);
setZero(h_data1,&h_data_reference1);
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunDualTestFunction(&hModule, name, d_data0, d_data1, h_data0, h_data1, memSize); //run device function
test_dualArgument(&h_data_reference0,&h_data_reference1); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
if(compareData(h_data1,&h_data_reference1)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++; testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_vector"; /////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->fa[0] = h_data_reference0.fa[0] = 0.43f;
h_data0->fa[1] = h_data_reference0.fa[1] = 0.234f;
h_data0->fa[2] = h_data_reference0.fa[2] = 12893.f;
h_data0->fa[3] = h_data_reference0.fa[3] = 13.33f;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_vector(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_reg2Const"; /////////////////////////
setZero(h_data0,&h_data_reference0);
/*
unsigned int bytes; //size of constant
CUdeviceptr devptr_const=0;
status = cuModuleGetGlobal(&devptr_const,
&bytes,
hModule, "__ptx_constant_data_global");
cuMemcpyHtoD(devptr_const, h_data0, memSize);
*/
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_reg2Const(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_constantMemory"; /////////////////////////
setZero(h_data0,&h_data_reference0);
h_data0->fa[0] = __ptx_constant_data_global.fa[0] = 0.2348f;
unsigned int bytes; //size of constant
CUdeviceptr devptr_const=0;
status = cuModuleGetGlobal(&devptr_const,
&bytes,
hModule, "__ptx_constant_data_global");
cuMemcpyHtoD(devptr_const, h_data0, memSize);
setZero(h_data0,&h_data_reference0);
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
test_constantMemory(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_sharedMemory"; /////////////////////////
setZero(h_data0,&h_data_reference0);
for(int i = 0; i < ARRAY_N/2; i++)
h_data0->fa[i*2] = i;
for(int i = 0; i < ARRAY_N/2; i++)
h_data0->fa[i*2+1] = -i;
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize, 32,1,1, 1,1); //run device function
for(int i = 0; i < ARRAY_N/2; i++)
h_data_reference0.fa[i] = i;
for(int i = 0; i < ARRAY_N/2; i++)
h_data_reference0.fa[i+32] = -i;
// runHostTestFunction(test_sharedMemory, &h_data_reference0, 16,1,1, 1,1); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
//////////////////////////////////////////////////////////////////////////////////////////////////
/*///////////////*/ name = "test_lightShader"; /////////////////////////
setZero(h_data0,&h_data_reference0);
/*
unsigned int bytes; //size of constant
CUdeviceptr devptr_const=0;
status = cuModuleGetGlobal(&devptr_const,
&bytes,
hModule, "__ptx_constant_data_global");
cuMemcpyHtoD(devptr_const, h_data0, memSize);
*/
std::cout << "=============== Test " << testnum << ": " << name << " ===================\n";
loadAndRunTestFunction(&hModule, name, d_data0, h_data0, memSize); //run device function
/*
test_lightShader(&h_data_reference0); //run host reference
if(compareData(h_data0,&h_data_reference0)) //compare Data
{passed++; std::cout << " => Test passed!!!\n";}
testnum++;
*/
///////////////////////////////////////////////////////////////////////////////
//======================= test cases END ====================================//
///////////////////////////////////////////////////////////////////////////////
// Check the result
std::cout << "\nPASSED " << passed << " tests" << std::endl;
std::cout << "FAILED " << (testnum-passed) << " tests" << std::endl;
// Cleanup
if (d_data0)
{
cuMemFree(d_data0);
d_data0 = 0;
}
if (d_data1)
{
cuMemFree(d_data1);
d_data1 = 0;
}
if (h_data0)
{
free(h_data0);
h_data0 = 0;
}
if (h_data1)
{
free(h_data1);
h_data1 = 0;
}
if (hModule)
{
cuModuleUnload(hModule);
hModule = 0;
}
if (hStream)
{
cuStreamDestroy(hStream);
hStream = 0;
}
if (hContext)
{
cuCtxDestroy(hContext);
hContext = 0;
}
return 0;
}
int main(void)
{
vbx_test_init();
#if 0
vbx_mxp_t *this_mxp = VBX_GET_THIS_MXP();
const int VBX_SCRATCHPAD_SIZE = this_mxp->scratchpad_size;
int N = VBX_SCRATCHPAD_SIZE/sizeof(vbx_mm_t)/8;
#endif
int TEST_LENGTH = TEST_ROWS*TEST_COLS;
int NTAP_LENGTH = NTAP_ROWS*NTAP_COLS;
int PRINT_COLS = min( TEST_COLS, MAX_PRINT_LENGTH );
int PRINT_ROWS = min( TEST_ROWS, MAX_PRINT_LENGTH );
double scalar_time, vector_time;
int errors=0;
vbx_mxp_print_params();
printf( "\nMatrix FIR test...\n" );
printf( "Matrix dimensions: %d,%d\n", TEST_ROWS, TEST_COLS );
vbx_mm_t *scalar_in = malloc( TEST_LENGTH*sizeof(vbx_mm_t) );
vbx_mm_t *vector_in = vbx_shared_malloc( TEST_LENGTH*sizeof(vbx_mm_t) );
int32_t *scalar_filt = malloc( NTAP_LENGTH*sizeof(int32_t) );
int32_t *vector_filt = vbx_shared_malloc( NTAP_LENGTH*sizeof(int32_t) );
vbx_mm_t *scalar_out = malloc( TEST_LENGTH*sizeof(vbx_mm_t) );
vbx_mm_t *vector_out = vbx_shared_malloc( TEST_LENGTH*sizeof(vbx_mm_t) );
VBX_T(test_zero_array)( scalar_out, TEST_LENGTH );
VBX_T(test_zero_array)( vector_out, TEST_LENGTH );
VBX_T(test_init_array)( scalar_in, TEST_LENGTH, 1 );
VBX_T(test_copy_array)( vector_in, scalar_in, TEST_LENGTH );
test_init_array_word( scalar_filt, NTAP_LENGTH, 1 );
test_copy_array_word( vector_filt, scalar_filt, NTAP_LENGTH );
VBX_T(test_print_matrix)( scalar_in, PRINT_ROWS, PRINT_COLS, TEST_COLS );
test_print_matrix_word( scalar_filt, NTAP_ROWS, NTAP_COLS, NTAP_COLS );
scalar_time = test_scalar( scalar_out, scalar_in, scalar_filt,
TEST_ROWS, TEST_COLS, NTAP_ROWS, NTAP_COLS);
VBX_T(test_print_matrix)( scalar_out, PRINT_COLS, PRINT_ROWS, TEST_COLS );
vector_time = test_vector( vector_out, vector_in, vector_filt,
TEST_ROWS, TEST_COLS, NTAP_ROWS, NTAP_COLS, scalar_time );
VBX_T(test_print_matrix)( vector_out, PRINT_COLS, PRINT_ROWS, TEST_COLS );
int i;
for(i=0; i<TEST_ROWS-NTAP_ROWS; i++){
errors += VBX_T(test_verify_array)( scalar_out+i*TEST_COLS, vector_out+i*TEST_COLS, TEST_COLS-NTAP_COLS );
}
VBX_TEST_END(errors);
return 0;
}
int main()
{
test_vector();
}
int main(void)
{
test_string();
test_vector();
return 0;
}
int main()
{
sio << "short: " << sizeof(short) << " long: " << sizeof(long)
<< " long long: " << sizeof(long long) << " int: " << sizeof(int)
<< " void*: " << sizeof(void*) << " float: " << sizeof(float)
<< " double: " << sizeof(double) << '\n';
sio << "integer: " << sizeof(integer) << " memint: " << sizeof(memint)
<< " real: " << sizeof(real) << " variant: " << sizeof(variant)
<< " object: " << sizeof(object) << " rtobject: " << sizeof(rtobject) << '\n';
sio << "stateobj: " << sizeof(stateobj) << " Type: " << sizeof(Type)
<< " State: " << sizeof(State) << " opcodes: " << opMaxCode << '\n';
check(sizeof(memint) == sizeof(void*));
check(sizeof(memint) == sizeof(size_t));
#ifdef SHN_64
check(sizeof(integer) == 8);
check(sizeof(variant) <= 16);
#else
check(sizeof(integer) == 4);
check(sizeof(variant) <= 12);
#endif
initRuntime();
initTypeSys();
initVm();
int exitcode = 0;
try
{
test_common();
test_object();
test_ordset();
test_bytevec();
test_string();
test_strutils();
test_podvec();
test_vector();
test_dict();
test_set();
test_symtbl();
test_variant();
test_fifos();
test_parser();
// test_typesys();
// test_codegen();
}
catch (exception& e)
{
fprintf(stderr, "Exception: %s\n", e.what());
exitcode = 201;
}
doneVm();
doneTypeSys();
doneRuntime();
if (object::allocated != 0)
{
fprintf(stderr, "Error: object::allocated = %d\n", object::allocated);
exitcode = 202;
}
return exitcode;
}
