libstdc++-v3/testsuite/27_io/filesystem/operations/copy.cc

   1 // { dg-options "-std=gnu++17 -lstdc++fs" }
   2 // { dg-do run { target c++17 } }
   3 // { dg-require-filesystem-ts "" }
   4
   5 // Copyright (C) 2014-2019 Free Software Foundation, Inc.
   6 //
   7 // This file is part of the GNU ISO C++ Library.  This library is free
   8 // software; you can redistribute it and/or modify it under the
   9 // terms of the GNU General Public License as published by the
  10 // Free Software Foundation; either version 3, or (at your option)
  11 // any later version.
  12
  13 // This library is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License along
  19 // with this library; see the file COPYING3.  If not see
  20 // <http://www.gnu.org/licenses/>.
  21
  22 // 15.3 Copy [fs.op.copy]
  23
  24 #include <filesystem>
  25 #include <testsuite_fs.h>
  26 #include <testsuite_hooks.h>
  27
  28 namespace fs = std::filesystem;
  29
  30 // Test error conditions.
  31 void
  32 test01()
  33 {
  34   auto p = __gnu_test::nonexistent_path();
  35   std::error_code ec;
  36
  37   VERIFY( !fs::exists(p) );
  38   fs::copy(p, ".", fs::copy_options::none, ec);
  39   VERIFY( ec );
  40
  41   ec.clear();
  42   fs::copy(".", ".", fs::copy_options::none, ec);
  43   VERIFY( ec );
  44
  45   __gnu_test::scoped_file f(p);
  46   VERIFY( fs::is_directory(".") );
  47   VERIFY( fs::is_regular_file(p) );
  48   ec.clear();
  49   fs::copy(".", p, fs::copy_options::none, ec);
  50   VERIFY( ec );
  51
  52   auto to = __gnu_test::nonexistent_path();
  53   ec.clear();
  54   auto opts = fs::copy_options::create_symlinks;
  55   fs::copy("/", to, opts, ec);
  56   VERIFY( ec == std::make_error_code(std::errc::is_a_directory) );
  57   VERIFY( !exists(to) );
  58
  59   ec.clear();
  60   opts != fs::copy_options::recursive;
  61   fs::copy("/", to, opts, ec);
  62   VERIFY( ec == std::make_error_code(std::errc::is_a_directory) );
  63   VERIFY( !exists(to) );
  64 }
  65
  66 // Test is_symlink(f) case.
  67 void
  68 test02()
  69 {
  70   const std::error_code bad_ec = make_error_code(std::errc::invalid_argument);
  71   auto from = __gnu_test::nonexistent_path();
  72   auto to = __gnu_test::nonexistent_path();
  73   std::error_code ec;
  74
  75   ec = bad_ec;
  76   fs::create_symlink(".", from, ec);
  77   VERIFY( !ec );
  78   VERIFY( fs::exists(from) );
  79
  80   ec = bad_ec;
  81   fs::copy(from, to, fs::copy_options::skip_symlinks, ec);
  82   VERIFY( !ec );
  83   VERIFY( !fs::exists(to) );
  84
  85   ec = bad_ec;
  86   fs::copy(from, to, fs::copy_options::skip_symlinks, ec);
  87   VERIFY( !ec );
  88   VERIFY( !fs::exists(to) );
  89
  90   ec = bad_ec;
  91   fs::copy(from, to,
  92            fs::copy_options::skip_symlinks|fs::copy_options::copy_symlinks,
  93            ec);
  94   VERIFY( !ec );
  95   VERIFY( !fs::exists(to) );
  96
  97   ec = bad_ec;
  98   fs::copy(from, to, fs::copy_options::copy_symlinks, ec);
  99   VERIFY( !ec );
 100   VERIFY( fs::exists(to) );
 101   VERIFY( is_symlink(to) );
 102
 103   ec.clear();
 104   fs::copy(from, to, fs::copy_options::copy_symlinks, ec);
 105   VERIFY( ec );
 106
 107   remove(from, ec);
 108   remove(to, ec);
 109 }
 110
 111 // Test is_regular_file(f) case.
 112 void
 113 test03()
 114 {
 115   auto from = __gnu_test::nonexistent_path();
 116   auto to = __gnu_test::nonexistent_path();
 117
 118   // test empty file
 119   std::ofstream{from};
 120   VERIFY( fs::exists(from) );
 121   VERIFY( fs::file_size(from) == 0 );
 122   fs::copy(from, to);
 123   VERIFY( fs::exists(to) );
 124   VERIFY( fs::file_size(to) == 0 );
 125
 126   remove(to);
 127   VERIFY( !fs::exists(to) );
 128   std::ofstream{from} << "Hello, filesystem!";
 129   VERIFY( fs::file_size(from) != 0 );
 130   fs::copy(from, to);
 131   VERIFY( fs::exists(to) );
 132   VERIFY( fs::file_size(to) == fs::file_size(from) );
 133
 134   remove(from);
 135   remove(to);
 136 }
 137
 138 // Test is_directory(f) case.
 139 void
 140 test04()
 141 {
 142   const std::error_code bad_ec = make_error_code(std::errc::invalid_argument);
 143   auto from = __gnu_test::nonexistent_path();
 144   auto to = __gnu_test::nonexistent_path();
 145   std::error_code ec;
 146
 147   create_directories(from/"a/b/c");
 148
 149   {
 150     __gnu_test::scoped_file f(to);
 151     copy(from, to, ec);
 152     VERIFY( ec );
 153   }
 154
 155   __gnu_test::scoped_file f1(from/"a/f1");
 156   std::ofstream{f1.path} << "file one";
 157   __gnu_test::scoped_file f2(from/"a/b/f2");
 158   std::ofstream{f2.path} << "file two";
 159
 160   copy(from, to, ec);
 161   VERIFY( !ec );
 162   VERIFY( exists(to) && is_empty(to) );
 163   remove(to);
 164
 165   ec = bad_ec;
 166   copy(from, to, fs::copy_options::recursive, ec);
 167   VERIFY( !ec );
 168   VERIFY( exists(to) && !is_empty(to) );
 169   VERIFY( is_regular_file(to/"a/f1") && !is_empty(to/"a/f1") );
 170   VERIFY( file_size(from/"a/f1") == file_size(to/"a/f1") );
 171   VERIFY( is_regular_file(to/"a/b/f2") && !is_empty(to/"a/b/f2") );
 172   VERIFY( file_size(from/"a/b/f2") == file_size(to/"a/b/f2") );
 173   VERIFY( is_directory(to/"a/b/c") && is_empty(to/"a/b/c") );
 174
 175   f1.path.clear();
 176   f2.path.clear();
 177   remove_all(from, ec);
 178   remove_all(to, ec);
 179 }
 180
 181 // Test no-op cases.
 182 void
 183 test05()
 184 {
 185   auto to = __gnu_test::nonexistent_path();
 186   std::error_code ec = std::make_error_code(std::errc::invalid_argument);
 187
 188   fs::copy("/", to, fs::copy_options::copy_symlinks, ec);
 189   VERIFY( !ec );  // Previous value should be cleared (LWG 2683)
 190 }
 191
 192 int
 193 main()
 194 {
 195   test01();
 196   test02();
 197   test03();
 198   test04();
 199   test05();
 200 }