procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

libstdc++: Skip filesystem tests that depend on permissions [PR90787]

Browse source 
Tests that depend on filesystem permissions FAIL if run on Windows or as
root. Add a helper function to detect those cases, so the tests can skip
those checks gracefully.

Signed-off-by: Jonathan Wakely <jwakely@redhat.com>

libstdc++-v3/ChangeLog:

	PR libstdc++/90787
	* testsuite/27_io/filesystem/iterators/directory_iterator.cc:
	Use new __gnu_test::permissions_are_testable() function.
	* testsuite/27_io/filesystem/iterators/recursive_directory_iterator.cc:
	Likewise.
	* testsuite/27_io/filesystem/operations/exists.cc: Likewise.
	* testsuite/27_io/filesystem/operations/is_empty.cc: Likewise.
	* testsuite/27_io/filesystem/operations/remove.cc: Likewise.
	* testsuite/27_io/filesystem/operations/remove_all.cc: Likewise.
	* testsuite/27_io/filesystem/operations/status.cc: Likewise.
	* testsuite/27_io/filesystem/operations/symlink_status.cc:
	Likewise.
	* testsuite/27_io/filesystem/operations/temp_directory_path.cc:
	Likewise.
	* testsuite/experimental/filesystem/iterators/directory_iterator.cc:
	Likewise.
	* testsuite/experimental/filesystem/iterators/recursive_directory_iterator.cc:
	Likewise.
	* testsuite/experimental/filesystem/operations/exists.cc:
	Likewise.
	* testsuite/experimental/filesystem/operations/is_empty.cc:
	Likewise.
	* testsuite/experimental/filesystem/operations/remove.cc:
	Likewise.
	* testsuite/experimental/filesystem/operations/remove_all.cc:
	Likewise.
	* testsuite/experimental/filesystem/operations/temp_directory_path.cc:
	Likewise.
	* testsuite/util/testsuite_fs.h (__gnu_test::permissions_are_testable):
	New function to guess whether testing permissions will work.
This commit is contained in:
Jonathan Wakely 2021-08-20 14:51:06 +01:00
parent 1b507b1e3c
commit 29b2fd371f
17 changed files with 189 additions and 174 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
libstdc++-v3/testsuite/27_io/filesystem/iterators/directory_iterator.cc
View file

@ -56,24 +56,26 @@ test01()
++iter; ++iter;
VERIFY( iter == end(iter) ); VERIFY( iter == end(iter) );
#if !(defined(__MINGW32__) || defined(__MINGW64__)) if (__gnu_test::permissions_are_testable())
// Test inaccessible directory. {
ec = bad_ec; // Test inaccessible directory.
permissions(p, fs::perms::none, ec); ec = bad_ec;
VERIFY( !ec ); permissions(p, fs::perms::none, ec);
iter = fs::directory_iterator(p, ec); VERIFY( !ec );
VERIFY( ec ); iter = fs::directory_iterator(p, ec);
VERIFY( iter == end(iter) ); VERIFY( ec );
VERIFY( iter == end(iter) );
// Test inaccessible directory, skipping permission denied. // Test inaccessible directory, skipping permission denied.
const auto opts = fs::directory_options::skip_permission_denied; const auto opts = fs::directory_options::skip_permission_denied;
ec = bad_ec; ec = bad_ec;
iter = fs::directory_iterator(p, opts, ec); iter = fs::directory_iterator(p, opts, ec);
VERIFY( !ec ); VERIFY( !ec );
VERIFY( iter == end(iter) ); VERIFY( iter == end(iter) );
#endif
permissions(p, fs::perms::owner_all, ec);
}
permissions(p, fs::perms::owner_all, ec);
remove_all(p, ec); remove_all(p, ec);
} }

91
libstdc++-v3/testsuite/27_io/filesystem/iterators/recursive_directory_iterator.cc
View file

