DECLARE_TEST( fs, directory )
{
char* longpath;
char* testpath = path_merge( environment_temporary_directory(), string_from_int_static( random64(), 0, 0 ) );
if( !fs_is_file( testpath ) )
fs_remove_file( testpath );
if( !fs_is_directory( testpath ) )
fs_make_directory( testpath );
EXPECT_TRUE( fs_is_directory( testpath ) );
fs_remove_directory( testpath );
EXPECT_FALSE( fs_is_directory( testpath ) );
longpath = path_merge( testpath, string_from_int_static( random64(), 0, 0 ) );
EXPECT_FALSE( fs_is_directory( longpath ) );
fs_make_directory( longpath );
EXPECT_TRUE( fs_is_directory( longpath ) );
fs_remove_directory( testpath );
EXPECT_FALSE( fs_is_directory( testpath ) );
EXPECT_FALSE( fs_is_directory( longpath ) );
string_deallocate( longpath );
string_deallocate( testpath );
return 0;
}
DECLARE_TEST( fs, util )
{
tick_t systime = time_system();
tick_t lastmod = 0;
char* testpath = path_merge( environment_temporary_directory(), string_from_int_static( random64(), 0, 0 ) );
if( !fs_is_directory( environment_temporary_directory() ) )
fs_make_directory( environment_temporary_directory() );
if( fs_is_directory( testpath ) )
fs_remove_directory( testpath );
fs_remove_file( testpath );
EXPECT_EQ( fs_last_modified( testpath ), 0 );
thread_sleep( 1000 ); //For fs time granularity, make sure at least one second passed since systime
stream_deallocate( fs_open_file( testpath, STREAM_OUT ) );
EXPECT_TRUE( fs_is_file( testpath ) );
EXPECT_GE( fs_last_modified( testpath ), systime );
fs_remove_file( testpath );
EXPECT_FALSE( fs_is_file( testpath ) );
EXPECT_EQ( fs_last_modified( testpath ), 0 );
stream_deallocate( fs_open_file( testpath, STREAM_OUT ) );
EXPECT_TRUE( fs_is_file( testpath ) );
EXPECT_GE( fs_last_modified( testpath ), systime );
lastmod = fs_last_modified( testpath );
thread_sleep( 5000 );
EXPECT_EQ( fs_last_modified( testpath ), lastmod );
fs_touch( testpath );
EXPECT_GT( fs_last_modified( testpath ), lastmod );
fs_remove_file( testpath );
string_deallocate( testpath );
return 0;
}
void PluginHandler_create(bool shadowDirectory) {
s_useShadowDir = shadowDirectory;
if (!shadowDirectory)
return;
// Cleanup directory first
if (fs_is_file(s_shadowDirName))
fs_remove_file(s_shadowDirName);
if (fs_is_directory(s_shadowDirName))
fs_remove_directory(s_shadowDirName);
fs_make_directory(s_shadowDirName);
// Listen to changes in the current directry for code
// TODO: Add this to settings so we can have more dirs here
}
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;
}
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;
}
DECLARE_TEST( fs, file )
{
char* testpath = path_merge( environment_temporary_directory(), string_from_int_static( random64(), 0, 0 ) );
char* copypath = path_merge( environment_temporary_directory(), string_from_int_static( random64(), 0, 0 ) );
stream_t* teststream = 0;
if( !fs_is_directory( environment_temporary_directory() ) )
fs_make_directory( environment_temporary_directory() );
if( fs_is_directory( testpath ) )
fs_remove_directory( testpath );
fs_remove_file( testpath );
if( fs_is_directory( copypath ) )
fs_remove_directory( copypath );
fs_remove_file( copypath );
teststream = fs_open_file( testpath, STREAM_IN );
EXPECT_EQ( teststream, 0 );
EXPECT_FALSE( fs_is_file( testpath ) );
teststream = fs_open_file( testpath, STREAM_IN | STREAM_OUT );
EXPECT_NE( teststream, 0 );
EXPECT_TRUE( fs_is_file( testpath ) );
stream_deallocate( teststream );
fs_remove_file( testpath );
teststream = fs_open_file( testpath, STREAM_IN );
EXPECT_EQ( teststream, 0 );
EXPECT_FALSE( fs_is_file( testpath ) );
teststream = fs_open_file( testpath, STREAM_OUT );
EXPECT_NE( teststream, 0 );
EXPECT_TRUE( fs_is_file( testpath ) );
stream_deallocate( teststream );
teststream = 0;
fs_copy_file( testpath, copypath );
EXPECT_TRUE( fs_is_file( copypath ) );
fs_remove_file( copypath );
EXPECT_FALSE( fs_is_file( copypath ) );
teststream = fs_open_file( testpath, STREAM_OUT );
EXPECT_NE( teststream, 0 );
EXPECT_TRUE( fs_is_file( testpath ) );
stream_write_string( teststream, "testing testing" );
stream_deallocate( teststream );
teststream = 0;
fs_copy_file( testpath, copypath );
EXPECT_TRUE( fs_is_file( copypath ) );
fs_remove_file( copypath );
EXPECT_FALSE( fs_is_file( copypath ) );
stream_deallocate( teststream );
string_deallocate( testpath );
string_deallocate( copypath );
return 0;
}
DECLARE_TEST( fs, monitor )
{
char* testpath = path_merge( environment_temporary_directory(), string_from_int_static( random64(), 0, 0 ) );
char* filetestpath = path_merge( testpath, string_from_int_static( random64(), 0, 0 ) );
stream_t* test_stream;
event_stream_t* stream;
event_block_t* block;
event_t* event;
stream = fs_event_stream();
if( fs_is_file( testpath ) )
fs_remove_file( testpath );
if( !fs_is_directory( testpath ) )
fs_make_directory( testpath );
if( fs_is_file( filetestpath ) )
fs_remove_file( filetestpath );
stream_deallocate( fs_open_file( filetestpath, STREAM_OUT ) );
fs_remove_file( filetestpath );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_EQ( event, 0 );
fs_monitor( testpath );
thread_sleep( 1000 );
stream_deallocate( fs_open_file( filetestpath, STREAM_OUT ) );
thread_sleep( 100 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_NE( event, 0 );
EXPECT_EQ( event->system, SYSTEM_FOUNDATION );
EXPECT_EQ( event->id, FOUNDATIONEVENT_FILE_CREATED );
EXPECT_STREQ( event->payload, filetestpath );
event = event_next( block, event );
EXPECT_EQ( event, 0 );
test_stream = fs_open_file( filetestpath, STREAM_IN | STREAM_OUT );
stream_write_string( test_stream, filetestpath );
stream_deallocate( test_stream );
thread_sleep( 100 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_NE( event, 0 );
EXPECT_EQ( event->system, SYSTEM_FOUNDATION );
EXPECT_EQ( event->id, FOUNDATIONEVENT_FILE_MODIFIED );
EXPECT_STREQ( event->payload, filetestpath );
event = event_next( block, event );
EXPECT_EQ( event, 0 );
fs_remove_file( filetestpath );
thread_sleep( 100 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_NE( event, 0 );
EXPECT_EQ( event->system, SYSTEM_FOUNDATION );
EXPECT_EQ( event->id, FOUNDATIONEVENT_FILE_DELETED );
EXPECT_STREQ( event->payload, filetestpath );
event = event_next( block, event );
EXPECT_EQ( event, 0 );
fs_unmonitor( testpath );
thread_sleep( 1000 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_EQ( event, 0 );
stream_deallocate( fs_open_file( filetestpath, STREAM_OUT ) );
thread_sleep( 100 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_EQ( event, 0 );
fs_remove_file( filetestpath );
thread_sleep( 100 );
block = event_stream_process( stream );
event = event_next( block, 0 );
EXPECT_EQ( event, 0 );
fs_remove_directory( testpath );
string_deallocate( testpath );
string_deallocate( filetestpath );
return 0;
}
DECLARE_TEST( fs, query )
{
uint64_t subpathid = random64();
uint64_t subfileid = random64();
char* testpath = path_merge( environment_temporary_directory(), string_from_int_static( random64(), 0, 0 ) );
char* subtestpath = path_merge( testpath, string_from_int_static( subpathid, 0, 0 ) );
char* filepath[8];
char** subdirs;
char** files;
int ifp = 0;
char* subfilepath;
if( fs_is_file( testpath ) )
fs_remove_file( testpath );
if( !fs_is_directory( testpath ) )
fs_make_directory( testpath );
if( !fs_is_directory( subtestpath ) )
fs_make_directory( subtestpath );
for( ifp = 0; ifp < 8; ++ifp )
{
filepath[ifp] = path_merge( testpath, string_from_int_static( random64(), 0, 0 ) );
filepath[ifp] = string_append( string_append( filepath[ifp], "." ), string_from_int_static( ifp, 0, 0 ) );
stream_deallocate( fs_open_file( filepath[ifp], STREAM_OUT ) );
}
subfilepath = path_merge( subtestpath, string_from_int_static( subfileid, 0, 0 ) );
subfilepath = string_append( subfilepath, ".0" );
stream_deallocate( fs_open_file( subfilepath, STREAM_OUT ) );
files = fs_files( filepath[0] );
EXPECT_EQ( array_size( files ), 0 );
string_array_deallocate( files );
subdirs = fs_subdirs( subtestpath );
EXPECT_EQ( array_size( subdirs ), 0 );
string_array_deallocate( subdirs );
files = fs_files( testpath );
EXPECT_EQ( array_size( files ), 8 );
string_array_deallocate( files );
subdirs = fs_subdirs( testpath );
EXPECT_EQ( array_size( subdirs ), 1 );
string_array_deallocate( subdirs );
files = fs_matching_files( testpath, "*", false );
EXPECT_EQ( array_size( files ), 8 );
string_array_deallocate( files );
files = fs_matching_files( testpath, "*", true );
EXPECT_EQ( array_size( files ), 9 );
string_array_deallocate( files );
files = fs_matching_files( testpath, "*.0", false );
EXPECT_EQ( array_size( files ), 1 );
string_array_deallocate( files );
files = fs_matching_files( testpath, "*.0", true );
EXPECT_EQ( array_size( files ), 2 );
string_array_deallocate( files );
files = fs_matching_files( testpath, "*.1", false );
EXPECT_EQ( array_size( files ), 1 );
string_array_deallocate( files );
files = fs_matching_files( testpath, "*.1", true );
EXPECT_EQ( array_size( files ), 1 );
string_array_deallocate( files );
files = fs_matching_files( testpath, "*.?", true );
EXPECT_EQ( array_size( files ), 9 );
{
char* verifypath = string_from_int( subpathid, 0, 0 );
verifypath = path_append( verifypath, string_from_int_static( subfileid, 0, 0 ) );
verifypath = string_append( verifypath, ".0" );
EXPECT_STREQ( files[8], verifypath );
string_deallocate( verifypath );
}
string_array_deallocate( files );
fs_remove_directory( testpath );
string_array_deallocate( subdirs );
string_array_deallocate( files );
string_deallocate( subfilepath );
for( ifp = 0; ifp < 8; ++ifp )
string_deallocate( filepath[ifp] );
string_deallocate( subtestpath );
string_deallocate( testpath );
return 0;
}
void test_file_notification(void**) {
int temp = 1;
const char* test_dir = "t2-output/test_dir";
const char* test_dir_2 = "t2-output/2_test_dir";
const char* test_dir_3 = "t2-output/3_test_dir";
const char* filename_2 = "t2-output/test_dir/test_file_2";
s_filename = "t2-output/test_dir/test_file.dll";
s_filename_2 = "t2-output/2_test_dir/test_file.txt";
s_filename_3 = "t2-output/3_test_dir/test_file.bin";
s_filename_4 = "t2-output/3_test_dir/test_file.so";
s_filename_5 = "t2-output/3_test_dir/test_file.exe";
fs_remove_directory(test_dir);
fs_make_directory(test_dir);
fs_remove_directory(test_dir_2);
fs_make_directory(test_dir_2);
fs_remove_directory(test_dir_3);
fs_make_directory(test_dir_3);
FILE* t = fopen(filename_2, "wb");
fwrite(&temp, 4, 1, t);
fclose(t);
FileMonitor_addPath(test_dir, "*", fileNotifaction, &s_user_data_1);
thread_sleep(200);
// Test notification when writing one file
t = fopen(s_filename, "wb");
fclose(t);
thread_sleep(1000);
FileMonitor_update();
thread_sleep(400);
assert_int_equal(s_checkPhase, 1);
fs_copy_file(filename_2, s_filename);
thread_sleep(1000);
FileMonitor_update();
thread_sleep(400);
assert_int_equal(s_checkPhase, 2);
FileMonitor_addPath(test_dir_2, "txt", fileNotifaction2, &s_user_data_2);
thread_sleep(1000);
fs_copy_file(filename_2, s_filename_2);
thread_sleep(1200);
FileMonitor_update();
assert_int_equal(s_checkPhase, 3);
FileMonitor_removePath(test_dir);
// Except no notifactions for this
fs_remove_file(s_filename);
FileMonitor_update();
thread_sleep(1000);
FileMonitor_update();
thread_sleep(400);
assert_int_equal(s_checkPhase, 3);
FileMonitor_addPath(test_dir_3, "bin;so", fileNotifaction3, &s_user_data_3);
thread_sleep(1000);
fs_copy_file(filename_2, s_filename_3);
thread_sleep(1200);
FileMonitor_update();
assert_int_equal(s_checkPhase, 4);
thread_sleep(1000);
fs_copy_file(filename_2, s_filename_4);
thread_sleep(1200);
FileMonitor_update();
assert_int_equal(s_checkPhase, 5);
thread_sleep(1000);
fs_copy_file(filename_2, s_filename_5);
thread_sleep(1200);
FileMonitor_update();
assert_int_equal(s_checkPhase, 5);
FileMonitor_close();
}
