static BOOLEAN run_tests(test_suite suite, const char* test_name)
{
current_suite = suite.name;
if (NULL == test_name) {
int i;
for (i = 0; i < suite.num_tests; ++i) {
++(test_results->run);
current_test = suite.tests[i].name;
printf("Running test: %s\n", current_test);
handle_outcome(test_runner(suite, &(suite.tests[i])));
current_test = NULL;
}
} else {
int i;
for (i = 0; i < suite.num_tests; ++i) {
if (strcmp(test_name, suite.tests[i].name) == 0) {
current_test = suite.tests[i].name;
printf("Running test: %s\n", current_test);
handle_outcome(test_runner(suite, &(suite.tests[i])));
current_test = NULL;
return TRUE;
}
}
fprintf(stderr, "Unable to find test: %s\n", test_name);
return FALSE;
}
current_suite = NULL;
return TRUE;
}
int main(int argc, char** argv)
{
mapnik::parameters params;
benchmark::handle_args(argc,argv,params);
// polygon/rect clipping
// IN : POLYGON ((155 203, 233 454, 315 340, 421 446, 463 324, 559 466, 665 253, 528 178, 394 229, 329 138, 212 134, 183 228, 200 264, 155 203),(313 190, 440 256, 470 248, 510 305, 533 237, 613 263, 553 397, 455 262, 405 378, 343 287, 249 334, 229 191, 313 190))
// RECT : POLYGON ((181 106, 181 470, 631 470, 631 106, 181 106))
// OUT (expected)
// POLYGON ((181 286.6666666666667, 233 454, 315 340, 421 446, 463 324, 559 466, 631 321.3207547169811, 631 234.38686131386862, 528 178, 394 229, 329 138, 212 134, 183 228, 200 264, 181 238.24444444444444, 181 286.6666666666667),(313 190, 440 256, 470 248, 510 305, 533 237, 613 263, 553 397, 455 262, 405 378, 343 287, 249 334, 229 191, 313 190))
mapnik::box2d<double> clipping_box(181,106,631,470);
std::string filename_("./benchmark/data/polygon.wkt");
std::ifstream in(filename_.c_str(),std::ios_base::in | std::ios_base::binary);
if (!in.is_open())
throw std::runtime_error("could not open: '" + filename_ + "'");
std::string wkt_in( (std::istreambuf_iterator<char>(in) ),
(std::istreambuf_iterator<char>()) );
{
test1 test_runner(params,wkt_in,clipping_box);
run(test_runner,"clipping polygon with agg");
}
{
test2 test_runner(params,wkt_in,clipping_box);
run(test_runner,"clipping polygon with clipper");
}
{
test3 test_runner(params,wkt_in,clipping_box);
run(test_runner,"clipping polygon with boost");
}
return 0;
}
int main(int argc, char** argv)
{
mapnik::parameters params;
benchmark::handle_args(argc,argv,params);
mapnik::datasource_cache::instance().register_datasources("./plugins/input/");
mapnik::box2d<double> z1(-20037508.3428,-8317435.0606,20037508.3428,18399242.7298);
// bbox for 16/10491/22911.png
mapnik::box2d<double> z16(-13622912.929097254,6026906.8062295765,-13621689.93664469,6028129.79868214);
{
test test_runner(params,
"benchmark/data/polygon_rendering_clip.xml",
z1);
run(test_runner,"polygon clip render z1");
}
{
test test_runner(params,
"benchmark/data/polygon_rendering_no_clip.xml",
z1);
run(test_runner,"polygon noclip render z1");
}
{
test test_runner(params,
"benchmark/data/polygon_rendering_clip.xml",
z16);
run(test_runner,"polygon clip render z16");
}
{
test test_runner(params,
"benchmark/data/polygon_rendering_no_clip.xml",
z16);
run(test_runner,"polygon noclip render z16");
}
return 0;
}
int run(T const& test_runner, std::string const& name)
{
try
{
if (!test_runner.validate())
{
std::clog << "test did not validate: " << name << "\n";
return -1;
}
// run test once before timing
// if it returns false then we'll abort timing
if (test_runner())
{
std::chrono::high_resolution_clock::time_point start;
std::chrono::high_resolution_clock::duration elapsed;
std::stringstream s;
s << name << ":"
<< std::setw(45 - (int)s.tellp()) << std::right
<< " t:" << test_runner.threads()
<< " i:" << test_runner.iterations();
if (test_runner.threads() > 0)
{
using thread_group = std::vector<std::unique_ptr<std::thread> >;
using value_type = thread_group::value_type;
thread_group tg;
for (std::size_t i=0;i<test_runner.threads();++i)
{
tg.emplace_back(new std::thread(test_runner));
}
start = std::chrono::high_resolution_clock::now();
std::for_each(tg.begin(), tg.end(), [](value_type & t) {if (t->joinable()) t->join();});
elapsed = std::chrono::high_resolution_clock::now() - start;
}
else
{
start = std::chrono::high_resolution_clock::now();
test_runner();
elapsed = std::chrono::high_resolution_clock::now() - start;
}
s << std::setw(65 - (int)s.tellp()) << std::right
<< std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count() << " milliseconds\n";
std::clog << s.str();
}
return 0;
}
catch (std::exception const& ex)
{
std::clog << "test runner did not complete: " << ex.what() << "\n";
return -1;
}
return 0;
}
int main(int argc, char** argv)
{
int return_value = 0;
try
{
mapnik::parameters params;
benchmark::handle_args(argc,argv,params);
boost::optional<std::string> name = params.get<std::string>("name");
if (!name)
{
std::clog << "please provide a name for this test\n";
return -1;
}
mapnik::freetype_engine::register_fonts("./fonts/",true);
mapnik::datasource_cache::instance().register_datasources("./plugins/input/");
{
test test_runner(params);
return_value = run(test_runner,*name);
}
}
catch (std::exception const& ex)
{
std::clog << ex.what() << "\n";
return -1;
}
return return_value;
}
int main(int argc, char** argv) {
if (argc < 3) {
fprintf(stderr, "USAGE: ngtembed_test infile1 [... infilen] bmkfile\n");
return -1;
}
return test_runner(0, argv[argc-1], test_function, argc-1, argv);
}
int main(int argc, char** argv)
{
mapnik::parameters params;
benchmark::handle_args(argc,argv,params);
test test_runner(params);
run(test_runner,"expr: grammer per parse");
test2 test_runner2(params);
return run(test_runner2,"expr: reuse grammar");
}
int main(int argc, char *argv[])
{
int ret = 0;
setup(argc, argv);
ret = test_runner();
teardown(MPI_RET_SUCCESS);
return ret;
}
int
main(int argc, const char** argv)
{
TTestContext ctx;
int len;
TTestContext_Init(&ctx);
len = sizeof(cases)/sizeof(TestCase);
test_runner(&ctx, cases, len);
TTestContext_Clean(&ctx);
return 0;
}
int main(int argc, char** argv)
{
mapnik::parameters params;
benchmark::handle_args(argc,argv,params);
bool success = mapnik::freetype_engine::register_fonts("./fonts", true);
if (!success) {
std::clog << "warning, did not register any new fonts!\n";
return -1;
}
std::size_t face_count = mapnik::freetype_engine::face_names().size();
test test_runner(params);
return run(test_runner,(boost::format("font_engine: creating %ld faces") % (face_count)).str());
}
int
main(int argc, const char** argv)
{
TTestMVM ctx;
TInst inst;
int len;
TTestContext_Init(&(ctx.fBase));
ctx.fVM = VM_New();
len = sizeof(cases)/sizeof(TestCase);
test_runner((TTestContext*)&ctx, cases, len);
TVM_Delete(ctx.fVM);
TTestContext_Clean(&(ctx.fBase));
return 0;
}
// echo -180 -60 | cs2cs -f "%.10f" +init=epsg:4326 +to +init=epsg:3857
int main(int argc, char** argv)
{
mapnik::parameters params;
benchmark::handle_args(argc,argv,params);
mapnik::box2d<double> from(-180,-80,180,80);
mapnik::box2d<double> to(-20037508.3427892476,-15538711.0963092316,20037508.3427892476,15538711.0963092316);
std::string from_str("+init=epsg:4326");
std::string to_str("+init=epsg:3857");
std::string from_str2("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs");
std::string to_str2("+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs +over");
int return_value = 0;
test test_runner(params,
from_str,
to_str,
from,
to,
true);
return_value = return_value | run(test_runner,"lonlat->merc epsg");
test test_runner2(params,
from_str2,
to_str2,
from,
to,
true);
return_value = return_value | run(test_runner2,"lonlat->merc literal");
test test_runner3(params,
to_str,
from_str,
to,
from,
true);
return_value = return_value | run(test_runner3,"merc->lonlat epsg");
test test_runner4(params,
to_str2,
from_str2,
to,
from,
true);
return_value = return_value | run(test_runner4,"merc->lonlat literal");
return return_value;
}
int main(int argc, char** argv)
{
int return_value = 0;
try
{
mapnik::parameters params;
benchmark::handle_args(argc,argv,params);
{
test test_runner(params);
return_value = return_value | run(test_runner,"std::getline");
}
{
test2 test_runner2(params);
return_value = return_value | run(test_runner2,"csv_utils::getline_csv");
}
}
catch (std::exception const& ex)
{
std::clog << ex.what() << "\n";
return -1;
}
return return_value;
}
int
main_run(void* main_arg) {
#if !BUILD_MONOLITHIC
string_const_t pattern;
string_t* exe_paths = 0;
size_t iexe, exesize;
process_t* process = 0;
string_t process_path = { 0, 0 };
unsigned int* exe_flags = 0;
#else
void* test_result;
#endif
#if FOUNDATION_PLATFORM_IOS || FOUNDATION_PLATFORM_ANDROID || FOUNDATION_PLATFORM_PNACL
int remain_counter = 0;
#endif
#if BUILD_DEBUG
const string_const_t build_name = string_const(STRING_CONST("debug"));
#elif BUILD_RELEASE
const string_const_t build_name = string_const(STRING_CONST("release"));
#elif BUILD_PROFILE
const string_const_t build_name = string_const(STRING_CONST("profile"));
#elif BUILD_DEPLOY
const string_const_t build_name = string_const(STRING_CONST("deploy"));
#endif
#if BUILD_MONOLITHIC
const string_const_t build_type = string_const(STRING_CONST(" monolithic"));
#else
const string_const_t build_type = string_empty();
#endif
char* pathbuf;
int process_result = 0;
thread_t event_thread;
FOUNDATION_UNUSED(main_arg);
FOUNDATION_UNUSED(build_name);
log_set_suppress(HASH_TEST, ERRORLEVEL_DEBUG);
log_infof(HASH_TEST, STRING_CONST("Task library v%s built for %s using %s (%.*s%.*s)"),
string_from_version_static(task_module_version()).str, FOUNDATION_PLATFORM_DESCRIPTION,
FOUNDATION_COMPILER_DESCRIPTION, STRING_FORMAT(build_name), STRING_FORMAT(build_type));
thread_initialize(&event_thread, event_loop, 0, STRING_CONST("event_thread"),
THREAD_PRIORITY_NORMAL, 0);
thread_start(&event_thread);
pathbuf = memory_allocate(HASH_STRING, BUILD_MAX_PATHLEN, 0, MEMORY_PERSISTENT);
while (!thread_is_running(&event_thread))
thread_sleep(10);
#if FOUNDATION_PLATFORM_IOS || FOUNDATION_PLATFORM_ANDROID || FOUNDATION_PLATFORM_PNACL
while (!_test_should_start) {
#if FOUNDATION_PLATFORM_ANDROID
system_process_events();
#endif
thread_sleep(100);
}
#endif
fs_remove_directory(STRING_ARGS(environment_temporary_directory()));
#if BUILD_MONOLITHIC
test_run_fn tests[] = {
test_task_run,
0
};
#if FOUNDATION_PLATFORM_ANDROID
thread_t test_thread;
thread_initialize(&test_thread, test_runner, tests, STRING_CONST("test_runner"),
THREAD_PRIORITY_NORMAL, 0);
thread_start(&test_thread);
log_debug(HASH_TEST, STRING_CONST("Starting test runner thread"));
while (!thread_is_running(&test_thread)) {
system_process_events();
thread_sleep(10);
}
while (thread_is_running(&test_thread)) {
system_process_events();
thread_sleep(10);
}
test_result = thread_join(&test_thread);
process_result = (int)(intptr_t)test_result;
thread_finalize(&test_thread);
#else
test_result = test_runner(tests);
process_result = (int)(intptr_t)test_result;
#endif
if (process_result != 0)
log_warnf(HASH_TEST, WARNING_SUSPICIOUS, STRING_CONST("Tests failed with exit code %d"),
process_result);
#if FOUNDATION_PLATFORM_IOS || FOUNDATION_PLATFORM_ANDROID || FOUNDATION_PLATFORM_PNACL
while (!_test_should_terminate && _test_have_focus && (remain_counter < 50)) {
system_process_events();
thread_sleep(100);
++remain_counter;
}
#endif
log_debug(HASH_TEST, STRING_CONST("Exiting main loop"));
#else // !BUILD_MONOLITHIC
//Find all test executables in the current executable directory
#if FOUNDATION_PLATFORM_WINDOWS
pattern = string_const(STRING_CONST("^test-.*\\.exe$"));
#elif FOUNDATION_PLATFORM_MACOSX
pattern = string_const(STRING_CONST("^test-.*$"));
#elif FOUNDATION_PLATFORM_POSIX
pattern = string_const(STRING_CONST("^test-.*$"));
#else
# error Not implemented
#endif
exe_paths = fs_matching_files(STRING_ARGS(environment_executable_directory()),
STRING_ARGS(pattern), false);
array_resize(exe_flags, array_size(exe_paths));
memset(exe_flags, 0, sizeof(unsigned int) * array_size(exe_flags));
#if FOUNDATION_PLATFORM_MACOSX
//Also search for test applications
string_const_t app_pattern = string_const(STRING_CONST("^test-.*\\.app$"));
regex_t* app_regex = regex_compile(app_pattern.str, app_pattern.length);
string_t* subdirs = fs_subdirs(STRING_ARGS(environment_executable_directory()));
for (size_t idir = 0, dirsize = array_size(subdirs); idir < dirsize; ++idir) {
if (regex_match(app_regex, subdirs[idir].str, subdirs[idir].length, 0, 0)) {
string_t exe_path = { subdirs[idir].str, subdirs[idir].length - 4 };
array_push(exe_paths, exe_path);
array_push(exe_flags, PROCESS_MACOSX_USE_OPENAPPLICATION);
}
}
string_array_deallocate(subdirs);
regex_deallocate(app_regex);
#endif
for (iexe = 0, exesize = array_size(exe_paths); iexe < exesize; ++iexe) {
string_const_t* process_args = 0;
string_const_t exe_file_name = path_base_file_name(STRING_ARGS(exe_paths[iexe]));
if (string_equal(STRING_ARGS(exe_file_name), STRING_ARGS(environment_executable_name())))
continue; //Don't run self
process_path = path_concat(pathbuf, BUILD_MAX_PATHLEN,
STRING_ARGS(environment_executable_directory()),
STRING_ARGS(exe_paths[iexe]));
process = process_allocate();
process_set_executable_path(process, STRING_ARGS(process_path));
process_set_working_directory(process, STRING_ARGS(environment_executable_directory()));
process_set_flags(process, PROCESS_ATTACHED | exe_flags[iexe]);
if (!_test_memory_tracker)
array_push(process_args, string_const(STRING_CONST("--no-memory-tracker")));
process_set_arguments(process, process_args, array_size(process_args));
log_infof(HASH_TEST, STRING_CONST("Running test executable: %.*s"),
STRING_FORMAT(exe_paths[iexe]));
process_result = process_spawn(process);
while (process_result == PROCESS_WAIT_INTERRUPTED) {
thread_sleep(10);
process_result = process_wait(process);
}
process_deallocate(process);
array_deallocate(process_args);
if (process_result != 0) {
if (process_result >= PROCESS_INVALID_ARGS)
log_warnf(HASH_TEST, WARNING_SUSPICIOUS,
STRING_CONST("Tests failed, process terminated with error %x"),
process_result);
else
log_warnf(HASH_TEST, WARNING_SUSPICIOUS, STRING_CONST("Tests failed with exit code %d"),
process_result);
process_set_exit_code(-1);
goto exit;
}
log_infof(HASH_TEST, STRING_CONST("All tests from %.*s passed (%d)"),
STRING_FORMAT(exe_paths[iexe]), process_result);
}
log_info(HASH_TEST, STRING_CONST("All tests passed"));
exit:
if (exe_paths)
string_array_deallocate(exe_paths);
array_deallocate(exe_flags);
#endif
_test_should_terminate = true;
thread_signal(&event_thread);
thread_finalize(&event_thread);
memory_deallocate(pathbuf);
log_infof(HASH_TEST, STRING_CONST("Tests exiting: %s (%d)"),
process_result ? "FAILED" : "PASSED", process_result);
if (process_result)
memory_set_tracker(memory_tracker_none());
return process_result;
}
void run_tests() {
Test *tests = test_init();
test_runner(tests);
test_destroy(tests);
}
static int
test_jig(int argc, char *argv[])
{
return test_runner(OPT_NOJIGTEST);
}
int main_run( void* main_arg )
{
#if !BUILD_MONOLITHIC
const char* pattern = 0;
char** exe_paths = 0;
unsigned int iexe, exesize;
process_t* process = 0;
char* process_path = 0;
unsigned int* exe_flags = 0;
#endif
#if FOUNDATION_PLATFORM_IOS || FOUNDATION_PLATFORM_ANDROID || FOUNDATION_PLATFORM_PNACL
int remain_counter = 0;
#endif
#if BUILD_DEBUG
const char* build_name = "debug";
#elif BUILD_RELEASE
const char* build_name = "release";
#elif BUILD_PROFILE
const char* build_name = "profile";
#elif BUILD_DEPLOY
const char* build_name = "deploy";
#endif
int process_result = 0;
object_t thread = 0;
FOUNDATION_UNUSED( main_arg );
FOUNDATION_UNUSED( build_name );
log_set_suppress( HASH_TEST, ERRORLEVEL_DEBUG );
log_infof( HASH_TEST, "Foundation library v%s built for %s using %s (%s)", string_from_version_static( foundation_version() ), FOUNDATION_PLATFORM_DESCRIPTION, FOUNDATION_COMPILER_DESCRIPTION, build_name );
thread = thread_create( event_thread, "event_thread", THREAD_PRIORITY_NORMAL, 0 );
thread_start( thread, 0 );
while( !thread_is_running( thread ) )
thread_sleep( 10 );
#if FOUNDATION_PLATFORM_IOS || FOUNDATION_PLATFORM_ANDROID
while( !_test_should_start )
{
#if FOUNDATION_PLATFORM_ANDROID
system_process_events();
#endif
thread_sleep( 100 );
}
#endif
fs_remove_directory( environment_temporary_directory() );
#if BUILD_MONOLITHIC
test_run_fn tests[] = {
test_app_run,
test_array_run,
test_atomic_run,
test_base64_run,
test_bitbuffer_run,
test_blowfish_run,
test_bufferstream_run,
test_config_run,
test_crash_run,
test_environment_run,
test_error_run,
test_event_run,
test_fs_run,
test_hash_run,
test_hashmap_run,
test_hashtable_run,
test_library_run,
test_math_run,
test_md5_run,
test_mutex_run,
test_objectmap_run,
test_path_run,
test_pipe_run,
test_process_run,
test_profile_run,
test_radixsort_run,
test_random_run,
test_regex_run,
test_ringbuffer_run,
test_semaphore_run,
test_stacktrace_run,
test_stream_run, //stream test closes stdin
test_string_run,
test_system_run,
test_time_run,
test_uuid_run,
0
};
#if FOUNDATION_PLATFORM_ANDROID
object_t test_thread = thread_create( test_runner, "test_runner", THREAD_PRIORITY_NORMAL, 0 );
thread_start( test_thread, tests );
log_debug( HASH_TEST, "Starting test runner thread" );
while( !thread_is_running( test_thread ) )
{
system_process_events();
thread_sleep( 10 );
}
while( thread_is_running( test_thread ) )
{
system_process_events();
thread_sleep( 10 );
}
process_result = (int)(intptr_t)thread_result( test_thread );
thread_destroy( test_thread );
while( thread_is_thread( test_thread ) )
{
system_process_events();
thread_sleep( 10 );
}
#else
process_result = (int)(intptr_t)test_runner( 0, tests );
#endif
if( process_result != 0 )
log_warnf( HASH_TEST, WARNING_SUSPICIOUS, "Tests failed with exit code %d", process_result );
#if FOUNDATION_PLATFORM_IOS || FOUNDATION_PLATFORM_ANDROID || FOUNDATION_PLATFORM_PNACL
while( !_test_should_terminate && _test_have_focus && ( remain_counter < 50 ) )
{
system_process_events();
thread_sleep( 100 );
++remain_counter;
}
#endif
log_debug( HASH_TEST, "Exiting main loop" );
#else // !BUILD_MONOLITHIC
//Find all test executables in the current executable directory
#if FOUNDATION_PLATFORM_WINDOWS
pattern = "^test-.*\\.exe$";
#elif FOUNDATION_PLATFORM_MACOSX
pattern = "^test-.*$";
#elif FOUNDATION_PLATFORM_POSIX
pattern = "^test-.*$";
#else
# error Not implemented
#endif
exe_paths = fs_matching_files( environment_executable_directory(), pattern, false );
array_resize( exe_flags, array_size( exe_paths ) );
memset( exe_flags, 0, sizeof( unsigned int ) * array_size( exe_flags ) );
#if FOUNDATION_PLATFORM_MACOSX
//Also search for test applications
const char* app_pattern = "^test-.*\\.app$";
regex_t* app_regex = regex_compile( app_pattern );
char** subdirs = fs_subdirs( environment_executable_directory() );
for( int idir = 0, dirsize = array_size( subdirs ); idir < dirsize; ++idir )
{
if( regex_match( app_regex, subdirs[idir], string_length( subdirs[idir] ), 0, 0 ) )
{
array_push( exe_paths, string_substr( subdirs[idir], 0, string_length( subdirs[idir] ) - 4 ) );
array_push( exe_flags, PROCESS_MACOSX_USE_OPENAPPLICATION );
}
}
string_array_deallocate( subdirs );
regex_deallocate( app_regex );
#endif
for( iexe = 0, exesize = array_size( exe_paths ); iexe < exesize; ++iexe )
{
bool is_self = false;
char* exe_file_name = path_base_file_name( exe_paths[iexe] );
if( string_equal( exe_file_name, environment_executable_name() ) )
is_self = true;
string_deallocate( exe_file_name );
if( is_self )
continue; //Don't run self
process_path = path_merge( environment_executable_directory(), exe_paths[iexe] );
process = process_allocate();
process_set_executable_path( process, process_path );
process_set_working_directory( process, environment_executable_directory() );
process_set_flags( process, PROCESS_ATTACHED | exe_flags[iexe] );
log_infof( HASH_TEST, "Running test executable: %s", exe_paths[iexe] );
process_result = process_spawn( process );
while( process_result == PROCESS_WAIT_INTERRUPTED )
{
thread_sleep( 10 );
process_result = process_wait( process );
}
process_deallocate( process );
string_deallocate( process_path );
if( process_result != 0 )
{
if( process_result >= PROCESS_INVALID_ARGS )
log_warnf( HASH_TEST, WARNING_SUSPICIOUS, "Tests failed, process terminated with error %x", process_result );
else
log_warnf( HASH_TEST, WARNING_SUSPICIOUS, "Tests failed with exit code %d", process_result );
process_set_exit_code( -1 );
goto exit;
}
log_infof( HASH_TEST, "All tests from %s passed (%d)", exe_paths[iexe], process_result );
}
log_info( HASH_TEST, "All tests passed" );
exit:
if( exe_paths )
string_array_deallocate( exe_paths );
array_deallocate( exe_flags );
#endif
thread_terminate( thread );
thread_destroy( thread );
while( thread_is_running( thread ) )
thread_sleep( 10 );
while( thread_is_thread( thread ) )
thread_sleep( 10 );
log_infof( HASH_TEST, "Tests exiting: %d", process_result );
return process_result;
}
int main(int argc, char** argv)
{
int return_value = 0;
mapnik::parameters params;
benchmark::handle_args(argc,argv,params);
{
test4 test_runner4(params);
return_value = return_value | run(test_runner4,"calloc");
}
{
test1 test_runner(params);
return_value = return_value | run(test_runner,"malloc/memcpy");
}
{
test1b test_runner(params);
return_value = return_value | run(test_runner,"malloc/memset");
}
{
test1c test_runner(params);
return_value = return_value | run(test_runner,"operator new/std::fill");
}
{
test2 test_runner(params);
return_value = return_value | run(test_runner,"operator new/memcpy");
}
{
test3 test_runner(params);
return_value = return_value | run(test_runner,"vector(N)");
}
{
test3b test_runner(params);
return_value = return_value | run(test_runner,"vector/resize");
}
{
test3c test_runner(params);
return_value = return_value | run(test_runner,"vector/assign");
}
{
test3d test_runner(params);
return_value = return_value | run(test_runner,"deque(N)");
}
{
test5 test_runner(params);
return_value = return_value | run(test_runner,"std::string range");
}
{
test5b test_runner(params);
return_value = return_value | run(test_runner,"std::string &[0]");
}
{
test6 test_runner(params);
return_value = return_value | run(test_runner,"valarray");
}
#if BOOST_VERSION >= 105400
{
test7 test_runner(params);
return_value = return_value | run(test_runner,"static_vector");
}
#endif
return return_value;
}
static int
test_all(int argc, char *argv[])
{
return test_runner(OPT_NOALLTEST);
}
int main_run( void* main_arg )
{
#if !FOUNDATION_PLATFORM_IOS && !FOUNDATION_PLATFORM_ANDROID
const char* pattern = 0;
char** exe_paths = 0;
unsigned int iexe, exesize;
process_t* process = 0;
char* process_path = 0;
unsigned int* exe_flags = 0;
#endif
int process_result = 0;
object_t thread = 0;
log_set_suppress( HASH_TEST, ERRORLEVEL_DEBUG );
thread = thread_create( event_thread, "event_thread", THREAD_PRIORITY_NORMAL, 0 );
thread_start( thread, 0 );
while( !thread_is_running( thread ) )
thread_sleep( 10 );
#if FOUNDATION_PLATFORM_IOS || FOUNDATION_PLATFORM_ANDROID
while( !_test_should_start )
thread_sleep( 10 );
test_run_fn tests[] = {
//test_app_run
test_array_run,
test_atomic_run,
test_base64_run,
test_bitbuffer_run,
test_blowfish_run,
test_bufferstream_run,
test_config_run,
test_crash_run,
test_environment_run,
test_error_run,
test_event_run,
test_fs_run,
test_hash_run,
test_hashmap_run,
test_hashtable_run,
test_library_run,
test_math_run,
test_md5_run,
test_mutex_run,
test_objectmap_run,
test_path_run,
test_pipe_run,
test_profile_run,
test_radixsort_run,
test_random_run,
test_ringbuffer_run,
test_semaphore_run,
test_stacktrace_run,
test_string_run,
test_uuid_run,
0
};
#if FOUNDATION_PLATFORM_ANDROID
object_t test_thread = thread_create( test_runner, "test_runner", THREAD_PRIORITY_NORMAL, 0 );
thread_start( test_thread, tests );
while( !thread_is_running( test_thread ) )
{
system_process_events();
thread_sleep( 10 );
}
while( thread_is_running( test_thread ) )
{
system_process_events();
thread_sleep( 10 );
}
process_result = (int)(intptr_t)thread_result( test_thread );
thread_destroy( test_thread );
while( thread_is_thread( test_thread ) )
{
system_process_events();
thread_sleep( 10 );
}
#else
process_result = (int)(intptr_t)test_runner( 0, tests );
#endif
if( process_result != 0 )
log_warnf( HASH_TEST, WARNING_SUSPICIOUS, "Tests failed with exit code %d", process_result );
while( !_test_should_terminate )
{
system_process_events();
thread_sleep( 100 );
}
log_debug( HASH_TEST, "Exiting main loop" );
#else
//Find all test executables in the current executable directory
#if FOUNDATION_PLATFORM_WINDOWS
pattern = "test-*.exe";
#elif FOUNDATION_PLATFORM_MACOSX
pattern = "test-*";
#elif FOUNDATION_PLATFORM_POSIX
pattern = "test-*";
#else
# error Not implemented
#endif
exe_paths = fs_matching_files( environment_executable_directory(), pattern, false );
array_resize( exe_flags, array_size( exe_paths ) );
memset( exe_flags, 0, sizeof( unsigned int ) * array_size( exe_flags ) );
#if FOUNDATION_PLATFORM_MACOSX
//Also search for test-*.app
const char* app_pattern = "test-*.app";
char** subdirs = fs_subdirs( environment_executable_directory() );
for( int idir = 0, dirsize = array_size( subdirs ); idir < dirsize; ++idir )
{
if( string_match_pattern( subdirs[idir], app_pattern ) )
{
array_push( exe_paths, string_substr( subdirs[idir], 0, string_length( subdirs[idir] ) - 4 ) );
array_push( exe_flags, PROCESS_OSX_USE_OPENAPPLICATION );
}
}
string_array_deallocate( subdirs );
#endif
for( iexe = 0, exesize = array_size( exe_paths ); iexe < exesize; ++iexe )
{
bool is_self = false;
char* exe_file_name = path_base_file_name( exe_paths[iexe] );
if( string_equal( exe_file_name, environment_executable_name() ) )
is_self = true;
string_deallocate( exe_file_name );
if( is_self )
continue; //Don't run self
process_path = path_merge( environment_executable_directory(), exe_paths[iexe] );
process = process_allocate();
process_set_executable_path( process, process_path );
process_set_working_directory( process, environment_executable_directory() );
process_set_flags( process, PROCESS_ATTACHED | exe_flags[iexe] );
log_infof( HASH_TEST, "Running test executable: %s", exe_paths[iexe] );
process_result = process_spawn( process );
while( process_result == PROCESS_WAIT_INTERRUPTED )
{
thread_sleep( 10 );
process_result = process_wait( process );
}
process_deallocate( process );
string_deallocate( process_path );
if( process_result != 0 )
{
if( process_result >= PROCESS_INVALID_ARGS )
log_warnf( HASH_TEST, WARNING_SUSPICIOUS, "Tests failed, process terminated with error %x", process_result );
else
log_warnf( HASH_TEST, WARNING_SUSPICIOUS, "Tests failed with exit code %d", process_result );
process_set_exit_code( -1 );
goto exit;
}
log_infof( HASH_TEST, "All tests from %s passed (%d)", exe_paths[iexe], process_result );
}
log_info( HASH_TEST, "All tests passed" );
exit:
if( exe_paths )
string_array_deallocate( exe_paths );
array_deallocate( exe_flags );
#endif
thread_terminate( thread );
thread_destroy( thread );
while( thread_is_running( thread ) )
thread_sleep( 10 );
while( thread_is_thread( thread ) )
thread_sleep( 10 );
return process_result;
}