@ -59,54 +59,55 @@ test01()
++iter; ++iter;
VERIFY( iter == end(iter) ); VERIFY( iter == end(iter) );
#if ! (defined (__MINGW32__) || defined(__MINGW64__)) if (__gnu_test::permissions_are_testable())
// Test inaccessible directory. {
ec = bad_ec; // Test inaccessible directory.
permissions(p, fs::perms::none, ec); ec = bad_ec;
VERIFY( !ec ); permissions(p, fs::perms::none, ec);
iter = fs::recursive_directory_iterator(p, ec); VERIFY( !ec );
VERIFY( ec ); iter = fs::recursive_directory_iterator(p, ec);
VERIFY( iter == end(iter) ); VERIFY( ec );
VERIFY( iter == end(iter) );
// Test inaccessible directory, skipping permission denied. // Test inaccessible directory, skipping permission denied.
const auto opts = fs::directory_options::skip_permission_denied; const auto opts = fs::directory_options::skip_permission_denied;
iter = fs::recursive_directory_iterator(p, opts, ec); iter = fs::recursive_directory_iterator(p, opts, ec);
VERIFY( !ec ); VERIFY( !ec );
VERIFY( iter == end(iter) ); VERIFY( iter == end(iter) );
// Test inaccessible sub-directory. // Test inaccessible sub-directory.
ec = bad_ec; ec = bad_ec;
permissions(p, fs::perms::owner_all, ec); permissions(p, fs::perms::owner_all, ec);
VERIFY( !ec ); VERIFY( !ec );
ec = bad_ec; ec = bad_ec;
permissions(p/"d1/d2", fs::perms::none, ec); permissions(p/"d1/d2", fs::perms::none, ec);
VERIFY( !ec ); VERIFY( !ec );
ec = bad_ec; ec = bad_ec;
iter = fs::recursive_directory_iterator(p, ec); iter = fs::recursive_directory_iterator(p, ec);
VERIFY( !ec ); VERIFY( !ec );
VERIFY( iter != end(iter) ); VERIFY( iter != end(iter) );
VERIFY( iter->path() == p/"d1" ); VERIFY( iter->path() == p/"d1" );
++iter; // should recurse into d1 ++iter; // should recurse into d1
VERIFY( iter != end(iter) ); VERIFY( iter != end(iter) );
VERIFY( iter->path() == p/"d1/d2" ); VERIFY( iter->path() == p/"d1/d2" );
iter.increment(ec); // should fail to recurse into p/d1/d2 iter.increment(ec); // should fail to recurse into p/d1/d2
VERIFY( ec ); VERIFY( ec );
VERIFY( iter == end(iter) ); VERIFY( iter == end(iter) );
// Test inaccessible sub-directory, skipping permission denied. // Test inaccessible sub-directory, skipping permission denied.
ec = bad_ec; ec = bad_ec;
iter = fs::recursive_directory_iterator(p, opts, ec); iter = fs::recursive_directory_iterator(p, opts, ec);
VERIFY( !ec ); VERIFY( !ec );
VERIFY( iter != end(iter) ); VERIFY( iter != end(iter) );
VERIFY( iter->path() == p/"d1" ); VERIFY( iter->path() == p/"d1" );
++iter; // should recurse into d1 ++iter; // should recurse into d1
VERIFY( iter != end(iter) ); VERIFY( iter != end(iter) );
VERIFY( iter->path() == p/"d1/d2" ); VERIFY( iter->path() == p/"d1/d2" );
ec = bad_ec; ec = bad_ec;
iter.increment(ec); // should fail to recurse into p/d1/d2, so skip it iter.increment(ec); // should fail to recurse into p/d1/d2, so skip it
VERIFY( !ec ); VERIFY( !ec );
VERIFY( iter == end(iter) ); VERIFY( iter == end(iter) );
#endif }
permissions(p/"d1/d2", fs::perms::owner_all, ec); permissions(p/"d1/d2", fs::perms::owner_all, ec);
remove_all(p, ec); remove_all(p, ec);

6
libstdc++-v3/testsuite/27_io/filesystem/operations/exists.cc
View file

