diff options
Diffstat (limited to 'test/test_fileutils01.cpp')
| -rw-r--r-- | test/test_fileutils01.cpp | 1014 |
1 files changed, 862 insertions, 152 deletions
diff --git a/test/test_fileutils01.cpp b/test/test_fileutils01.cpp index 6a4b4bf..5f5b47b 100644 --- a/test/test_fileutils01.cpp +++ b/test/test_fileutils01.cpp @@ -39,6 +39,103 @@ using namespace jau::fractions_i64_literals; +static constexpr const bool _remove_target_test_dir = true; + +struct visitor_stats { + jau::fs::traverse_options topts; + int total_real; + int total_sym_links_existing; + int total_sym_links_not_existing; + int total_no_access; + int total_not_existing; + size_t total_file_bytes; + int files_real; + int files_sym_link; + int dirs_real; + int dirs_sym_link; + + visitor_stats(jau::fs::traverse_options topts_) + : topts(topts_), + total_real(0), + total_sym_links_existing(0), + total_sym_links_not_existing(0), + total_no_access(0), + total_not_existing(0), + total_file_bytes(0), + files_real(0), + files_sym_link(0), + dirs_real(0), + dirs_sym_link(0) + {} + + void add(const jau::fs::file_stats& element_stats) { + if( element_stats.is_link() ) { + if( element_stats.exists() ) { + total_sym_links_existing++; + } else { + total_sym_links_not_existing++; + } + } else { + total_real++; + } + if( !element_stats.has_access() ) { + total_no_access++; + } + if( !element_stats.exists() ) { + total_not_existing++; + } + if( element_stats.is_file() ) { + if( element_stats.is_link() ) { + files_sym_link++; + if( is_set(topts, jau::fs::traverse_options::follow_symlinks) ) { + total_file_bytes += element_stats.size(); + } + } else { + files_real++; + total_file_bytes += element_stats.size(); + } + } else if( element_stats.is_dir() ) { + if( element_stats.is_link() ) { + dirs_sym_link++; + } else { + dirs_real++; + } + } + } + + std::string to_string() const noexcept { + std::string res; + res += "- traverse_options "+jau::fs::to_string(topts)+"\n"; + res += "- total_real "+std::to_string(total_real)+"\n"; + res += "- total_sym_links_existing "+std::to_string(total_sym_links_existing)+"\n"; + res += "- total_sym_links_not_existing "+std::to_string(total_sym_links_not_existing)+"\n"; + res += "- total_no_access "+std::to_string(total_no_access)+"\n"; + res += "- total_not_existing "+std::to_string(total_not_existing)+"\n"; + res += "- total_file_bytes "+jau::to_decstring(total_file_bytes)+"\n"; + res += "- files_real "+std::to_string(files_real)+"\n"; + res += "- files_sym_link "+std::to_string(files_sym_link)+"\n"; + res += "- dirs_real "+std::to_string(dirs_real)+"\n"; + res += "- dirs_sym_link "+std::to_string(dirs_sym_link)+"\n"; + return res; + } +}; + +constexpr bool operator ==(const visitor_stats& lhs, const visitor_stats& rhs) noexcept { + return lhs.total_file_bytes == rhs.total_file_bytes && + lhs.total_real == rhs.total_real && + lhs.total_sym_links_existing == rhs.total_sym_links_existing && + lhs.total_sym_links_not_existing == rhs.total_sym_links_not_existing && + lhs.total_no_access == rhs.total_no_access && + lhs.total_not_existing == rhs.total_not_existing && + lhs.files_real == rhs.files_real && + lhs.files_sym_link == rhs.files_sym_link && + lhs.dirs_real == rhs.dirs_real && + lhs.dirs_sym_link == rhs.dirs_sym_link; +} +constexpr bool operator !=(const visitor_stats& lhs, const visitor_stats& rhs) noexcept { + return !( lhs == rhs ); +} + class TestFileUtil01 { public: const std::string root = "test_data"; @@ -46,14 +143,223 @@ class TestFileUtil01 { const std::string project_root1 = "../../test_data"; // submodule location with jaulib directly hosted below main project const std::string project_root2 = "../../../jaulib/test_data"; + // external filesystem to test ... + const std::string project_root_ext = "/mnt/ssd0/data/test_data"; + + /** + * + */ + void test01_cwd() { + const std::string cwd = jau::fs::get_cwd(); + INFO_STR("\n\ntest01_cwd: cwd "+cwd+"\n"); + REQUIRE( 0 < cwd.size() ); + const size_t idx = cwd.find("/jaulib/"); + REQUIRE( 0 < idx ); + REQUIRE( idx < cwd.size() ); + REQUIRE( idx != std::string::npos ); + } + + /** + * + */ + void test02_dirname() { + { + const std::string pathname0 = "/"; + const std::string pathname1 = jau::fs::dirname(pathname0); + INFO_STR("\n\ntest02_dirname: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "/" ); + } + { + { + const std::string pathname0 = "lala.txt"; + const std::string pathname1 = jau::fs::dirname(pathname0); + INFO_STR("\n\ntest02_dirname: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "." ); + } + { + const std::string pathname0 = "lala"; + const std::string pathname1 = jau::fs::dirname(pathname0); + INFO_STR("\n\ntest02_dirname: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "." ); + } + { + const std::string pathname0 = "lala/"; + const std::string pathname1 = jau::fs::dirname(pathname0); + INFO_STR("\n\ntest02_dirname: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "." ); + } + } + { + const std::string pathname0 = "blabla/jaulib/test/sub.txt"; + const std::string pathname1 = jau::fs::dirname(pathname0); + INFO_STR("\n\ntest02_dirname: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "blabla/jaulib/test" ); + } + { + const std::string pathname0 = "blabla/jaulib/test/sub"; + const std::string pathname1 = jau::fs::dirname(pathname0); + INFO_STR("\n\ntest02_dirname: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "blabla/jaulib/test" ); + } + { + const std::string pathname0 = "blabla/jaulib/test/"; + const std::string pathname1 = jau::fs::dirname(pathname0); + INFO_STR("\n\ntest02_dirname: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "blabla/jaulib" ); + } + { + const std::string pathname0 = "blabla/jaulib/test"; + const std::string pathname1 = jau::fs::dirname(pathname0); + INFO_STR("\n\ntest02_dirname: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "blabla/jaulib" ); + } + } + + void test03_basename() { + { + const std::string pathname0 = "/"; + const std::string pathname1 = jau::fs::basename(pathname0); + INFO_STR("\n\ntest03_basename: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "/" ); + } + { + { + const std::string pathname0 = "lala.txt"; + const std::string pathname1 = jau::fs::basename(pathname0); + INFO_STR("\n\ntest03_basename: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "lala.txt" ); + } + { + const std::string pathname0 = "lala"; + const std::string pathname1 = jau::fs::basename(pathname0); + INFO_STR("\n\ntest03_basename: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "lala" ); + } + { + const std::string pathname0 = "lala/"; + const std::string pathname1 = jau::fs::basename(pathname0); + INFO_STR("\n\ntest03_basename: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "lala" ); + } + } + { + const std::string pathname0 = "blabla/jaulib/test/sub.txt"; + const std::string pathname1 = jau::fs::basename(pathname0); + INFO_STR("\n\ntest03_basename: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "sub.txt" ); + } + + { + const std::string pathname0 = "blabla/jaulib/test/"; + const std::string pathname1 = jau::fs::basename(pathname0); + INFO_STR("\n\ntest03_basename: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "test" ); + } + + { + const std::string pathname0 = "blabla/jaulib/test"; + const std::string pathname1 = jau::fs::basename(pathname0); + INFO_STR("\n\ntest03_basename: cwd "+pathname0+" -> "+pathname1+"\n"); + REQUIRE( 0 < pathname1.size() ); + REQUIRE( pathname1 == "test" ); + } + } + + void test04_file_stat() { + INFO_STR("\n\ntest04_file_stat\n"); + + { + jau::fs::file_stats stats(project_root_ext+"/file_01.txt"); + jau::fprintf_td(stderr, "test04_file_stat: 01: %s\n", stats.to_string().c_str()); + jau::fprintf_td(stderr, "test04_file_stat: 01: fields %s\n", jau::fs::to_string( stats.fields() ).c_str()); + if( stats.exists() ) { + REQUIRE( stats.has_access() ); + REQUIRE( !stats.is_dir() ); + REQUIRE( stats.is_file() ); + REQUIRE( !stats.is_link() ); + REQUIRE( 15 == stats.size() ); + } + } + + jau::fs::file_stats proot_stats(project_root1); + if( !proot_stats.exists() ) { + proot_stats = jau::fs::file_stats(project_root2); + } + jau::fprintf_td(stderr, "test04_file_stat: 11: %s\n", proot_stats.to_string().c_str()); + jau::fprintf_td(stderr, "test04_file_stat: 11: fields %s\n", jau::fs::to_string( proot_stats.fields() ).c_str()); + REQUIRE( true == proot_stats.exists() ); + REQUIRE( true == proot_stats.is_dir() ); + + { + jau::fs::file_stats stats(proot_stats.path()+"/file_01.txt"); + jau::fprintf_td(stderr, "test04_file_stat: 12: %s\n", stats.to_string().c_str()); + jau::fprintf_td(stderr, "test04_file_stat: 12: fields %s\n", jau::fs::to_string( stats.fields() ).c_str()); + REQUIRE( stats.exists() ); + REQUIRE( stats.has_access() ); + REQUIRE( !stats.is_dir() ); + REQUIRE( stats.is_file() ); + REQUIRE( !stats.is_link() ); + REQUIRE( 15 == stats.size() ); + } + { + jau::fs::file_stats stats(proot_stats.path()+"/file_01_slink01.txt"); + jau::fprintf_td(stderr, "test04_file_stat: 13: %s\n", stats.to_string().c_str()); + jau::fprintf_td(stderr, "test04_file_stat: 13: fields %s\n", jau::fs::to_string( stats.fields() ).c_str()); + if( stats.is_link() ) { + jau::fprintf_td(stderr, "test04_file_stat: 13: link_target %s\n", stats.link_target()->to_string().c_str()); + } + REQUIRE( stats.exists() ); + REQUIRE( stats.has_access() ); + REQUIRE( !stats.is_dir() ); + REQUIRE( stats.is_file() ); + REQUIRE( stats.is_link() ); + REQUIRE( 15 == stats.size() ); + REQUIRE( nullptr != stats.link_target() ); + const jau::fs::file_stats* link_target = stats.link_target().get(); + REQUIRE( nullptr != link_target ); + REQUIRE( "file_01.txt" == link_target->path() ); + } + { + jau::fs::file_stats stats(proot_stats.path()+"/fstab_slink07_absolute"); + jau::fprintf_td(stderr, "test04_file_stat: 14: %s\n", stats.to_string().c_str()); + jau::fprintf_td(stderr, "test04_file_stat: 14: fields %s\n", jau::fs::to_string( stats.fields() ).c_str()); + if( stats.is_link() ) { + jau::fprintf_td(stderr, "test04_file_stat: 14: link_target %s\n", stats.link_target()->to_string().c_str()); + } + REQUIRE( stats.exists() ); + REQUIRE( stats.has_access() ); + REQUIRE( !stats.is_dir() ); + REQUIRE( stats.is_file() ); + REQUIRE( stats.is_link() ); + REQUIRE( 20 < stats.size() ); // greater than basename + REQUIRE( nullptr != stats.link_target() ); + const jau::fs::file_stats* link_target = stats.link_target().get(); + REQUIRE( nullptr != link_target ); + REQUIRE( "/etc/fstab" == link_target->path() ); + } + } /** * */ - void test01_mkdir() { - INFO_STR("\n\ntest01_mkdir\n"); + void test10_mkdir() { + INFO_STR("\n\ntest10_mkdir\n"); - jau::fs::remove(root, true); // start fresh + jau::fs::remove(root, jau::fs::traverse_options::recursive); // start fresh { jau::fs::file_stats root_stats(root); INFO_STR("root_stats.pre: "+root_stats.to_string(true)+"\n"); @@ -63,7 +369,7 @@ class TestFileUtil01 { REQUIRE( !root_stats.is_file() ); REQUIRE( !root_stats.is_link() ); } - REQUIRE( true == jau::fs::mkdir(root) ); + REQUIRE( true == jau::fs::mkdir(root, jau::fs::fmode_t::def_dir_prot) ); { jau::fs::file_stats root_stats(root); INFO_STR("root_stats.post: "+root_stats.to_string(true)+"\n"); @@ -73,15 +379,15 @@ class TestFileUtil01 { REQUIRE( !root_stats.is_file() ); REQUIRE( !root_stats.is_link() ); } - REQUIRE( false == jau::fs::remove(root, false) ); - REQUIRE( true == jau::fs::remove(root, true) ); + REQUIRE( false == jau::fs::remove(root, jau::fs::traverse_options::none) ); + REQUIRE( true == jau::fs::remove(root, jau::fs::traverse_options::recursive) ); } - void test02_touch() { - INFO_STR("\n\ntest02_touch\n"); + void test11_touch() { + INFO_STR("\n\ntest11_touch\n"); const std::string file_01 = root+"/data01.txt"; const std::string file_02 = root+"/data02.txt"; - REQUIRE( true == jau::fs::mkdir(root) ); + REQUIRE( true == jau::fs::mkdir(root, jau::fs::fmode_t::def_dir_prot) ); { jau::fs::file_stats root_stats(root); INFO_STR("root_stats1.post: "+root_stats.to_string(true)+"\n"); @@ -92,7 +398,7 @@ class TestFileUtil01 { REQUIRE( !root_stats.is_link() ); } - REQUIRE( true == jau::fs::touch(file_01) ); + REQUIRE( true == jau::fs::touch(file_01, jau::fs::fmode_t::def_file_prot) ); { jau::fs::file_stats file_stats(file_01); INFO_STR("file_stats2.post: "+file_stats.to_string(true)+"\n"); @@ -103,40 +409,61 @@ class TestFileUtil01 { REQUIRE( !file_stats.is_link() ); } - const jau::fraction_timespec atime = jau::getWallClockTime(); - const jau::fraction_timespec ts_20200101( 1577836800_s + 0_h); // 2020-01-01 00:00:00 - const jau::fraction_timespec mtime( ts_20200101 + 31_d + 10_h ); - INFO_STR("atime.pre: "+atime.to_iso8601_string(true)+", "+atime.to_string()+"\n"); - INFO_STR("mtime.pre: "+mtime.to_iso8601_string(true)+", "+mtime.to_string()+"\n"); - REQUIRE( true == jau::fs::touch(file_02, atime, mtime) ); { - jau::fs::file_stats file_stats(file_02); - INFO_STR("file_stats3.post: "+file_stats.to_string(true)+"\n"); - REQUIRE( file_stats.exists() ); - REQUIRE( file_stats.has_access() ); - REQUIRE( !file_stats.is_dir() ); - REQUIRE( file_stats.is_file() ); - REQUIRE( !file_stats.is_link() ); - REQUIRE( atime == file_stats.atime() ); - REQUIRE( mtime == file_stats.mtime() ); + REQUIRE( true == jau::fs::touch(file_02, jau::fs::fmode_t::def_file_prot) ); + jau::fs::file_stats file_stats_pre(file_02); + const jau::fraction_timespec btime_pre = file_stats_pre.btime(); + const jau::fraction_timespec atime_pre = file_stats_pre.atime(); + const jau::fraction_timespec mtime_pre = file_stats_pre.mtime(); + INFO_STR("btime.pre: "+btime_pre.to_iso8601_string(true)+", "+btime_pre.to_string()+"\n"); + INFO_STR("atime.pre: "+atime_pre.to_iso8601_string(true)+", "+atime_pre.to_string()+"\n"); + INFO_STR("mtime.pre: "+mtime_pre.to_iso8601_string(true)+", "+mtime_pre.to_string()+"\n"); + + const jau::fraction_timespec ts_20200101( 1577836800_s + 0_h); // 2020-01-01 00:00:00 + const jau::fraction_timespec atime_set( ts_20200101 + 1_d + 10_h ); + const jau::fraction_timespec mtime_set( ts_20200101 + 31_d + 10_h ); + INFO_STR("atime.set: "+atime_set.to_iso8601_string(true)+", "+atime_set.to_string()+"\n"); + INFO_STR("mtime.set: "+mtime_set.to_iso8601_string(true)+", "+mtime_set.to_string()+"\n"); + REQUIRE( true == jau::fs::touch(file_02, atime_set, mtime_set, jau::fs::fmode_t::def_file_prot) ); + + jau::fs::file_stats file_stats_post(file_02); + const jau::fraction_timespec atime_post = file_stats_post.atime(); + const jau::fraction_timespec mtime_post = file_stats_post.mtime(); + INFO_STR("atime.post: "+atime_post.to_iso8601_string(true)+", "+atime_post.to_string()+"\n"); + INFO_STR("mtime.post: "+mtime_post.to_iso8601_string(true)+", "+mtime_post.to_string()+"\n"); + jau::fprintf_td(stderr, "test11_touch: 03: %s\n", file_stats_post.to_string().c_str()); + { + REQUIRE( file_stats_post.exists() ); + REQUIRE( file_stats_post.has_access() ); + REQUIRE( !file_stats_post.is_dir() ); + REQUIRE( file_stats_post.is_file() ); + REQUIRE( !file_stats_post.is_link() ); + if( file_stats_post.has( jau::fs::file_stats::field_t::atime ) ) { + REQUIRE( atime_set == file_stats_post.atime() ); + } + if( file_stats_post.has( jau::fs::file_stats::field_t::mtime ) ) { + REQUIRE( mtime_set == file_stats_post.mtime() ); + } + } } - REQUIRE( true == jau::fs::remove(root, true) ); + REQUIRE( true == jau::fs::remove(root, jau::fs::traverse_options::recursive) ); } - void test03_visit() { - INFO_STR("\n\ntest03_visit\n"); + + void test20_visit() { + INFO_STR("\n\ntest20_visit\n"); std::string sub_dir1 = root+"/sub1"; std::string sub_dir2 = root+"/sub2"; std::string sub_dir3 = root+"/sub1/sub3"; - REQUIRE( true == jau::fs::mkdir(root) ); + REQUIRE( true == jau::fs::mkdir(root, jau::fs::fmode_t::def_dir_prot) ); REQUIRE( true == jau::fs::touch(root+"/data01.txt") ); REQUIRE( true == jau::fs::touch(root+"/data02.txt") ); - REQUIRE( true == jau::fs::mkdir(sub_dir1) ); - REQUIRE( true == jau::fs::mkdir(sub_dir2) ); - REQUIRE( true == jau::fs::mkdir(sub_dir3) ); + REQUIRE( true == jau::fs::mkdir(sub_dir1, jau::fs::fmode_t::def_dir_prot) ); + REQUIRE( true == jau::fs::mkdir(sub_dir2, jau::fs::fmode_t::def_dir_prot) ); + REQUIRE( true == jau::fs::mkdir(sub_dir3, jau::fs::fmode_t::def_dir_prot) ); REQUIRE( true == jau::fs::touch(sub_dir1+"/data03.txt") ); REQUIRE( true == jau::fs::touch(sub_dir1+"/data04.txt") ); REQUIRE( true == jau::fs::touch(sub_dir2+"/data05.txt") ); @@ -144,55 +471,53 @@ class TestFileUtil01 { REQUIRE( true == jau::fs::touch(sub_dir3+"/data07.txt") ); REQUIRE( true == jau::fs::touch(sub_dir3+"/data08.txt") ); - struct visitor_stats { - int total; - int files; - int dirs; - int sym_links; - }; - visitor_stats stats { 0, 0, 0, 0 }; - const jau::fs::path_visitor pv = jau::bindCaptureRefFunc(&stats, - ( bool(*)(visitor_stats*, const jau::fs::file_stats&) ) /* help template type deduction of function-ptr */ - ( [](visitor_stats* stats_ptr, const jau::fs::file_stats& element_stats) -> bool { - stats_ptr->total++; - jau::fprintf_td(stderr, "test_03_visit: %d: %s\n", stats_ptr->total, element_stats.to_string(true).c_str()); - if( !element_stats.has_access() ) { - return false; - } - if( element_stats.is_link() ) { - stats_ptr->sym_links++; - } - if( element_stats.is_file() ) { - stats_ptr->files++; - } else if( element_stats.is_dir() ) { - stats_ptr->dirs++; - } - return true; - } ) ); - REQUIRE( true == jau::fs::visit(root, true /* follow_sym_link_dirs */, pv) ); - REQUIRE( 12 == stats.total ); - REQUIRE( 8 == stats.files ); - REQUIRE( 4 == stats.dirs ); - REQUIRE( 0 == stats.sym_links ); - - REQUIRE( true == jau::fs::remove(root, true) ); - } + const jau::fs::traverse_options topts_R_FSL_PDL = jau::fs::traverse_options::recursive | + jau::fs::traverse_options::follow_symlinks | + jau::fs::traverse_options::dir_exit; + visitor_stats stats_R_FSL_PDL(topts_R_FSL_PDL); + { + const jau::fs::path_visitor pv = jau::bindCaptureRefFunc(&stats_R_FSL_PDL, + ( bool(*)(visitor_stats*, jau::fs::traverse_event, const jau::fs::file_stats&) ) /* help template type deduction of function-ptr */ + ( [](visitor_stats* stats_ptr, jau::fs::traverse_event tevt, const jau::fs::file_stats& element_stats) -> bool { + (void)tevt; + stats_ptr->add(element_stats); + return true; + } ) ); + REQUIRE( true == jau::fs::visit(root, topts_R_FSL_PDL, pv) ); + jau::fprintf_td(stderr, "test20_visit[R, FSL, PDL]: %s\n%s\n", to_string(topts_R_FSL_PDL).c_str(), stats_R_FSL_PDL.to_string().c_str()); + REQUIRE( 12 == stats_R_FSL_PDL.total_real ); + REQUIRE( 0 == stats_R_FSL_PDL.total_sym_links_existing ); + REQUIRE( 0 == stats_R_FSL_PDL.total_sym_links_not_existing ); + REQUIRE( 0 == stats_R_FSL_PDL.total_no_access ); + REQUIRE( 0 == stats_R_FSL_PDL.total_not_existing ); + REQUIRE( 0 == stats_R_FSL_PDL.total_file_bytes ); + REQUIRE( 8 == stats_R_FSL_PDL.files_real ); + REQUIRE( 0 == stats_R_FSL_PDL.files_sym_link ); + REQUIRE( 4 == stats_R_FSL_PDL.dirs_real ); + REQUIRE( 0 == stats_R_FSL_PDL.dirs_sym_link ); + } + const jau::fs::traverse_options topts_R_FSL = jau::fs::traverse_options::recursive | + jau::fs::traverse_options::follow_symlinks | + jau::fs::traverse_options::dir_entry; + visitor_stats stats_R_FSL(topts_R_FSL); + { + const jau::fs::path_visitor pv = jau::bindCaptureRefFunc(&stats_R_FSL, + ( bool(*)(visitor_stats*, jau::fs::traverse_event, const jau::fs::file_stats&) ) /* help template type deduction of function-ptr */ + ( [](visitor_stats* stats_ptr, jau::fs::traverse_event tevt, const jau::fs::file_stats& element_stats) -> bool { + (void)tevt; + stats_ptr->add(element_stats); + return true; + } ) ); + REQUIRE( true == jau::fs::visit(root, topts_R_FSL, pv) ); + jau::fprintf_td(stderr, "test20_visit[R, FSL]: %s\n%s\n", to_string(topts_R_FSL).c_str(), stats_R_FSL.to_string().c_str()); + REQUIRE( stats_R_FSL_PDL == stats_R_FSL ); + } - /** - * - */ - void test04_cwd() { - const std::string cwd = jau::fs::get_cwd(); - INFO_STR("\n\ntest04_cwd: cwd "+cwd+"\n"); - REQUIRE( 0 < cwd.size() ); - const size_t idx = cwd.find("/jaulib/"); - REQUIRE( 0 < idx ); - REQUIRE( idx < cwd.size() ); - REQUIRE( idx != std::string::npos ); + REQUIRE( true == jau::fs::remove(root, jau::fs::traverse_options::recursive) ); } - void test04_symlink_file() { - INFO_STR("\n\ntest04_symlink_file\n"); + void test21_symlink_file() { + INFO_STR("\n\ntest21_symlink_file\n"); jau::fs::file_stats proot_stats(project_root1); if( !proot_stats.exists() ) { @@ -203,15 +528,15 @@ class TestFileUtil01 { INFO_STR("project_root "+proot_stats.to_string(true)+"\n"); REQUIRE( true == proot_stats.is_dir() ); - jau::fs::file_stats file_01_link_stats(proot_stats.path()+"/file_01_slink.txt"); + jau::fs::file_stats file_01_link_stats(proot_stats.path()+"/file_01_slink01.txt"); INFO_STR("project_root "+file_01_link_stats.to_string(true)+"\n"); REQUIRE( true == file_01_link_stats.is_link() ); REQUIRE( true == file_01_link_stats.is_file() ); REQUIRE( 15 == file_01_link_stats.size() ); } - void test05_visit_symlinks() { - INFO_STR("\n\ntest05_visit_symlinks\n"); + void test22_visit_symlinks() { + INFO_STR("\n\ntest22_visit_symlinks\n"); jau::fs::file_stats proot_stats(project_root1); if( !proot_stats.exists() ) { @@ -219,99 +544,484 @@ class TestFileUtil01 { } REQUIRE( true == proot_stats.exists() ); - struct visitor_stats { - int total_real; - int total_sym_link; - int files_real; - int files_sym_link; - int dirs_real; - int dirs_sym_link; - }; { - visitor_stats stats { 0, 0, 0, 0, 0, 0 }; + const jau::fs::traverse_options topts = jau::fs::traverse_options::recursive | + jau::fs::traverse_options::dir_entry; + visitor_stats stats(topts); const jau::fs::path_visitor pv = jau::bindCaptureRefFunc(&stats, - ( bool(*)(visitor_stats*, const jau::fs::file_stats&) ) /* help template type deduction of function-ptr */ - ( [](visitor_stats* stats_ptr, const jau::fs::file_stats& element_stats) -> bool { - if( element_stats.is_link() ) { - stats_ptr->total_sym_link++; - } else { - stats_ptr->total_real++; - } - jau::fprintf_td(stderr, "test05_visit_symlinks: total[real %d, symlink %d]: %s\n", - stats_ptr->total_real, stats_ptr->total_sym_link, element_stats.to_string(true).c_str()); - if( !element_stats.has_access() ) { - return false; - } - if( element_stats.is_file() ) { - if( element_stats.is_link() ) { - stats_ptr->files_sym_link++; - } else { - stats_ptr->files_real++; - } - } else if( element_stats.is_dir() ) { - if( element_stats.is_link() ) { - stats_ptr->dirs_sym_link++; - } else { - stats_ptr->dirs_real++; - } - } + ( bool(*)(visitor_stats*, jau::fs::traverse_event, const jau::fs::file_stats&) ) /* help template type deduction of function-ptr */ + ( [](visitor_stats* stats_ptr, jau::fs::traverse_event tevt, const jau::fs::file_stats& element_stats) -> bool { + (void)tevt; + stats_ptr->add(element_stats); return true; } ) ); - REQUIRE( true == jau::fs::visit(proot_stats, false /* follow_sym_link_dirs */, pv) ); + REQUIRE( true == jau::fs::visit(proot_stats, topts, pv) ); + jau::fprintf_td(stderr, "test22_visit[R]: %s\n%s\n", to_string(topts).c_str(), stats.to_string().c_str()); REQUIRE( 7 == stats.total_real ); - REQUIRE( 3 == stats.total_sym_link ); + REQUIRE( 8 == stats.total_sym_links_existing ); + REQUIRE( 0 == stats.total_sym_links_not_existing ); + REQUIRE( 0 == stats.total_no_access ); + REQUIRE( 0 == stats.total_not_existing ); + REQUIRE( 60 == stats.total_file_bytes ); REQUIRE( 4 == stats.files_real ); - REQUIRE( 3 == stats.files_sym_link ); + REQUIRE( 7 == stats.files_sym_link ); REQUIRE( 3 == stats.dirs_real ); - REQUIRE( 0 == stats.dirs_sym_link ); + REQUIRE( 1 == stats.dirs_sym_link ); } { - visitor_stats stats { 0, 0, 0, 0, 0, 0 }; + const jau::fs::traverse_options topts = jau::fs::traverse_options::recursive | + jau::fs::traverse_options::dir_entry | + jau::fs::traverse_options::follow_symlinks; + visitor_stats stats(topts); const jau::fs::path_visitor pv = jau::bindCaptureRefFunc(&stats, - ( bool(*)(visitor_stats*, const jau::fs::file_stats&) ) /* help template type deduction of function-ptr */ - ( [](visitor_stats* stats_ptr, const jau::fs::file_stats& element_stats) -> bool { - if( element_stats.is_link() ) { - stats_ptr->total_sym_link++; + ( bool(*)(visitor_stats*, jau::fs::traverse_event, const jau::fs::file_stats&) ) /* help template type deduction of function-ptr */ + ( [](visitor_stats* stats_ptr, jau::fs::traverse_event tevt, const jau::fs::file_stats& element_stats) -> bool { + (void)tevt; + stats_ptr->add(element_stats); + return true; + } ) ); + REQUIRE( true == jau::fs::visit(proot_stats, topts, pv) ); + jau::fprintf_td(stderr, "test22_visit[R, FSL]: %s\n%s\n", to_string(topts).c_str(), stats.to_string().c_str()); + REQUIRE( 9 == stats.total_real ); + REQUIRE( 9 == stats.total_sym_links_existing ); + REQUIRE( 0 == stats.total_sym_links_not_existing ); + REQUIRE( 0 == stats.total_no_access ); + REQUIRE( 0 == stats.total_not_existing ); + REQUIRE( 60 < stats.total_file_bytes ); // some followed symlink files are of unknown size, e.g. /etc/fstab + REQUIRE( 6 == stats.files_real ); + REQUIRE( 8 == stats.files_sym_link ); + REQUIRE( 3 == stats.dirs_real ); + REQUIRE( 1 == stats.dirs_sym_link ); + } + } + + void test30_copy_file2dir() { + INFO_STR("\n\ntest30_copy_file2dir\n"); + + jau::fs::file_stats root_orig_stats(project_root1); + if( !root_orig_stats.exists() ) { + root_orig_stats = jau::fs::file_stats(project_root2); + } + REQUIRE( true == root_orig_stats.exists() ); + + const std::string root_copy = root+"_copy_test30"; + { + // Fresh target folder + jau::fs::remove(root_copy, jau::fs::traverse_options::recursive); + + REQUIRE( true == jau::fs::mkdir(root_copy, jau::fs::fmode_t::def_dir_prot) ); + { + jau::fs::file_stats stats(root_copy); + REQUIRE( true == stats.exists() ); + REQUIRE( true == stats.ok() ); + REQUIRE( true == stats.is_dir() ); + } + } + jau::fs::file_stats source1_stats(root_orig_stats.path()+"/file_01.txt"); + jau::fprintf_td(stderr, "test30_copy_file2dir: source1: %s\n", source1_stats.to_string().c_str()); + { + REQUIRE( true == source1_stats.exists() ); + REQUIRE( true == source1_stats.ok() ); + REQUIRE( true == source1_stats.is_file() ); + } + { + // Copy file to folder + const jau::fs::copy_options copts = jau::fs::copy_options::preserve_all | + jau::fs::copy_options::verbose; + { + jau::fs::file_stats dest_stats(root_copy+"/file_01.txt"); + jau::fprintf_td(stderr, "test30_copy_file2dir: 01: dest.pre: %s\n", dest_stats.to_string().c_str()); + REQUIRE( false == dest_stats.exists() ); + } + REQUIRE( true == jau::fs::copy(source1_stats.path(), root_copy, copts) ); + { + jau::fs::file_stats dest_stats(root_copy+"/file_01.txt"); + jau::fprintf_td(stderr, "test30_copy_file2dir: 01: dest.post: %s\n", dest_stats.to_string().c_str()); + REQUIRE( true == dest_stats.exists() ); + REQUIRE( true == dest_stats.ok() ); + REQUIRE( true == dest_stats.is_file() ); + REQUIRE( source1_stats.size() == dest_stats.size() ); + REQUIRE( source1_stats.mode() == dest_stats.mode() ); + } + } + { + // Error: already exists of 'Copy file to folder' + const jau::fs::copy_options copts = jau::fs::copy_options::preserve_all | + jau::fs::copy_options::verbose; + { + jau::fs::file_stats dest_stats(root_copy+"/file_01.txt"); + jau::fprintf_td(stderr, "test30_copy_file2dir: 02: dest.pre: %s\n", dest_stats.to_string().c_str()); + REQUIRE( true == dest_stats.exists() ); + REQUIRE( true == dest_stats.ok() ); + REQUIRE( true == dest_stats.is_file() ); + } + REQUIRE( false == jau::fs::copy(source1_stats.path(), root_copy, copts) ); + } + { + // Overwrite copy file to folder + const jau::fs::copy_options copts = jau::fs::copy_options::preserve_all | + jau::fs::copy_options::overwrite | + jau::fs::copy_options::verbose; + + jau::fprintf_td(stderr, "test30_copy_file2dir: 03: source: %s\n", source1_stats.to_string().c_str()); + { + jau::fs::file_stats dest_stats(root_copy+"/file_01.txt"); + jau::fprintf_td(stderr, "test30_copy_file2dir: 03: dest.pre: %s\n", dest_stats.to_string().c_str()); + REQUIRE( true == dest_stats.exists() ); + REQUIRE( true == dest_stats.ok() ); + REQUIRE( true == dest_stats.is_file() ); + REQUIRE( source1_stats.size() == dest_stats.size() ); + REQUIRE( source1_stats.mode() == dest_stats.mode() ); + } + REQUIRE( true == jau::fs::copy(source1_stats.path(), root_copy, copts) ); + { + jau::fs::file_stats dest_stats(root_copy+"/file_01.txt"); + jau::fprintf_td(stderr, "test30_copy_file2dir: 03: dest.post: %s\n", dest_stats.to_string().c_str()); + REQUIRE( true == dest_stats.exists() ); + REQUIRE( true == dest_stats.ok() ); + REQUIRE( true == dest_stats.is_file() ); + REQUIRE( source1_stats.size() == dest_stats.size() ); + REQUIRE( source1_stats.mode() == dest_stats.mode() ); + } + } + if constexpr ( _remove_target_test_dir ) { + REQUIRE( true == jau::fs::remove(root_copy, jau::fs::traverse_options::recursive) ); + } + } + + void test31_copy_file2file() { + INFO_STR("\n\ntest31_copy_file2file\n"); + + jau::fs::file_stats root_orig_stats(project_root1); + if( !root_orig_stats.exists() ) { + root_orig_stats = jau::fs::file_stats(project_root2); + } + REQUIRE( true == root_orig_stats.exists() ); + + const std::string root_copy = root+"_copy_test31"; + { + // Fresh target folder + jau::fs::remove(root_copy, jau::fs::traverse_options::recursive); + + REQUIRE( true == jau::fs::mkdir(root_copy, jau::fs::fmode_t::def_dir_prot) ); + { + jau::fs::file_stats stats(root_copy); + REQUIRE( true == stats.exists() ); + REQUIRE( true == stats.ok() ); + REQUIRE( true == stats.is_dir() ); + } + } + jau::fs::file_stats source1_stats(root_orig_stats.path()+"/file_01.txt"); + jau::fprintf_td(stderr, "test31_copy_file2file: source1: %s\n", source1_stats.to_string().c_str()); + { + REQUIRE( true == source1_stats.exists() ); + REQUIRE( true == source1_stats.ok() ); + REQUIRE( true == source1_stats.is_file() ); + } + jau::fs::file_stats source2_stats(root_orig_stats.path()+"/README_slink08_relext.txt"); + jau::fprintf_td(stderr, "test30_copy_file2dir: source2: %s\n", source2_stats.to_string().c_str()); + { + REQUIRE( true == source2_stats.exists() ); + REQUIRE( true == source2_stats.ok() ); + REQUIRE( true == source2_stats.is_file() ); + REQUIRE( true == source2_stats.is_link() ); + } + { + // Copy file to new file-name + const jau::fs::copy_options copts = jau::fs::copy_options::preserve_all | + jau::fs::copy_options::verbose; + { + jau::fs::file_stats dest_stats(root_copy+"/file_10.txt"); + jau::fprintf_td(stderr, "test31_copy_file2file: 10: dest.pre: %s\n", dest_stats.to_string().c_str()); + REQUIRE( false == dest_stats.exists() ); + } + REQUIRE( true == jau::fs::copy(source1_stats.path(), root_copy+"/file_10.txt", copts) ); + { + jau::fs::file_stats dest_stats(root_copy+"/file_10.txt"); + jau::fprintf_td(stderr, "test31_copy_file2file: 10: dest.post: %s\n", dest_stats.to_string().c_str()); + REQUIRE( true == dest_stats.exists() ); + REQUIRE( true == dest_stats.ok() ); + REQUIRE( true == dest_stats.is_file() ); + REQUIRE( source1_stats.size() == dest_stats.size() ); + REQUIRE( source1_stats.mode() == dest_stats.mode() ); + } + } + { + // Error: already exists of 'Copy file to file' + const jau::fs::copy_options copts = jau::fs::copy_options::preserve_all | + jau::fs::copy_options::verbose; + { + jau::fs::file_stats dest_stats(root_copy+"/file_10.txt"); + jau::fprintf_td(stderr, "test30_copy_file2dir: 11: dest.pre: %s\n", dest_stats.to_string().c_str()); + REQUIRE( true == dest_stats.exists() ); + REQUIRE( true == dest_stats.ok() ); + REQUIRE( true == dest_stats.is_file() ); + } + REQUIRE( false == jau::fs::copy(source1_stats.path(), root_copy+"/file_10.txt", copts) ); + } + { + // Overwrite copy file to file + const jau::fs::copy_options copts = jau::fs::copy_options::preserve_all | + jau::fs::copy_options::overwrite | + jau::fs::copy_options::follow_symlinks | + jau::fs::copy_options::verbose; + + { + jau::fs::file_stats dest_stats(root_copy+"/file_10.txt"); + jau::fprintf_td(stderr, "test30_copy_file2dir: 12: dest.pre: %s\n", dest_stats.to_string().c_str()); + REQUIRE( true == dest_stats.exists() ); + REQUIRE( true == dest_stats.ok() ); + REQUIRE( true == dest_stats.is_file() ); + REQUIRE( source1_stats.size() == dest_stats.size() ); + REQUIRE( source1_stats.mode() == dest_stats.mode() ); + } + REQUIRE( true == jau::fs::copy(source2_stats.path(), root_copy+"/file_10.txt", copts) ); + { + jau::fs::file_stats dest_stats(root_copy+"/file_10.txt"); + jau::fprintf_td(stderr, "test30_copy_file2dir: 12: dest.post: %s\n", dest_stats.to_string().c_str()); + REQUIRE( true == dest_stats.exists() ); + REQUIRE( true == dest_stats.ok() ); + REQUIRE( true == dest_stats.is_file() ); + REQUIRE( false == dest_stats.is_link() ); + REQUIRE( source2_stats.size() == dest_stats.size() ); + REQUIRE( source2_stats.link_target()->prot_mode() == dest_stats.prot_mode() ); + } + } + if constexpr ( _remove_target_test_dir ) { + REQUIRE( true == jau::fs::remove(root_copy, jau::fs::traverse_options::recursive) ); + } + } + + void test40_copy_ext_r_p() { + INFO_STR("\n\ntest40_copy_ext_r_p\n"); + + jau::fs::file_stats root_orig_stats(project_root1); + if( !root_orig_stats.exists() ) { + root_orig_stats = jau::fs::file_stats(project_root2); + } + REQUIRE( true == root_orig_stats.exists() ); + + const std::string root_copy = root+"_copy_test40"; + const jau::fs::copy_options copts = jau::fs::copy_options::recursive | + jau::fs::copy_options::preserve_all | + jau::fs::copy_options::sync | + jau::fs::copy_options::verbose; + { + jau::fs::remove(root_copy, jau::fs::traverse_options::recursive); + + REQUIRE( true == jau::fs::copy(root_orig_stats.path(), root_copy, copts) ); + } + jau::fs::file_stats root_copy_stats(root_copy); + REQUIRE( true == root_copy_stats.exists() ); + REQUIRE( true == root_copy_stats.ok() ); + REQUIRE( true == root_copy_stats.is_dir() ); + + bool(*pv_capture)(visitor_stats*, jau::fs::traverse_event, const jau::fs::file_stats&) = + ( [](visitor_stats* stats_ptr, jau::fs::traverse_event tevt, const jau::fs::file_stats& element_stats) -> bool { + (void)tevt; + stats_ptr->add(element_stats); + return true; + } ); + { + + const jau::fs::traverse_options topts = jau::fs::traverse_options::recursive | + jau::fs::traverse_options::dir_entry; + visitor_stats stats(topts); + visitor_stats stats_copy(topts); + const jau::fs::path_visitor pv_orig = jau::bindCaptureRefFunc(&stats, pv_capture); + const jau::fs::path_visitor pv_copy = jau::bindCaptureRefFunc(&stats_copy, pv_capture); + REQUIRE( true == jau::fs::visit(root_orig_stats, topts, pv_orig) ); + REQUIRE( true == jau::fs::visit(root_copy_stats, topts, pv_copy) ); + + jau::fprintf_td(stderr, "test40_copy_ext_r_p: copy %s, traverse %s\n", + to_string(copts).c_str(), to_string(topts).c_str()); + + jau::fprintf_td(stderr, "test40_copy_ext_r_p: source visitor stats\n%s\n", stats.to_string().c_str()); + jau::fprintf_td(stderr, "test40_copy_ext_r_p: destination visitor stats\n%s\n", stats_copy.to_string().c_str()); + + REQUIRE( 7 == stats.total_real ); + REQUIRE( 8 == stats.total_sym_links_existing ); + REQUIRE( 0 == stats.total_sym_links_not_existing ); + REQUIRE( 0 == stats.total_no_access ); + REQUIRE( 0 == stats.total_not_existing ); + REQUIRE( 60 == stats.total_file_bytes ); + REQUIRE( 4 == stats.files_real ); + REQUIRE( 7 == stats.files_sym_link ); + REQUIRE( 3 == stats.dirs_real ); + REQUIRE( 1 == stats.dirs_sym_link ); + + REQUIRE( 7 == stats_copy.total_real ); + REQUIRE( 7 == stats_copy.total_sym_links_existing ); + REQUIRE( 1 == stats_copy.total_sym_links_not_existing ); // symlink ../README.txt + REQUIRE( 0 == stats_copy.total_no_access ); + REQUIRE( 1 == stats_copy.total_not_existing ); // symlink ../README.txt + REQUIRE( 60 == stats_copy.total_file_bytes ); + REQUIRE( 4 == stats_copy.files_real ); + REQUIRE( 6 == stats_copy.files_sym_link ); + REQUIRE( 3 == stats_copy.dirs_real ); + REQUIRE( 1 == stats_copy.dirs_sym_link ); + } + { + // compare each file in detail O(n*n) + const jau::fs::traverse_options topts = jau::fs::traverse_options::recursive | + jau::fs::traverse_options::dir_entry; + struct search_and_result { + std::string basename; + jau::fs::file_stats stats; + bool match; + }; + const jau::fs::path_visitor pv1 = jau::bindCaptureRefFunc<bool, const jau::fs::file_stats, jau::fs::traverse_event, const jau::fs::file_stats&>(&root_copy_stats, + ( bool(*)(const jau::fs::file_stats*, jau::fs::traverse_event, const jau::fs::file_stats&) ) /* help template type deduction of function-ptr */ + ( [](const jau::fs::file_stats* _root_copy_stats, jau::fs::traverse_event tevt1, const jau::fs::file_stats& element_stats1) -> bool { + (void)tevt1; + search_and_result sar { jau::fs::basename( element_stats1.path() ), element_stats1, false }; + const jau::fs::path_visitor pv2 = jau::bindCaptureRefFunc<bool, search_and_result, jau::fs::traverse_event, const jau::fs::file_stats&>(&sar, + ( bool(*)(search_and_result*, jau::fs::traverse_event, const jau::fs::file_stats&) ) /* help template type deduction of function-ptr */ + ( [](search_and_result* _sar, jau::fs::traverse_event tevt2, const jau::fs::file_stats& element_stats2) -> bool { + (void)tevt2; + const std::string basename2 = jau::fs::basename( element_stats2.path() ); + if( basename2 == _sar->basename || + ( "test_data" == _sar->basename && "test_data_copy_test40" == basename2 ) + ) + { + if( "README_slink08_relext.txt" == basename2 ) { + // symlink to ../README.txt not existent on target + _sar->match = element_stats2.is_link() && + !element_stats2.exists(); + } else { + _sar->match = + element_stats2.mode() == _sar->stats.mode() && + element_stats2.atime() == _sar->stats.atime() && + element_stats2.mtime() == _sar->stats.mtime() && + element_stats2.uid() == _sar->stats.uid() && + element_stats2.gid() == _sar->stats.gid() && + element_stats2.size() == _sar->stats.size(); + } + jau::fprintf_td(stderr, "test40_copy_ext_r_p.check: '%s', match %d\n\t source %s\n\t dest__ %s\n\n", + basename2.c_str(), _sar->match, + _sar->stats.to_string().c_str(), + element_stats2.to_string().c_str()); + return false; // done + } else { + return true; // continue search + } + } ) ); + if( jau::fs::visit(*_root_copy_stats, topts, pv2) ) { + jau::fprintf_td(stderr, "test40_copy_ext_r_p.check: '%s', not found!\n\t source %s\n\n", + sar.basename.c_str(), + element_stats1.to_string().c_str()); + return false; // not found, abort } else { - stats_ptr->total_real++; - } - jau::fprintf_td(stderr, "test05_visit_symlinks: total[real %d, symlink %d]: %s\n", - stats_ptr->total_real, stats_ptr->total_sym_link, element_stats.to_string(true).c_str()); - if( !element_stats.has_access() ) { - return false; - } - if( element_stats.is_file() ) { - if( element_stats.is_link() ) { - stats_ptr->files_sym_link++; - } else { - stats_ptr->files_real++; - } - } else if( element_stats.is_dir() ) { - if( element_stats.is_link() ) { - stats_ptr->dirs_sym_link++; + // found + if( sar.match ) { + return true; // found and matching, continue } else { - stats_ptr->dirs_real++; + return false; // found not matching, abort } } - return true; } ) ); - REQUIRE( true == jau::fs::visit(proot_stats, true /* follow_sym_link_dirs */, pv) ); + REQUIRE( true == jau::fs::visit(root_orig_stats, topts, pv1) ); + } + if constexpr ( _remove_target_test_dir ) { + REQUIRE( true == jau::fs::remove(root_copy, jau::fs::traverse_options::recursive) ); + } + } + + void test41_copy_ext_r_p_fsl() { + INFO_STR("\n\ntest41_copy_ext_r_p_fsl\n"); + + jau::fs::file_stats root_orig_stats(project_root1); + if( !root_orig_stats.exists() ) { + root_orig_stats = jau::fs::file_stats(project_root2); + } + REQUIRE( true == root_orig_stats.exists() ); + + const std::string root_copy = root+"_copy_test41"; + const jau::fs::copy_options copts = jau::fs::copy_options::recursive | + jau::fs::copy_options::preserve_all | + jau::fs::copy_options::follow_symlinks | + jau::fs::copy_options::verbose; + { + jau::fs::remove(root_copy, jau::fs::traverse_options::recursive); + + REQUIRE( true == jau::fs::copy(root_orig_stats.path(), root_copy, copts) ); + } + jau::fs::file_stats root_copy_stats(root_copy); + REQUIRE( true == root_copy_stats.exists() ); + REQUIRE( true == root_copy_stats.ok() ); + REQUIRE( true == root_copy_stats.is_dir() ); + + bool(*pv_capture)(visitor_stats*, jau::fs::traverse_event, const jau::fs::file_stats&) = + ( [](visitor_stats* stats_ptr, jau::fs::traverse_event tevt, const jau::fs::file_stats& element_stats) -> bool { + (void)tevt; + stats_ptr->add(element_stats); + return true; + } ); + { + + const jau::fs::traverse_options topts_orig = jau::fs::traverse_options::recursive | + jau::fs::traverse_options::dir_entry | + jau::fs::traverse_options::follow_symlinks; + + const jau::fs::traverse_options topts_copy = jau::fs::traverse_options::recursive | + jau::fs::traverse_options::dir_entry; + visitor_stats stats(topts_orig); + visitor_stats stats_copy(topts_copy); + const jau::fs::path_visitor pv_orig = jau::bindCaptureRefFunc(&stats, pv_capture); + const jau::fs::path_visitor pv_copy = jau::bindCaptureRefFunc(&stats_copy, pv_capture); + REQUIRE( true == jau::fs::visit(root_orig_stats, topts_orig, pv_orig) ); + REQUIRE( true == jau::fs::visit(root_copy_stats, topts_copy, pv_copy) ); + + jau::fprintf_td(stderr, "test41_copy_ext_r_p_fsl: copy %s, traverse_orig %s, traverse_copy %s\n", + to_string(copts).c_str(), to_string(topts_orig).c_str(), to_string(topts_copy).c_str()); + + jau::fprintf_td(stderr, "test41_copy_ext_r_p_fsl: source visitor stats\n%s\n", stats.to_string().c_str()); + jau::fprintf_td(stderr, "test41_copy_ext_r_p_fsl: destination visitor stats\n%s\n", stats_copy.to_string().c_str()); + REQUIRE( 9 == stats.total_real ); - REQUIRE( 5 == stats.total_sym_link ); + REQUIRE( 9 == stats.total_sym_links_existing ); + REQUIRE( 0 == stats.total_sym_links_not_existing ); + REQUIRE( 0 == stats.total_no_access ); + REQUIRE( 0 == stats.total_not_existing ); + REQUIRE( 60 < stats.total_file_bytes ); // some followed symlink files are of unknown size, e.g. /etc/fstab REQUIRE( 6 == stats.files_real ); - REQUIRE( 4 == stats.files_sym_link ); + REQUIRE( 8 == stats.files_sym_link ); REQUIRE( 3 == stats.dirs_real ); REQUIRE( 1 == stats.dirs_sym_link ); + + REQUIRE( 18 == stats_copy.total_real ); + REQUIRE( 0 == stats_copy.total_sym_links_existing ); + REQUIRE( 0 == stats_copy.total_sym_links_not_existing ); + REQUIRE( 0 == stats_copy.total_no_access ); + REQUIRE( 0 == stats_copy.total_not_existing ); + REQUIRE( 60 < stats_copy.total_file_bytes ); // some followed symlink files are of unknown size, e.g. /etc/fstab + REQUIRE( 14 == stats_copy.files_real ); + REQUIRE( 0 == stats_copy.files_sym_link ); + REQUIRE( 4 == stats_copy.dirs_real ); + REQUIRE( 0 == stats_copy.dirs_sym_link ); + } + if constexpr ( _remove_target_test_dir ) { + REQUIRE( true == jau::fs::remove(root_copy, jau::fs::traverse_options::recursive) ); } } - }; -METHOD_AS_TEST_CASE( TestFileUtil01::test01_mkdir, "Test TestFileUtil01 - test01_mkdir"); -METHOD_AS_TEST_CASE( TestFileUtil01::test02_touch, "Test TestFileUtil01 - test02_touch"); -METHOD_AS_TEST_CASE( TestFileUtil01::test03_visit, "Test TestFileUtil01 - test03_visit"); -METHOD_AS_TEST_CASE( TestFileUtil01::test04_cwd, "Test TestFileUtil01 - test04_cwd"); -METHOD_AS_TEST_CASE( TestFileUtil01::test04_symlink_file, "Test TestFileUtil01 - test04_symlink_file"); -METHOD_AS_TEST_CASE( TestFileUtil01::test05_visit_symlinks, "Test TestFileUtil01 - test05_visit_symlinks"); +METHOD_AS_TEST_CASE( TestFileUtil01::test01_cwd, "Test TestFileUtil01 - test01_cwd"); +METHOD_AS_TEST_CASE( TestFileUtil01::test02_dirname, "Test TestFileUtil01 - test02_dirname"); +METHOD_AS_TEST_CASE( TestFileUtil01::test03_basename, "Test TestFileUtil01 - test03_basename"); +METHOD_AS_TEST_CASE( TestFileUtil01::test04_file_stat, "Test TestFileUtil01 - test04_file_stat"); + +METHOD_AS_TEST_CASE( TestFileUtil01::test10_mkdir, "Test TestFileUtil01 - test10_mkdir"); +METHOD_AS_TEST_CASE( TestFileUtil01::test11_touch, "Test TestFileUtil01 - test11_touch"); + +METHOD_AS_TEST_CASE( TestFileUtil01::test20_visit, "Test TestFileUtil01 - test20_visit"); +METHOD_AS_TEST_CASE( TestFileUtil01::test21_symlink_file, "Test TestFileUtil01 - test21_symlink_file"); +METHOD_AS_TEST_CASE( TestFileUtil01::test22_visit_symlinks, "Test TestFileUtil01 - test22_visit_symlinks"); + +METHOD_AS_TEST_CASE( TestFileUtil01::test30_copy_file2dir, "Test TestFileUtil01 - test30_copy_file2dir"); +METHOD_AS_TEST_CASE( TestFileUtil01::test31_copy_file2file, "Test TestFileUtil01 - test31_copy_file2file"); + +METHOD_AS_TEST_CASE( TestFileUtil01::test40_copy_ext_r_p, "Test TestFileUtil01 - test40_copy_ext_r_p"); +METHOD_AS_TEST_CASE( TestFileUtil01::test41_copy_ext_r_p_fsl, "Test TestFileUtil01 - test41_copy_ext_r_p_fsl"); |