@ -79,10 +79,8 @@ test03()
void void
test04() test04()
{ {
#if defined(__MINGW32__) || defined(__MINGW64__) if (!__gnu_test::permissions_are_testable())
// filesystem permissions not supported return;
return;
#endif
using std::filesystem::perms; using std::filesystem::perms;
using std::filesystem::perm_options; using std::filesystem::perm_options;

6
libstdc++-v3/testsuite/27_io/filesystem/operations/is_empty.cc
View file

@ -27,10 +27,8 @@ namespace fs = std::filesystem;
void void
test01() test01()
{ {
#if defined(__MINGW32__) || defined(__MINGW64__) if (!__gnu_test::permissions_are_testable())
// filesystem permissions not supported return;
return;
#endif
auto p = __gnu_test::nonexistent_path(); auto p = __gnu_test::nonexistent_path();
create_directory(p); create_directory(p);

21
libstdc++-v3/testsuite/27_io/filesystem/operations/remove.cc
View file

@ -76,19 +76,18 @@ test01()
VERIFY( !n ); VERIFY( !n );
VERIFY( exists(dir/"a/b") ); VERIFY( exists(dir/"a/b") );
#if defined(__MINGW32__) || defined(__MINGW64__) if (__gnu_test::permissions_are_testable())
// No permissions support
#else
permissions(dir, fs::perms::none, ec);
if (!ec)
{ {
ec.clear(); permissions(dir, fs::perms::none, ec);
n = remove(dir/"a/b", ec); if (!ec)
VERIFY( ec ); {
VERIFY( !n ); ec.clear();
permissions(dir, fs::perms::owner_all, ec); n = remove(dir/"a/b", ec);
VERIFY( ec );
VERIFY( !n );
permissions(dir, fs::perms::owner_all, ec);
}
} }
#endif
ec = bad_ec; ec = bad_ec;
n = remove(dir/"a/b", ec); n = remove(dir/"a/b", ec);

7
libstdc++-v3/testsuite/27_io/filesystem/operations/remove_all.cc
View file

@ -142,9 +142,9 @@ test03()
void void
test04() test04()
{ {
#if defined(__MINGW32__) || defined(__MINGW64__) if (!__gnu_test::permissions_are_testable())
// no permissions return;
#else
// PR libstdc++/93201 // PR libstdc++/93201
std::error_code ec; std::error_code ec;
std::uintmax_t n; std::uintmax_t n;
@ -172,7 +172,6 @@ test04()
fs::permissions(dir, fs::perms::owner_write, fs::perm_options::add); fs::permissions(dir, fs::perms::owner_write, fs::perm_options::add);
fs::remove_all(dir, ec); fs::remove_all(dir, ec);
f.path.clear(); f.path.clear();
#endif
} }
int int

6
libstdc++-v3/testsuite/27_io/filesystem/operations/status.cc
View file

@ -55,10 +55,8 @@ test02()
void void
test03() test03()
{ {
#if defined(__MINGW32__) || defined(__MINGW64__) if (!__gnu_test::permissions_are_testable())
// No permissions support return;
return;
#endif
fs::path dir = __gnu_test::nonexistent_path(); fs::path dir = __gnu_test::nonexistent_path();
fs::create_directory(dir); fs::create_directory(dir);

3
libstdc++-v3/testsuite/27_io/filesystem/operations/symlink_status.cc
View file

@ -68,6 +68,9 @@ test02()
void void
test03() test03()
{ {
if (!__gnu_test::permissions_are_testable())
return;
fs::path dir = __gnu_test::nonexistent_path(); fs::path dir = __gnu_test::nonexistent_path();
fs::create_directory(dir); fs::create_directory(dir);
__gnu_test::scoped_file d(dir, __gnu_test::scoped_file::adopt_file); __gnu_test::scoped_file d(dir, __gnu_test::scoped_file::adopt_file);

6
libstdc++-v3/testsuite/27_io/filesystem/operations/temp_directory_path.cc
View file

@ -101,10 +101,8 @@ test02()
void void
test03() test03()
{ {
#if defined(__MINGW32__) || defined(__MINGW64__) if (!__gnu_test::permissions_are_testable())
// No permissions support return;
return;
#endif
clean_env(); clean_env();

30
libstdc++-v3/testsuite/experimental/filesystem/iterators/directory_iterator.cc
View file

@ -53,22 +53,24 @@ test01()
++iter; ++iter;
VERIFY( iter == end(iter) ); VERIFY( iter == end(iter) );
#if !(defined(__MINGW32__) || defined(__MINGW64__)) if (__gnu_test::permissions_are_testable())
// Test inaccessible directory. {
permissions(p, fs::perms::none, ec); // Test inaccessible directory.
VERIFY( !ec ); permissions(p, fs::perms::none, ec);
iter = fs::directory_iterator(p, ec); VERIFY( !ec );
VERIFY( ec ); iter = fs::directory_iterator(p, ec);
VERIFY( iter == end(iter) ); VERIFY( ec );
VERIFY( iter == end(iter) );
// Test inaccessible directory, skipping permission denied. // Test inaccessible directory, skipping permission denied.
const auto opts = fs::directory_options::skip_permission_denied; const auto opts = fs::directory_options::skip_permission_denied;
iter = fs::directory_iterator(p, opts, ec); iter = fs::directory_iterator(p, opts, ec);
VERIFY( !ec ); VERIFY( !ec );
VERIFY( iter == end(iter) ); VERIFY( iter == end(iter) );
#endif
permissions(p, fs::perms::owner_all, ec);
}
permissions(p, fs::perms::owner_all, ec);
remove_all(p, ec); remove_all(p, ec);
} }

92
libstdc++-v3/testsuite/experimental/filesystem/iterators/recursive_directory_iterator.cc
View file

@ -61,54 +61,58 @@ test01()
++iter; ++iter;
VERIFY( iter == end(iter) ); VERIFY( iter == end(iter) );
// Test inaccessible directory. if (__gnu_test::permissions_are_testable())
ec = bad_ec; {
permissions(p, fs::perms::none, ec); // Test inaccessible directory.
VERIFY( !ec ); ec = bad_ec;
iter = fs::recursive_directory_iterator(p, ec); permissions(p, fs::perms::none, ec);
VERIFY( ec ); VERIFY( !ec );
VERIFY( iter == end(iter) ); iter = fs::recursive_directory_iterator(p, ec);
VERIFY( ec );
VERIFY( iter == end(iter) );
// Test inaccessible directory, skipping permission denied. // Test inaccessible directory, skipping permission denied.
const auto opts = fs::directory_options::skip_permission_denied; const auto opts = fs::directory_options::skip_permission_denied;
ec = bad_ec; ec = bad_ec;
iter = fs::recursive_directory_iterator(p, opts, ec); iter = fs::recursive_directory_iterator(p, opts, ec);
VERIFY( !ec ); VERIFY( !ec );
VERIFY( iter == end(iter) ); VERIFY( iter == end(iter) );
// Test inaccessible sub-directory. // Test inaccessible sub-directory.
ec = bad_ec; ec = bad_ec;
permissions(p, fs::perms::owner_all, ec); permissions(p, fs::perms::owner_all, ec);
VERIFY( !ec ); VERIFY( !ec );
ec = bad_ec; ec = bad_ec;
permissions(p/"d1/d2", fs::perms::none, ec); permissions(p/"d1/d2", fs::perms::none, ec);
VERIFY( !ec ); VERIFY( !ec );
ec = bad_ec; ec = bad_ec;
iter = fs::recursive_directory_iterator(p, ec); iter = fs::recursive_directory_iterator(p, ec);
VERIFY( !ec ); VERIFY( !ec );
VERIFY( iter != end(iter) ); VERIFY( iter != end(iter) );
VERIFY( iter->path() == p/"d1" ); VERIFY( iter->path() == p/"d1" );
++iter; // should recurse into d1 ++iter; // should recurse into d1
VERIFY( iter != end(iter) ); VERIFY( iter != end(iter) );
VERIFY( iter->path() == p/"d1/d2" ); VERIFY( iter->path() == p/"d1/d2" );
iter.increment(ec); // should fail to recurse into p/d1/d2 iter.increment(ec); // should fail to recurse into p/d1/d2
VERIFY( ec ); VERIFY( ec );
VERIFY( iter == end(iter) ); VERIFY( iter == end(iter) );
// Test inaccessible sub-directory, skipping permission denied. // Test inaccessible sub-directory, skipping permission denied.
ec = bad_ec; ec = bad_ec;
iter = fs::recursive_directory_iterator(p, opts, ec); iter = fs::recursive_directory_iterator(p, opts, ec);
VERIFY( !ec ); VERIFY( !ec );
VERIFY( iter != end(iter) ); VERIFY( iter != end(iter) );
VERIFY( iter->path() == p/"d1" ); VERIFY( iter->path() == p/"d1" );
++iter; // should recurse into d1 ++iter; // should recurse into d1
VERIFY( iter->path() == p/"d1/d2" ); VERIFY( iter->path() == p/"d1/d2" );
ec = bad_ec; ec = bad_ec;
iter.increment(ec); // should fail to recurse into p/d1/d2, so skip it iter.increment(ec); // should fail to recurse into p/d1/d2, so skip it
VERIFY( !ec ); VERIFY( !ec );
VERIFY( iter == end(iter) ); VERIFY( iter == end(iter) );
permissions(p/"d1/d2", fs::perms::owner_all, ec);
}
permissions(p/"d1/d2", fs::perms::owner_all, ec);
remove_all(p, ec); remove_all(p, ec);
} }

6
libstdc++-v3/testsuite/experimental/filesystem/operations/exists.cc
View file

@ -74,10 +74,8 @@ test03()
void void
test04() test04()
{ {
#if defined(__MINGW32__) || defined(__MINGW64__) if (!__gnu_test::permissions_are_testable())
// filesystem permissions not supported return;
return;
#endif
using perms = std::experimental::filesystem::perms; using perms = std::experimental::filesystem::perms;
path p = __gnu_test::nonexistent_path(); path p = __gnu_test::nonexistent_path();

6
libstdc++-v3/testsuite/experimental/filesystem/operations/is_empty.cc
View file

@ -28,10 +28,8 @@ namespace fs = std::experimental::filesystem;
void void
test01() test01()
{ {
#if defined(__MINGW32__) || defined(__MINGW64__) if (!__gnu_test::permissions_are_testable())
// filesystem permissions not supported return;
return;
#endif
auto p = __gnu_test::nonexistent_path(); auto p = __gnu_test::nonexistent_path();
create_directory(p); create_directory(p);

21
libstdc++-v3/testsuite/experimental/filesystem/operations/remove.cc
View file

@ -78,19 +78,18 @@ test01()
VERIFY( !n ); VERIFY( !n );
VERIFY( exists(dir/"a/b") ); VERIFY( exists(dir/"a/b") );
#if defined(__MINGW32__) || defined(__MINGW64__) if (__gnu_test::permissions_are_testable())
// No permissions support
#else
permissions(dir, fs::perms::none, ec);
if (!ec)
{ {
ec.clear(); permissions(dir, fs::perms::none, ec);
n = remove(dir/"a/b", ec); if (!ec)
VERIFY( ec ); {
VERIFY( !n ); ec.clear();
permissions(dir, fs::perms::owner_all, ec); n = remove(dir/"a/b", ec);
VERIFY( ec );
VERIFY( !n );
permissions(dir, fs::perms::owner_all, ec);
}
} }
#endif
ec = bad_ec; ec = bad_ec;
n = remove(dir/"a/b", ec); n = remove(dir/"a/b", ec);

7
libstdc++-v3/testsuite/experimental/filesystem/operations/remove_all.cc
View file

@ -111,9 +111,9 @@ test02()
void void
test04() test04()
{ {
#if defined(__MINGW32__) || defined(__MINGW64__) if (!__gnu_test::permissions_are_testable())
// no permissions return;
#else
// PR libstdc++/93201 // PR libstdc++/93201
std::error_code ec; std::error_code ec;
std::uintmax_t n; std::uintmax_t n;
@ -139,7 +139,6 @@ test04()
fs::permissions(dir, fs::perms::owner_write|fs::perms::add_perms); fs::permissions(dir, fs::perms::owner_write|fs::perms::add_perms);
fs::remove_all(dir, ec); fs::remove_all(dir, ec);
f.path.clear(); f.path.clear();
#endif
} }
int int

3
libstdc++-v3/testsuite/experimental/filesystem/operations/temp_directory_path.cc
View file

@ -102,6 +102,9 @@ test02()
void void
test03() test03()
{ {
if (!__gnu_test::permissions_are_testable())
return;
auto p = __gnu_test::nonexistent_path(); auto p = __gnu_test::nonexistent_path();
create_directories(p/"tmp"); create_directories(p/"tmp");
permissions(p, fs::perms::none); permissions(p, fs::perms::none);

18
libstdc++-v3/testsuite/util/testsuite_fs.h
View file

@ -34,7 +34,7 @@ namespace test_fs = std::experimental::filesystem;
#include <fstream> #include <fstream>
#include <string> #include <string>
#include <cstdio> #include <cstdio>
#include <unistd.h> // unlink, close, getpid #include <unistd.h> // unlink, close, getpid, geteuid
#if defined(_GNU_SOURCE) || _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200112L #if defined(_GNU_SOURCE) || _XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200112L
#include <stdlib.h> // mkstemp #include <stdlib.h> // mkstemp
@ -160,5 +160,21 @@ namespace __gnu_test
path_type path; path_type path;
}; };
bool
permissions_are_testable(bool print_msg = true)
{
bool testable = false;
#if !(defined __MINGW32__ || defined __MINGW64__)
if (geteuid() != 0)
testable = true;
// XXX on Linux the CAP_DAC_OVERRIDE and CAP_DAC_READ_SEARCH capabilities
// can give normal users extra permissions for files and directories.
// We ignore that possibility here.
#endif
if (print_msg && !testable)
std::puts("Skipping tests that depend on filesystem permissions");
return testable;
}
} // namespace __gnu_test } // namespace __gnu_test
#endif #endif