This is an archive of the discontinued LLVM Phabricator instance.

Differential D143383

[libc++][test] Removes rapid-cxx-test.h.
ClosedPublic

Authored by Mordante on Feb 6 2023, 4:24 AM.

Details

Reviewers
ldionne
Group Reviewers
Restricted Project
Commits
rG2f2ed477143e: [libc++][test] Removes rapid-cxx-test.h.
Summary

Depends on D142808

Diff Detail

Unit TestsFailed

TimeTest
1,500,040 mslibcxx CI Apple back-deployment macosx11.0 arm64 > apple-libc++-backdeployment-cfg-in.std/thread/thread_condition::notify_all_at_thread_exit_lwg3343.pass.cpp
1,500,060 mslibcxx CI Apple back-deployment with assertions enabled > apple-libc++-backdeployment-cfg-in.std/thread/thread_condition::notify_all_at_thread_exit_lwg3343.pass.cpp

Event Timeline

Mordante created this revision.Feb 6 2023, 4:24 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 6 2023, 4:24 AM
Herald added a subscriber: jdoerfert. · View Herald Transcript
Mordante requested review of this revision.Feb 6 2023, 4:24 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 6 2023, 4:24 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B212061: Diff 495079.Feb 6 2023, 5:58 AM
ldionne accepted this revision.Feb 14 2023, 9:55 AM
ldionne added a subscriber: ldionne.

LGTM, thanks! This is a nice cleanup since it makes all of our tests use the same conventions.

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_size.pass.cpp
108

You're missing an include of assert_macros.h here.

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/hard_link_count.pass.cpp
171

Same here, and probably elsewhere.

This revision is now accepted and ready to land.Feb 14 2023, 9:55 AM
Mordante updated this revision to Diff 498385.Feb 17 2023, 8:14 AM

Rebased and addresses review comments.

Mordante marked 2 inline comments as done.Feb 17 2023, 8:59 AM

Thanks for the review.

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_size.pass.cpp
108

Agreed, the tests still worked due to filesystem_test_helper.h including this file.

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/hard_link_count.pass.cpp
171

I had that already done locally.

Due to the changes in the parent patch I've given the patch another CI run to make sure everything still works.

Harbormaster completed remote builds in B214426: Diff 498385.Feb 17 2023, 9:52 AM
Mordante updated this revision to Diff 498422.Feb 17 2023, 9:54 AM
Mordante marked 2 inline comments as done.

CI fixes.

Harbormaster completed remote builds in B214447: Diff 498422.Feb 17 2023, 11:19 AM
Mordante updated this revision to Diff 498467.Feb 17 2023, 11:42 AM

Avoid std::forward to avoid including the utility header.

Harbormaster completed remote builds in B214479: Diff 498467.Feb 17 2023, 5:09 PM
Closed by commit rG2f2ed477143e: [libc++][test] Removes rapid-cxx-test.h. (authored by Mordante). · Explain WhyFeb 18 2023, 3:52 AM
This revision was automatically updated to reflect the committed changes.
Mordante added a commit: rG2f2ed477143e: [libc++][test] Removes rapid-cxx-test.h..

Revision Contents

PathSize
libcxx/
test/
libcxx/
containers/
sequences/
deque/
180 lines
input.output/
filesystems/
class.directory_entry/
directory_entry.mods/
31 lines
std/
input.output/
filesystems/
class.directory_entry/
directory_entry.cons/
22 lines
22 lines
22 lines
22 lines
95 lines
directory_entry.mods/
46 lines
168 lines
64 lines
directory_entry.obs/
116 lines
166 lines
113 lines
101 lines
21 lines
20 lines
class.directory_iterator/
directory_iterator.members/
27 lines
50 lines
110 lines
52 lines
27 lines
57 lines
directory_iterator.nonmembers/
20 lines
class.rec.dir.itr/
rec.dir.itr.members/
39 lines
92 lines
110 lines
27 lines
16 lines
204 lines
39 lines
95 lines
34 lines
85 lines
rec.dir.itr.nonmembers/
20 lines
fs.op.funcs/
fs.op.hard_lk_ct/
44 lines
fs.op.absolute/
22 lines
fs.op.canonical/
48 lines
fs.op.copy/
166 lines
fs.op.copy_file/
103 lines
35 lines
fs.op.copy_symlink/
38 lines
fs.op.create_directories/
121 lines
fs.op.create_directory/
78 lines
102 lines
fs.op.create_directory_symlink/
24 lines
fs.op.create_hard_link/
34 lines
fs.op.create_symlink/
41 lines
fs.op.current_path/
50 lines
fs.op.equivalent/
69 lines
fs.op.exists/
53 lines
fs.op.file_size/
38 lines
fs.op.is_block_file/
32 lines
fs.op.is_char_file/
32 lines
fs.op.is_directory/
41 lines
fs.op.is_empty/
78 lines
fs.op.is_fifo/
32 lines
fs.op.is_other/
32 lines
fs.op.is_regular_file/
36 lines
fs.op.is_socket/
32 lines
fs.op.is_symlink/
41 lines
fs.op.last_write_time/
133 lines
fs.op.permissions/
53 lines
fs.op.proximate/
20 lines
fs.op.read_symlink/
27 lines
fs.op.relative/
80 lines
fs.op.remove/
32 lines
fs.op.remove_all/
57 lines
fs.op.rename/
74 lines
fs.op.resize_file/
36 lines
fs.op.space/
43 lines
fs.op.status/
77 lines
fs.op.status_known/
16 lines
fs.op.symlink_status/
100 lines
fs.op.temp_dir_path/
55 lines
support/
12 lines

Diff 495079

libcxx/test/libcxx/containers/sequences/deque/spare_block_handling.pass.cpp

Show All 9 Lines
// <deque> // <deque>
// Test how deque manages the spare blocks it keeps. The exact values it tests // Test how deque manages the spare blocks it keeps. The exact values it tests
// for are not always important, but are sometimes needed to ensure the container // for are not always important, but are sometimes needed to ensure the container
// resizes or shrinks at the correct time. // resizes or shrinks at the correct time.
#include <deque> #include <deque>
#include <cassert>
#include <cstdio> #include <cstdio>
#include <memory> #include <memory>
#include <queue> #include <queue>
#include <stack> #include <stack>
#include <string>
#include "min_allocator.h" #include "min_allocator.h"
#include "rapid-cxx-test.h" #include "assert_macros.h"
template <class Adaptor> template <class Adaptor>
struct ContainerAdaptor : public Adaptor { struct ContainerAdaptor : public Adaptor {
using Adaptor::Adaptor; using Adaptor::Adaptor;
typename Adaptor::container_type& GetContainer() { return Adaptor::c; } typename Adaptor::container_type& GetContainer() { return Adaptor::c; }
}; };
template <class Deque> template <class Deque>
Show All 18 Lines
}; };
static_assert(BlockSize<LargeT>::value == 16, ""); static_assert(BlockSize<LargeT>::value == 16, "");
const auto& AllocBytes = malloc_allocator_base::outstanding_bytes; const auto& AllocBytes = malloc_allocator_base::outstanding_bytes;
template <class Deque> template <class Deque>
struct PrintOnFailure { struct PrintOnFailure {
explicit PrintOnFailure(Deque const& deque) : deque_(&deque) {} explicit PrintOnFailure(Deque const& deque) : deque_(&deque) {}
void operator()() const { print(*deque_); }
~PrintOnFailure() {
if (::rapid_cxx_test::get_reporter().current_failure().type
!= ::rapid_cxx_test::failure_type::none) {
print(*deque_);
}
}
private: private:
const Deque* deque_; const Deque* deque_;
PrintOnFailure(PrintOnFailure const&) = delete; PrintOnFailure(PrintOnFailure const&) = delete;
}; };
TEST_SUITE(deque_spare_tests)
TEST_CASE(push_back) { static void push_back() {
const auto BS = BlockSize<LargeT>::value; const auto BS = BlockSize<LargeT>::value;
std::unique_ptr<Deque<LargeT>> dp(new Deque<LargeT>); std::unique_ptr<Deque<LargeT>> dp(new Deque<LargeT>);
auto& d = *dp; auto& d = *dp;
PrintOnFailure<Deque<LargeT>> on_fail(d); PrintOnFailure<Deque<LargeT>> on_fail(d);
// Test nothing is allocated after default construction. // Test nothing is allocated after default construction.
{ {
TEST_REQUIRE(d.size() == 0); TEST_REQUIRE(d.size() == 0, on_fail);
TEST_REQUIRE(d.__capacity() == 0); TEST_REQUIRE(d.__capacity() == 0, on_fail);
TEST_REQUIRE(d.__block_count() == 0); TEST_REQUIRE(d.__block_count() == 0, on_fail);
} }
// First push back allocates one block. // First push back allocates one block.
d.push_back({}); d.push_back({});
{ {
TEST_REQUIRE(d.size() == 1); TEST_REQUIRE(d.size() == 1, on_fail);
TEST_REQUIRE(d.__front_spare() == 0); TEST_REQUIRE(d.__front_spare() == 0, on_fail);
TEST_REQUIRE(d.__back_spare() == 14); TEST_REQUIRE(d.__back_spare() == 14, on_fail);
TEST_REQUIRE(d.__back_spare_blocks() == 0); TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
TEST_REQUIRE(d.__capacity() == BS - 1); TEST_REQUIRE(d.__capacity() == BS - 1, on_fail);
TEST_REQUIRE(d.__block_count() == 1); TEST_REQUIRE(d.__block_count() == 1, on_fail);
} }
d.push_back({}); d.push_back({});
{ {
TEST_REQUIRE(d.size() == 2); TEST_REQUIRE(d.size() == 2, on_fail);
TEST_REQUIRE(d.__front_spare() == 0); TEST_REQUIRE(d.__front_spare() == 0, on_fail);
TEST_REQUIRE(d.__back_spare() == 13); TEST_REQUIRE(d.__back_spare() == 13, on_fail);
TEST_REQUIRE(d.__back_spare_blocks() == 0); TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
} }
// Push back until we need a new block. // Push back until we need a new block.
for (int RemainingCap = d.__capacity() - d.size(); RemainingCap >= 0; --RemainingCap) for (int RemainingCap = d.__capacity() - d.size(); RemainingCap >= 0; --RemainingCap)
d.push_back({}); d.push_back({});
{ {
TEST_REQUIRE(d.__block_count() == 2); TEST_REQUIRE(d.__block_count() == 2, on_fail);
TEST_REQUIRE(d.__front_spare_blocks() == 0); TEST_REQUIRE(d.__front_spare_blocks() == 0, on_fail);
TEST_REQUIRE(d.__back_spare_blocks() == 0); TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
TEST_REQUIRE(d.__back_spare() == 15); TEST_REQUIRE(d.__back_spare() == 15, on_fail);
} }
// Remove the only element in the new block. Test that we keep the empty // Remove the only element in the new block. Test that we keep the empty
// block as a spare. // block as a spare.
d.pop_back(); d.pop_back();
{ {
TEST_REQUIRE(d.__block_count() == 2); TEST_REQUIRE(d.__block_count() == 2, on_fail);
TEST_REQUIRE(d.__front_spare_blocks() == 0); TEST_REQUIRE(d.__front_spare_blocks() == 0, on_fail);
TEST_REQUIRE(d.__back_spare_blocks() == 1); TEST_REQUIRE(d.__back_spare_blocks() == 1, on_fail);
TEST_REQUIRE(d.__back_spare() == 16); TEST_REQUIRE(d.__back_spare() == 16, on_fail);
} }
// Pop back again, keep the spare. // Pop back again, keep the spare.
d.pop_back(); d.pop_back();
{ {
TEST_REQUIRE(d.__block_count() == 2); TEST_REQUIRE(d.__block_count() == 2, on_fail);
TEST_REQUIRE(d.__front_spare() == 0); TEST_REQUIRE(d.__front_spare() == 0, on_fail);
TEST_REQUIRE(d.__back_spare() == 17); TEST_REQUIRE(d.__back_spare() == 17, on_fail);
TEST_REQUIRE(d.__back_spare_blocks() == 1); TEST_REQUIRE(d.__back_spare_blocks() == 1, on_fail);
} }
dp.reset(); dp.reset();
TEST_REQUIRE(AllocBytes == 0); TEST_REQUIRE(AllocBytes == 0, on_fail);
} }
TEST_CASE(push_front) { static void push_front() {
std::unique_ptr<Deque<LargeT>> dp(new Deque<LargeT>); std::unique_ptr<Deque<LargeT>> dp(new Deque<LargeT>);
auto& d = *dp; auto& d = *dp;
PrintOnFailure<Deque<LargeT>> on_fail(d); PrintOnFailure<Deque<LargeT>> on_fail(d);
// Test nothing is allocated after default construction. // Test nothing is allocated after default construction.
{ {
TEST_REQUIRE(d.size() == 0); TEST_REQUIRE(d.size() == 0, on_fail);
TEST_REQUIRE(d.__capacity() == 0); TEST_REQUIRE(d.__capacity() == 0, on_fail);
TEST_REQUIRE(d.__block_count() == 0); TEST_REQUIRE(d.__block_count() == 0, on_fail);
} }
// First push front allocates one block, and we start the sequence in the // First push front allocates one block, and we start the sequence in the
// middle. // middle.
d.push_front({}); d.push_front({});
{ {
TEST_REQUIRE(d.size() == 1); TEST_REQUIRE(d.size() == 1, on_fail);
TEST_REQUIRE(d.__front_spare() == 7); TEST_REQUIRE(d.__front_spare() == 7, on_fail);
TEST_REQUIRE(d.__back_spare() == 7); TEST_REQUIRE(d.__back_spare() == 7, on_fail);
TEST_REQUIRE(d.__front_spare_blocks() == 0); TEST_REQUIRE(d.__front_spare_blocks() == 0, on_fail);
TEST_REQUIRE(d.__back_spare_blocks() == 0); TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
TEST_REQUIRE(d.__block_count() == 1); TEST_REQUIRE(d.__block_count() == 1, on_fail);
} }
d.push_front({}); d.push_front({});
{ {
TEST_REQUIRE(d.size() == 2); TEST_REQUIRE(d.size() == 2, on_fail);
TEST_REQUIRE(d.__front_spare() == 6); TEST_REQUIRE(d.__front_spare() == 6, on_fail);
TEST_REQUIRE(d.__back_spare() == 7); TEST_REQUIRE(d.__back_spare() == 7, on_fail);
TEST_REQUIRE(d.__front_spare_blocks() == 0); TEST_REQUIRE(d.__front_spare_blocks() == 0, on_fail);
TEST_REQUIRE(d.__back_spare_blocks() == 0); TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
} }
// Push front until we need a new block. // Push front until we need a new block.
for (int RemainingCap = d.__front_spare(); RemainingCap >= 0; --RemainingCap) for (int RemainingCap = d.__front_spare(); RemainingCap >= 0; --RemainingCap)
d.push_front({}); d.push_front({});
{ {
TEST_REQUIRE(d.__block_count() == 2); TEST_REQUIRE(d.__block_count() == 2, on_fail);
TEST_REQUIRE(d.__front_spare() == 15); TEST_REQUIRE(d.__front_spare() == 15, on_fail);
TEST_REQUIRE(d.__back_spare() == 7); TEST_REQUIRE(d.__back_spare() == 7, on_fail);
TEST_REQUIRE(d.__front_spare_blocks() == 0); TEST_REQUIRE(d.__front_spare_blocks() == 0, on_fail);
TEST_REQUIRE(d.__back_spare_blocks() == 0); TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
} }
// Remove the only element in the new block. Test that we keep the empty // Remove the only element in the new block. Test that we keep the empty
// block as a spare. // block as a spare.
d.pop_front(); d.pop_front();
{ {
TEST_REQUIRE(d.__block_count() == 2); TEST_REQUIRE(d.__block_count() == 2, on_fail);
TEST_REQUIRE(d.__front_spare_blocks() == 1); TEST_REQUIRE(d.__front_spare_blocks() == 1, on_fail);
TEST_REQUIRE(d.__back_spare_blocks() == 0); TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
TEST_REQUIRE(d.__back_spare() == 7); TEST_REQUIRE(d.__back_spare() == 7, on_fail);
} }
// Pop back again, keep the spare. // Pop back again, keep the spare.
d.pop_front(); d.pop_front();
{ {
TEST_REQUIRE(d.__block_count() == 2); TEST_REQUIRE(d.__block_count() == 2, on_fail);
TEST_REQUIRE(d.__front_spare_blocks() == 1); TEST_REQUIRE(d.__front_spare_blocks() == 1, on_fail);
TEST_REQUIRE(d.__back_spare() == 7); TEST_REQUIRE(d.__back_spare() == 7, on_fail);
} }
dp.reset(); dp.reset();
TEST_REQUIRE(AllocBytes == 0); TEST_REQUIRE(AllocBytes == 0, on_fail);
} }
TEST_CASE(std_queue) { static void std_queue() {
using D = Deque<LargeT>; using D = Deque<LargeT>;
using Queue = std::queue<LargeT, D>; using Queue = std::queue<LargeT, D>;
ContainerAdaptor<Queue> CA; ContainerAdaptor<Queue> CA;
const D& d = CA.GetContainer(); const D& d = CA.GetContainer();
Queue &q = CA; Queue &q = CA;
PrintOnFailure<Deque<LargeT>> on_fail(d); PrintOnFailure<Deque<LargeT>> on_fail(d);
while (d.__block_count() < 4) while (d.__block_count() < 4)
q.push({}); q.push({});
{ {
TEST_REQUIRE(d.__block_count() == 4); TEST_REQUIRE(d.__block_count() == 4, on_fail);
TEST_REQUIRE(d.__front_spare() == 0); TEST_REQUIRE(d.__front_spare() == 0, on_fail);
TEST_REQUIRE(d.__back_spare() == 15); TEST_REQUIRE(d.__back_spare() == 15, on_fail);
TEST_REQUIRE(d.__back_spare_blocks() == 0); TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
} }
while (d.__back_spare()) { while (d.__back_spare()) {
q.push({}); q.push({});
} }
{ {
TEST_REQUIRE(d.__block_count() == 4); TEST_REQUIRE(d.__block_count() == 4, on_fail);
TEST_REQUIRE(d.__front_spare() == 0); TEST_REQUIRE(d.__front_spare() == 0, on_fail);
TEST_REQUIRE(d.__back_spare() == 0); TEST_REQUIRE(d.__back_spare() == 0, on_fail);
} }
q.pop(); q.pop();
{ {
TEST_REQUIRE(d.__block_count() == 4); TEST_REQUIRE(d.__block_count() == 4, on_fail);
TEST_REQUIRE(d.__front_spare() == 1); TEST_REQUIRE(d.__front_spare() == 1, on_fail);
TEST_REQUIRE(d.__back_spare() == 0); TEST_REQUIRE(d.__back_spare() == 0, on_fail);
} }
// Pop until we create a spare block at the front. // Pop until we create a spare block at the front.
while (d.__front_spare() <= 15) while (d.__front_spare() <= 15)
q.pop(); q.pop();
{ {
TEST_REQUIRE(d.__block_count() == 4); TEST_REQUIRE(d.__block_count() == 4, on_fail);
TEST_REQUIRE(d.__front_spare_blocks() == 1); TEST_REQUIRE(d.__front_spare_blocks() == 1, on_fail);
TEST_REQUIRE(d.__front_spare() == 16); TEST_REQUIRE(d.__front_spare() == 16, on_fail);
TEST_REQUIRE(d.__back_spare() == 0); TEST_REQUIRE(d.__back_spare() == 0, on_fail);
} }
// Push at the end -- should re-use new spare block at front // Push at the end -- should re-use new spare block at front
q.push({}); q.push({});
{ {
TEST_REQUIRE(d.__block_count() == 4); TEST_REQUIRE(d.__block_count() == 4, on_fail);
TEST_REQUIRE(d.__front_spare_blocks() == 0); TEST_REQUIRE(d.__front_spare_blocks() == 0, on_fail);
TEST_REQUIRE(d.__front_spare() == 0); TEST_REQUIRE(d.__front_spare() == 0, on_fail);
TEST_REQUIRE(d.__back_spare() == 15); TEST_REQUIRE(d.__back_spare() == 15, on_fail);
} }
while (!q.empty()) { while (!q.empty()) {
q.pop(); q.pop();
TEST_REQUIRE(d.__front_spare_blocks() + d.__back_spare_blocks() <= 2); TEST_REQUIRE(d.__front_spare_blocks() + d.__back_spare_blocks() <= 2, on_fail);
} }
// The empty state has two blocks // The empty state has two blocks
{ {
TEST_REQUIRE(d.__front_spare() == 16); TEST_REQUIRE(d.__front_spare() == 16, on_fail);
TEST_REQUIRE(d.__back_spare() == 15); TEST_REQUIRE(d.__back_spare() == 15, on_fail);
TEST_REQUIRE(d.__capacity() == 31); TEST_REQUIRE(d.__capacity() == 31, on_fail);
} }
} }
TEST_CASE(pop_front_push_back) { static void pop_front_push_back() {
Deque<char> d(32 * 1024, 'a'); Deque<char> d(32 * 1024, 'a');
bool take_from_front = true; bool take_from_front = true;
while (d.size() > 0) { while (d.size() > 0) {
if (take_from_front) { if (take_from_front) {
d.pop_front(); d.pop_front();
take_from_front = false; take_from_front = false;
} else { } else {
d.pop_back(); d.pop_back();
take_from_front = true; take_from_front = true;
} }
if (d.size() % 1000 == 0 || d.size() < 50) { if (d.size() % 1000 == 0 || d.size() < 50) {
print(d); print(d);
} }
} }
} }
TEST_SUITE_END() int main(int, char**) {
push_back();
push_front();
std_queue();
pop_front_push_back();
return 0;
}

libcxx/test/libcxx/input.output/filesystems/class.directory_entry/directory_entry.mods/last_write_time.pass.cpp

Show All 21 Lines
// class directory_entry // class directory_entry
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
#include "filesystem_common.h" #include "filesystem_common.h"
using namespace fs::detail; using namespace fs::detail;
TEST_SUITE(directory_entry_mods_suite) static void last_write_time_not_representable_error() {
TEST_CASE(last_write_time_not_representable_error) {
using namespace fs; using namespace fs;
using namespace std::chrono; using namespace std::chrono;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
TimeSpec ToTime; TimeSpec ToTime;
ToTime.tv_sec = std::numeric_limits<decltype(ToTime.tv_sec)>::max(); ToTime.tv_sec = std::numeric_limits<decltype(ToTime.tv_sec)>::max();
ToTime.tv_nsec = duration_cast<nanoseconds>(seconds(1)).count() - 1; ToTime.tv_nsec = duration_cast<nanoseconds>(seconds(1)).count() - 1;
std::array<TimeSpec, 2> TS = {ToTime, ToTime}; std::array<TimeSpec, 2> TS = {ToTime, ToTime};
file_time_type old_time = last_write_time(file); file_time_type old_time = last_write_time(file);
directory_entry ent(file); directory_entry ent(file);
file_time_type start_time = file_time_type::clock::now() - hours(1); file_time_type start_time = file_time_type::clock::now() - hours(1);
last_write_time(file, start_time); last_write_time(file, start_time);
TEST_CHECK(ent.last_write_time() == old_time); assert(ent.last_write_time() == old_time);
bool IsRepresentable = true; bool IsRepresentable = true;
file_time_type rep_value; file_time_type rep_value;
{ {
std::error_code ec; std::error_code ec;
TEST_REQUIRE(!set_file_times(file, TS, ec)); assert(!set_file_times(file, TS, ec));
ec.clear(); ec.clear();
rep_value = last_write_time(file, ec); rep_value = last_write_time(file, ec);
IsRepresentable = !bool(ec); IsRepresentable = !bool(ec);
} }
if (!IsRepresentable) { if (!IsRepresentable) {
std::error_code rec = GetTestEC(); std::error_code rec = GetTestEC();
ent.refresh(rec); ent.refresh(rec);
TEST_CHECK(!rec); assert(!rec);
const std::errc expected_err = std::errc::value_too_large; const std::errc expected_err = std::errc::value_too_large;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == file_time_type::min()); assert(ent.last_write_time(ec) == file_time_type::min());
TEST_CHECK(ErrorIs(ec, expected_err)); assert(ErrorIs(ec, expected_err));
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(last_write_time(file, ec) == file_time_type::min()); assert(last_write_time(file, ec) == file_time_type::min());
TEST_CHECK(ErrorIs(ec, expected_err)); assert(ErrorIs(ec, expected_err));
ExceptionChecker CheckExcept(file, expected_err, ExceptionChecker CheckExcept(file, expected_err,
"directory_entry::last_write_time"); "directory_entry::last_write_time");
TEST_CHECK_THROW_RESULT(filesystem_error, CheckExcept, TEST_VALIDATE_EXCEPTION(filesystem_error, CheckExcept,
ent.last_write_time()); ent.last_write_time());
} else { } else {
ent.refresh(); ent.refresh();
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == rep_value); assert(ent.last_write_time(ec) == rep_value);
TEST_CHECK(!ec); assert(!ec);
} }
} }
TEST_SUITE_END() int main(int, char**) {
last_write_time_not_representable_error();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy.pass.cpp

Show All 13 Lines
// directory_entry(const directory_entry&) = default; // directory_entry(const directory_entry&) = default;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
#include "test_convertible.h" #include "test_convertible.h"
TEST_SUITE(directory_entry_path_ctor_suite) static void copy_ctor() {
TEST_CASE(copy_ctor) {
using namespace fs; using namespace fs;
// Copy // Copy
{ {
static_assert(std::is_copy_constructible<directory_entry>::value, static_assert(std::is_copy_constructible<directory_entry>::value,
"directory_entry must be copy constructible"); "directory_entry must be copy constructible");
static_assert(!std::is_nothrow_copy_constructible<directory_entry>::value, static_assert(!std::is_nothrow_copy_constructible<directory_entry>::value,
"directory_entry's copy constructor cannot be noexcept"); "directory_entry's copy constructor cannot be noexcept");
const path p("foo/bar/baz"); const path p("foo/bar/baz");
const directory_entry e(p); const directory_entry e(p);
assert(e.path() == p); assert(e.path() == p);
directory_entry e2(e); directory_entry e2(e);
assert(e.path() == p); assert(e.path() == p);
assert(e2.path() == p); assert(e2.path() == p);
} }
} }
TEST_CASE(copy_ctor_copies_cache) { static void copy_ctor_copies_cache() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path sym = env.create_symlink("dir/file", "sym"); const path sym = env.create_symlink("dir/file", "sym");
{ {
directory_entry ent(sym); directory_entry ent(sym);
fs::remove(sym); fs::remove(sym);
directory_entry ent_cp(ent); directory_entry ent_cp(ent);
TEST_CHECK(ent_cp.path() == sym); assert(ent_cp.path() == sym);
TEST_CHECK(ent_cp.is_symlink()); assert(ent_cp.is_symlink());
} }
{ {
directory_entry ent(file); directory_entry ent(file);
fs::remove(file); fs::remove(file);
directory_entry ent_cp(ent); directory_entry ent_cp(ent);
TEST_CHECK(ent_cp.path() == file); assert(ent_cp.path() == file);
TEST_CHECK(ent_cp.is_regular_file()); assert(ent_cp.is_regular_file());
} }
} }
TEST_SUITE_END() int main(int, char**) {
copy_ctor();
copy_ctor_copies_cache();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy_assign.pass.cpp

Show All 16 Lines
// void assign(path const&); // void assign(path const&);
// void replace_filename(path const&); // void replace_filename(path const&);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
TEST_SUITE(directory_entry_ctor_suite) static void test_copy_assign_operator() {
TEST_CASE(test_copy_assign_operator) {
using namespace fs; using namespace fs;
// Copy // Copy
{ {
static_assert(std::is_copy_assignable<directory_entry>::value, static_assert(std::is_copy_assignable<directory_entry>::value,
"directory_entry must be copy assignable"); "directory_entry must be copy assignable");
static_assert(!std::is_nothrow_copy_assignable<directory_entry>::value, static_assert(!std::is_nothrow_copy_assignable<directory_entry>::value,
"directory_entry's copy assignment cannot be noexcept"); "directory_entry's copy assignment cannot be noexcept");
const path p("foo/bar/baz"); const path p("foo/bar/baz");
const path p2("abc"); const path p2("abc");
const directory_entry e(p); const directory_entry e(p);
directory_entry e2; directory_entry e2;
assert(e.path() == p && e2.path() == path()); assert(e.path() == p && e2.path() == path());
e2 = e; e2 = e;
assert(e.path() == p && e2.path() == p); assert(e.path() == p && e2.path() == p);
directory_entry e3(p2); directory_entry e3(p2);
e2 = e3; e2 = e3;
assert(e2.path() == p2 && e3.path() == p2); assert(e2.path() == p2 && e3.path() == p2);
} }
} }
TEST_CASE(copy_assign_copies_cache) { static void copy_assign_copies_cache() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path sym = env.create_symlink("dir/file", "sym"); const path sym = env.create_symlink("dir/file", "sym");
{ {
directory_entry ent(sym); directory_entry ent(sym);
fs::remove(sym); fs::remove(sym);
directory_entry ent_cp; directory_entry ent_cp;
ent_cp = ent; ent_cp = ent;
TEST_CHECK(ent_cp.path() == sym); assert(ent_cp.path() == sym);
TEST_CHECK(ent_cp.is_symlink()); assert(ent_cp.is_symlink());
} }
{ {
directory_entry ent(file); directory_entry ent(file);
fs::remove(file); fs::remove(file);
directory_entry ent_cp; directory_entry ent_cp;
ent_cp = ent; ent_cp = ent;
TEST_CHECK(ent_cp.path() == file); assert(ent_cp.path() == file);
TEST_CHECK(ent_cp.is_regular_file()); assert(ent_cp.is_regular_file());
} }
} }
TEST_SUITE_END() int main(int, char**) {
test_copy_assign_operator();
copy_assign_copies_cache();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move.pass.cpp

Show All 13 Lines
// directory_entry(directory_entry&&) noexcept = default; // directory_entry(directory_entry&&) noexcept = default;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
#include "test_convertible.h" #include "test_convertible.h"
TEST_SUITE(directory_entry_path_ctor_suite) static void move_ctor() {
TEST_CASE(move_ctor) {
using namespace fs; using namespace fs;
// Move // Move
{ {
static_assert(std::is_nothrow_move_constructible<directory_entry>::value, static_assert(std::is_nothrow_move_constructible<directory_entry>::value,
"directory_entry must be nothrow move constructible"); "directory_entry must be nothrow move constructible");
const path p("foo/bar/baz"); const path p("foo/bar/baz");
directory_entry e(p); directory_entry e(p);
assert(e.path() == p); assert(e.path() == p);
directory_entry e2(std::move(e)); directory_entry e2(std::move(e));
assert(e2.path() == p); assert(e2.path() == p);
assert(e.path() != p); // Testing moved from state. assert(e.path() != p); // Testing moved from state.
} }
} }
TEST_CASE(move_ctor_copies_cache) { static void move_ctor_copies_cache() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path sym = env.create_symlink("dir/file", "sym"); const path sym = env.create_symlink("dir/file", "sym");
{ {
directory_entry ent(sym); directory_entry ent(sym);
fs::remove(sym); fs::remove(sym);
directory_entry ent_cp(std::move(ent)); directory_entry ent_cp(std::move(ent));
TEST_CHECK(ent_cp.path() == sym); assert(ent_cp.path() == sym);
TEST_CHECK(ent_cp.is_symlink()); assert(ent_cp.is_symlink());
} }
{ {
directory_entry ent(file); directory_entry ent(file);
fs::remove(file); fs::remove(file);
directory_entry ent_cp(std::move(ent)); directory_entry ent_cp(std::move(ent));
TEST_CHECK(ent_cp.path() == file); assert(ent_cp.path() == file);
TEST_CHECK(ent_cp.is_regular_file()); assert(ent_cp.is_regular_file());
} }
} }
TEST_SUITE_END() int main(int, char**) {
move_ctor();
move_ctor_copies_cache();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move_assign.pass.cpp

Show All 16 Lines
// void assign(path const&); // void assign(path const&);
// void replace_filename(path const&); // void replace_filename(path const&);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
TEST_SUITE(directory_entry_ctor_suite) static void test_move_assign_operator() {
TEST_CASE(test_move_assign_operator) {
using namespace fs; using namespace fs;
// Copy // Copy
{ {
static_assert(std::is_nothrow_move_assignable<directory_entry>::value, static_assert(std::is_nothrow_move_assignable<directory_entry>::value,
"directory_entry is noexcept move assignable"); "directory_entry is noexcept move assignable");
const path p("foo/bar/baz"); const path p("foo/bar/baz");
const path p2("abc"); const path p2("abc");
directory_entry e(p); directory_entry e(p);
directory_entry e2(p2); directory_entry e2(p2);
assert(e.path() == p && e2.path() == p2); assert(e.path() == p && e2.path() == p2);
e2 = std::move(e); e2 = std::move(e);
assert(e2.path() == p); assert(e2.path() == p);
assert(e.path() != p); // testing moved from state assert(e.path() != p); // testing moved from state
} }
} }
TEST_CASE(move_assign_copies_cache) { static void move_assign_copies_cache() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path sym = env.create_symlink("dir/file", "sym"); const path sym = env.create_symlink("dir/file", "sym");
{ {
directory_entry ent(sym); directory_entry ent(sym);
fs::remove(sym); fs::remove(sym);
directory_entry ent_cp; directory_entry ent_cp;
ent_cp = std::move(ent); ent_cp = std::move(ent);
TEST_CHECK(ent_cp.path() == sym); assert(ent_cp.path() == sym);
TEST_CHECK(ent_cp.is_symlink()); assert(ent_cp.is_symlink());
} }
{ {
directory_entry ent(file); directory_entry ent(file);
fs::remove(file); fs::remove(file);
directory_entry ent_cp; directory_entry ent_cp;
ent_cp = std::move(ent); ent_cp = std::move(ent);
TEST_CHECK(ent_cp.path() == file); assert(ent_cp.path() == file);
TEST_CHECK(ent_cp.is_regular_file()); assert(ent_cp.is_regular_file());
} }
} }
TEST_SUITE_END() int main(int, char**) {
test_move_assign_operator();
move_assign_copies_cache();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/path.pass.cpp

Show All 14 Lines
// explicit directory_entry(const path); // explicit directory_entry(const path);
// directory_entry(const path&, error_code& ec); // directory_entry(const path&, error_code& ec);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
#include "test_convertible.h" #include "test_convertible.h"
TEST_SUITE(directory_entry_path_ctor_suite) static void path_ctor() {
TEST_CASE(path_ctor) {
using namespace fs; using namespace fs;
{ {
static_assert(std::is_constructible<directory_entry, const path&>::value, static_assert(std::is_constructible<directory_entry, const path&>::value,
"directory_entry must be constructible from path"); "directory_entry must be constructible from path");
static_assert( static_assert(
!std::is_nothrow_constructible<directory_entry, const path&>::value, !std::is_nothrow_constructible<directory_entry, const path&>::value,
"directory_entry constructor should not be noexcept"); "directory_entry constructor should not be noexcept");
static_assert(!std::is_convertible<path const&, directory_entry>::value, static_assert(!std::is_convertible<path const&, directory_entry>::value,
"directory_entry constructor should be explicit"); "directory_entry constructor should be explicit");
} }
{ {
const path p("foo/bar/baz"); const path p("foo/bar/baz");
const directory_entry e(p); const directory_entry e(p);
TEST_CHECK(e.path() == p); assert(e.path() == p);
} }
} }
TEST_CASE(path_ec_ctor) { static void path_ec_ctor() {
static_test_env static_env; static_test_env static_env;
using namespace fs; using namespace fs;
{ {
static_assert( static_assert(
std::is_constructible<directory_entry, const path&, std::is_constructible<directory_entry, const path&,
std::error_code&>::value, std::error_code&>::value,
"directory_entry must be constructible from path and error_code"); "directory_entry must be constructible from path and error_code");
static_assert(!std::is_nothrow_constructible<directory_entry, const path&, static_assert(!std::is_nothrow_constructible<directory_entry, const path&,
std::error_code&>::value, std::error_code&>::value,
"directory_entry constructor should not be noexcept"); "directory_entry constructor should not be noexcept");
static_assert( static_assert(
test_convertible<directory_entry, const path&, std::error_code&>(), test_convertible<directory_entry, const path&, std::error_code&>(),
"directory_entry constructor should not be explicit"); "directory_entry constructor should not be explicit");
} }
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
const directory_entry e(static_env.File, ec); const directory_entry e(static_env.File, ec);
TEST_CHECK(e.path() == static_env.File); assert(e.path() == static_env.File);
TEST_CHECK(!ec); assert(!ec);
} }
{ {
const path p("foo/bar/baz"); const path p("foo/bar/baz");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
const directory_entry e(p, ec); const directory_entry e(p, ec);
TEST_CHECK(e.path() == p); assert(e.path() == p);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
} }
} }
TEST_CASE(path_ctor_calls_refresh) { static void path_ctor_calls_refresh() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path sym = env.create_symlink("dir/file", "sym"); const path sym = env.create_symlink("dir/file", "sym");
{ {
directory_entry ent(file); directory_entry ent(file);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
directory_entry ent_ec(file, ec); directory_entry ent_ec(file, ec);
TEST_CHECK(!ec); assert(!ec);
LIBCPP_ONLY(remove(file)); LIBCPP_ONLY(remove(file));
TEST_CHECK(ent.exists()); assert(ent.exists());
TEST_CHECK(ent_ec.exists()); assert(ent_ec.exists());
TEST_CHECK(ent.file_size() == 42); assert(ent.file_size() == 42);
TEST_CHECK(ent_ec.file_size() == 42); assert(ent_ec.file_size() == 42);
} }
env.create_file("dir/file", 101); env.create_file("dir/file", 101);
{ {
directory_entry ent(sym); directory_entry ent(sym);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
directory_entry ent_ec(sym, ec); directory_entry ent_ec(sym, ec);
TEST_CHECK(!ec); assert(!ec);
LIBCPP_ONLY(remove(file)); LIBCPP_ONLY(remove(file));
LIBCPP_ONLY(remove(sym)); LIBCPP_ONLY(remove(sym));
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
TEST_CHECK(ent_ec.is_symlink()); assert(ent_ec.is_symlink());
TEST_CHECK(ent.is_regular_file()); assert(ent.is_regular_file());
TEST_CHECK(ent_ec.is_regular_file()); assert(ent_ec.is_regular_file());
TEST_CHECK(ent.file_size() == 101); assert(ent.file_size() == 101);
TEST_CHECK(ent_ec.file_size() == 101); assert(ent_ec.file_size() == 101);
} }
} }
TEST_CASE(path_ctor_dne) { static void path_ctor_dne() {
using namespace fs; using namespace fs;
static_test_env static_env; static_test_env static_env;
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
directory_entry ent(static_env.DNE, ec); directory_entry ent(static_env.DNE, ec);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
TEST_CHECK(ent.path() == static_env.DNE); assert(ent.path() == static_env.DNE);
} }
// don't report dead symlinks as an error. // don't report dead symlinks as an error.
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
directory_entry ent(static_env.BadSymlink, ec); directory_entry ent(static_env.BadSymlink, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(ent.path() == static_env.BadSymlink); assert(ent.path() == static_env.BadSymlink);
} }
// DNE does not cause the constructor to throw // DNE does not cause the constructor to throw
{ {
directory_entry ent(static_env.DNE); directory_entry ent(static_env.DNE);
TEST_CHECK(ent.path() == static_env.DNE); assert(ent.path() == static_env.DNE);
directory_entry ent_two(static_env.BadSymlink); directory_entry ent_two(static_env.BadSymlink);
TEST_CHECK(ent_two.path() == static_env.BadSymlink); assert(ent_two.path() == static_env.BadSymlink);
} }
} }
TEST_CASE(path_ctor_cannot_resolve) { static void path_ctor_cannot_resolve() {
using namespace fs; using namespace fs;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path dir = GetWindowsInaccessibleDir(); const path dir = GetWindowsInaccessibleDir();
if (dir.empty()) if (dir.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
const path file = dir / "file"; const path file = dir / "file";
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
directory_entry ent(file, ec); directory_entry ent(file, ec);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
TEST_CHECK(ent.path() == file); assert(ent.path() == file);
} }
{ {
TEST_CHECK_NO_THROW(directory_entry(file)); TEST_DOES_NOT_THROW(directory_entry(file));
} }
#else #else
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path file_out_of_dir = env.create_file("file1", 101); const path file_out_of_dir = env.create_file("file1", 101);
const path sym_out_of_dir = env.create_symlink("dir/file", "sym"); const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
const path sym_in_dir = env.create_symlink("dir/file1", "dir/sym2"); const path sym_in_dir = env.create_symlink("dir/file1", "dir/sym2");
permissions(dir, perms::none); permissions(dir, perms::none);
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
directory_entry ent(file, ec); directory_entry ent(file, ec);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
TEST_CHECK(ent.path() == file); assert(ent.path() == file);
} }
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
directory_entry ent(sym_in_dir, ec); directory_entry ent(sym_in_dir, ec);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
TEST_CHECK(ent.path() == sym_in_dir); assert(ent.path() == sym_in_dir);
} }
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
directory_entry ent(sym_out_of_dir, ec); directory_entry ent(sym_out_of_dir, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(ent.path() == sym_out_of_dir); assert(ent.path() == sym_out_of_dir);
} }
{ {
TEST_CHECK_NO_THROW(directory_entry(file)); TEST_DOES_NOT_THROW(directory_entry(file));
TEST_CHECK_NO_THROW(directory_entry(sym_in_dir)); TEST_DOES_NOT_THROW(directory_entry(sym_in_dir));
TEST_CHECK_NO_THROW(directory_entry(sym_out_of_dir)); TEST_DOES_NOT_THROW(directory_entry(sym_out_of_dir));
} }
#endif #endif
} }
TEST_SUITE_END() int main(int, char**) {
path_ctor();
path_ec_ctor();
path_ctor_calls_refresh();
path_ctor_dne();
path_ctor_cannot_resolve();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/assign.pass.cpp

Show All 16 Lines
// void assign(path const&); // void assign(path const&);
// void replace_filename(path const&); // void replace_filename(path const&);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
TEST_SUITE(directory_entry_mods_suite) static void test_path_assign_method() {
TEST_CASE(test_path_assign_method) {
using namespace fs; using namespace fs;
const path p("foo/bar/baz"); const path p("foo/bar/baz");
const path p2("abc"); const path p2("abc");
directory_entry e(p); directory_entry e(p);
{ {
static_assert(std::is_same<decltype(e.assign(p)), void>::value, static_assert(std::is_same<decltype(e.assign(p)), void>::value,
"return type should be void"); "return type should be void");
static_assert(noexcept(e.assign(p)) == false, static_assert(noexcept(e.assign(p)) == false,
"operation must not be noexcept"); "operation must not be noexcept");
} }
{ {
TEST_CHECK(e.path() == p); assert(e.path() == p);
e.assign(p2); e.assign(p2);
TEST_CHECK(e.path() == p2 && e.path() != p); assert(e.path() == p2 && e.path() != p);
e.assign(p); e.assign(p);
TEST_CHECK(e.path() == p && e.path() != p2); assert(e.path() == p && e.path() != p2);
} }
} }
TEST_CASE(test_path_assign_ec_method) { static void test_path_assign_ec_method() {
using namespace fs; using namespace fs;
const path p("foo/bar/baz"); const path p("foo/bar/baz");
const path p2("abc"); const path p2("abc");
{ {
std::error_code ec; std::error_code ec;
directory_entry e(p); directory_entry e(p);
static_assert(std::is_same<decltype(e.assign(p, ec)), void>::value, static_assert(std::is_same<decltype(e.assign(p, ec)), void>::value,
"return type should be void"); "return type should be void");
static_assert(noexcept(e.assign(p, ec)) == false, static_assert(noexcept(e.assign(p, ec)) == false,
"operation must not be noexcept"); "operation must not be noexcept");
} }
{ {
directory_entry ent(p); directory_entry ent(p);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(p2, ec); ent.assign(p2, ec);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
TEST_CHECK(ent.path() == p2); assert(ent.path() == p2);
} }
} }
TEST_CASE(test_assign_calls_refresh) { static void test_assign_calls_refresh() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path sym = env.create_symlink("dir/file", "sym"); const path sym = env.create_symlink("dir/file", "sym");
{ {
directory_entry ent; directory_entry ent;
ent.assign(file); ent.assign(file);
// removing the file demonstrates that the values where cached previously. // removing the file demonstrates that the values where cached previously.
LIBCPP_ONLY(remove(file)); LIBCPP_ONLY(remove(file));
TEST_CHECK(ent.is_regular_file()); assert(ent.is_regular_file());
} }
env.create_file("dir/file", 101); env.create_file("dir/file", 101);
{ {
directory_entry ent; directory_entry ent;
ent.assign(sym); ent.assign(sym);
LIBCPP_ONLY(remove(file)); LIBCPP_ONLY(remove(file));
LIBCPP_ONLY(remove(sym)); LIBCPP_ONLY(remove(sym));
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
TEST_CHECK(ent.is_regular_file()); assert(ent.is_regular_file());
} }
} }
TEST_CASE(test_assign_propagates_error) { static void test_assign_propagates_error() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path dir = GetWindowsInaccessibleDir(); const path dir = GetWindowsInaccessibleDir();
if (dir.empty()) if (dir.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
const path file = dir / "inaccessible_file"; const path file = dir / "inaccessible_file";
// We can't create files in the inaccessible directory, so this doesn't // We can't create files in the inaccessible directory, so this doesn't
// test exactly the same as the code below. // test exactly the same as the code below.
const path sym_out_of_dir = env.create_symlink(file, "sym"); const path sym_out_of_dir = env.create_symlink(file, "sym");
{ {
directory_entry ent; directory_entry ent;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(file, ec); ent.assign(file, ec);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
} }
#else #else
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path sym_out_of_dir = env.create_symlink("dir/file", "sym"); const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
const path file_out_of_dir = env.create_file("file1"); const path file_out_of_dir = env.create_file("file1");
const path sym_in_dir = env.create_symlink("file1", "dir/sym1"); const path sym_in_dir = env.create_symlink("file1", "dir/sym1");
permissions(dir, perms::none); permissions(dir, perms::none);
{ {
directory_entry ent; directory_entry ent;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(file, ec); ent.assign(file, ec);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
} }
{ {
directory_entry ent; directory_entry ent;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(sym_in_dir, ec); ent.assign(sym_in_dir, ec);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
} }
#endif #endif
{ {
directory_entry ent; directory_entry ent;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(sym_out_of_dir, ec); ent.assign(sym_out_of_dir, ec);
TEST_CHECK(!ec); assert(!ec);
} }
} }
TEST_SUITE_END() int main(int, char**) {
test_path_assign_method();
test_path_assign_ec_method();
test_assign_calls_refresh();
test_assign_propagates_error();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/refresh.pass.cpp

Show All 20 Lines
// void assign(path const&); // void assign(path const&);
// void replace_filename(path const&); // void replace_filename(path const&);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
TEST_SUITE(directory_entry_mods_suite) static void test_refresh_method() {
TEST_CASE(test_refresh_method) {
using namespace fs; using namespace fs;
{ {
directory_entry e; directory_entry e;
static_assert(noexcept(e.refresh()) == false, static_assert(noexcept(e.refresh()) == false,
"operation cannot be noexcept"); "operation cannot be noexcept");
static_assert(std::is_same<decltype(e.refresh()), void>::value, static_assert(std::is_same<decltype(e.refresh()), void>::value,
"operation must return void"); "operation must return void");
} }
{ {
directory_entry e; directory_entry e;
e.refresh(); e.refresh();
TEST_CHECK(!e.exists()); assert(!e.exists());
} }
} }
TEST_CASE(test_refresh_ec_method) { static void test_refresh_ec_method() {
using namespace fs; using namespace fs;
{ {
directory_entry e; directory_entry e;
std::error_code ec; std::error_code ec;
static_assert(noexcept(e.refresh(ec)), "operation should be noexcept"); static_assert(noexcept(e.refresh(ec)), "operation should be noexcept");
static_assert(std::is_same<decltype(e.refresh(ec)), void>::value, static_assert(std::is_same<decltype(e.refresh(ec)), void>::value,
"operation must return void"); "operation must return void");
} }
{ {
directory_entry e; directory_entry e;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
e.refresh(ec); e.refresh(ec);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
} }
} }
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. // reading directories.
TEST_CASE(refresh_on_file_dne) { static void refresh_on_file_dne() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const perms old_perms = status(dir).permissions(); const perms old_perms = status(dir).permissions();
// test file doesn't exist // test file doesn't exist
{ {
directory_entry ent(file); directory_entry ent(file);
remove(file); remove(file);
TEST_CHECK(ent.exists()); assert(ent.exists());
ent.refresh(); ent.refresh();
permissions(dir, perms::none); permissions(dir, perms::none);
TEST_CHECK(!ent.exists()); assert(!ent.exists());
} }
permissions(dir, old_perms); permissions(dir, old_perms);
env.create_file("dir/file", 101); env.create_file("dir/file", 101);
{ {
directory_entry ent(file); directory_entry ent(file);
remove(file); remove(file);
TEST_CHECK(ent.exists()); assert(ent.exists());
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.refresh(ec); ent.refresh(ec);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
permissions(dir, perms::none); permissions(dir, perms::none);
TEST_CHECK(!ent.exists()); assert(!ent.exists());
} }
} }
#endif #endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
void remove_if_exists(const fs::path& p) { void remove_if_exists(const fs::path& p) {
std::error_code ec; std::error_code ec;
remove(p, ec); remove(p, ec);
} }
TEST_CASE(refresh_on_bad_symlink) { static void refresh_on_bad_symlink() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path sym = env.create_symlink("dir/file", "sym"); const path sym = env.create_symlink("dir/file", "sym");
const perms old_perms = status(dir).permissions(); const perms old_perms = status(dir).permissions();
// test file doesn't exist // test file doesn't exist
{ {
directory_entry ent(sym); directory_entry ent(sym);
LIBCPP_ONLY(remove(file)); LIBCPP_ONLY(remove(file));
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
TEST_CHECK(ent.is_regular_file()); assert(ent.is_regular_file());
TEST_CHECK(ent.exists()); assert(ent.exists());
remove_if_exists(file); remove_if_exists(file);
ent.refresh(); ent.refresh();
LIBCPP_ONLY(permissions(dir, perms::none)); LIBCPP_ONLY(permissions(dir, perms::none));
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_CHECK(!ent.is_regular_file()); assert(!ent.is_regular_file());
TEST_CHECK(!ent.exists()); assert(!ent.exists());
#endif #endif
} }
permissions(dir, old_perms); permissions(dir, old_perms);
env.create_file("dir/file", 101); env.create_file("dir/file", 101);
{ {
directory_entry ent(sym); directory_entry ent(sym);
LIBCPP_ONLY(remove(file)); LIBCPP_ONLY(remove(file));
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
TEST_CHECK(ent.is_regular_file()); assert(ent.is_regular_file());
TEST_CHECK(ent.exists()); assert(ent.exists());
remove_if_exists(file); remove_if_exists(file);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.refresh(ec); ent.refresh(ec);
TEST_CHECK(!ec); // we don't report bad symlinks as an error. assert(!ec); // we don't report bad symlinks as an error.
LIBCPP_ONLY(permissions(dir, perms::none)); LIBCPP_ONLY(permissions(dir, perms::none));
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_CHECK(!ent.exists()); assert(!ent.exists());
#endif #endif
} }
} }
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. // reading directories.
TEST_CASE(refresh_cannot_resolve) { static void refresh_cannot_resolve() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path file_out_of_dir = env.create_file("file1", 99); const path file_out_of_dir = env.create_file("file1", 99);
const path sym_out_of_dir = env.create_symlink("dir/file", "sym"); const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
const path sym_in_dir = env.create_symlink("file1", "dir/sym1"); const path sym_in_dir = env.create_symlink("file1", "dir/sym1");
perms old_perms = status(dir).permissions(); perms old_perms = status(dir).permissions();
{ {
directory_entry ent(file); directory_entry ent(file);
permissions(dir, perms::none); permissions(dir, perms::none);
TEST_CHECK(ent.is_regular_file()); assert(ent.is_regular_file());
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.refresh(ec); ent.refresh(ec);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
TEST_CHECK(ent.path() == file); assert(ent.path() == file);
ExceptionChecker Checker(file, std::errc::permission_denied, ExceptionChecker Checker(file, std::errc::permission_denied,
"directory_entry::refresh"); "directory_entry::refresh");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.refresh()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.refresh());
} }
permissions(dir, old_perms); permissions(dir, old_perms);
{ {
directory_entry ent(sym_in_dir); directory_entry ent(sym_in_dir);
permissions(dir, perms::none); permissions(dir, perms::none);
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.refresh(ec); ent.refresh(ec);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
TEST_CHECK(ent.path() == sym_in_dir); assert(ent.path() == sym_in_dir);
ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied, ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied,
"directory_entry::refresh"); "directory_entry::refresh");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.refresh()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.refresh());
} }
permissions(dir, old_perms); permissions(dir, old_perms);
{ {
directory_entry ent(sym_out_of_dir); directory_entry ent(sym_out_of_dir);
permissions(dir, perms::none); permissions(dir, perms::none);
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
// Failure to resolve the linked entity due to permissions is not // Failure to resolve the linked entity due to permissions is not
// reported as an error. // reported as an error.
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.refresh(ec); ent.refresh(ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.exists(ec) == false); assert(ent.exists(ec) == false);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
TEST_CHECK(ent.path() == sym_out_of_dir); assert(ent.path() == sym_out_of_dir);
} }
permissions(dir, old_perms); permissions(dir, old_perms);
{ {
directory_entry ent_file(file); directory_entry ent_file(file);
directory_entry ent_sym(sym_in_dir); directory_entry ent_sym(sym_in_dir);
directory_entry ent_sym2(sym_out_of_dir); directory_entry ent_sym2(sym_out_of_dir);
permissions(dir, perms::none); permissions(dir, perms::none);
((void)ent_file); ((void)ent_file);
((void)ent_sym); ((void)ent_sym);
TEST_CHECK_THROW(filesystem_error, ent_file.refresh()); TEST_THROWS_TYPE(filesystem_error, ent_file.refresh());
TEST_CHECK_THROW(filesystem_error, ent_sym.refresh()); TEST_THROWS_TYPE(filesystem_error, ent_sym.refresh());
TEST_CHECK_NO_THROW(ent_sym2);
} }
} }
#endif #endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_CASE(refresh_doesnt_throw_on_dne_but_reports_it) { static void refresh_doesnt_throw_on_dne_but_reports_it() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file1", 42); const path file = env.create_file("file1", 42);
const path sym = env.create_symlink("file1", "sym"); const path sym = env.create_symlink("file1", "sym");
{ {
directory_entry ent(file); directory_entry ent(file);
TEST_CHECK(ent.file_size() == 42); assert(ent.file_size() == 42);
remove(file); remove(file);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.refresh(ec); ent.refresh(ec);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
TEST_CHECK_NO_THROW(ent.refresh()); TEST_DOES_NOT_THROW(ent.refresh());
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.file_size(ec) == uintmax_t(-1)); assert(ent.file_size(ec) == uintmax_t(-1));
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
// doesn't throw! // doesn't throw!
TEST_CHECK_THROW(filesystem_error, ent.file_size()); //
//
//
//TEST_THROWS_TYPE(filesystem_error, ent.file_size());
} }
env.create_file("file1", 99); env.create_file("file1", 99);
{ {
directory_entry ent(sym); directory_entry ent(sym);
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
TEST_CHECK(ent.is_regular_file()); assert(ent.is_regular_file());
TEST_CHECK(ent.file_size() == 99); assert(ent.file_size() == 99);
remove(file); remove(file);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.refresh(ec); ent.refresh(ec);
TEST_CHECK(!ec); assert(!ec);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.file_size(ec) == uintmax_t(-1)); assert(ent.file_size(ec) == uintmax_t(-1));
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
TEST_CHECK_THROW(filesystem_error, ent.file_size()); TEST_THROWS_TYPE(filesystem_error, ent.file_size());
} }
} }
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. // reading directories.
TEST_CASE(access_cache_after_refresh_fails) { static void access_cache_after_refresh_fails() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path file_out_of_dir = env.create_file("file1", 101); const path file_out_of_dir = env.create_file("file1", 101);
const path sym = env.create_symlink("dir/file", "sym"); const path sym = env.create_symlink("dir/file", "sym");
const path sym_in_dir = env.create_symlink("dir/file", "dir/sym2"); const path sym_in_dir = env.create_symlink("dir/file", "dir/sym2");
const perms old_perms = status(dir).permissions(); const perms old_perms = status(dir).permissions();
#define CHECK_ACCESS(func, expect) \ #define CHECK_ACCESS(func, expect) \
ec = GetTestEC(); \ ec = GetTestEC(); \
TEST_CHECK(ent.func(ec) == expect); \ assert(ent.func(ec) == expect); \
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)) assert(ErrorIs(ec, std::errc::permission_denied))
// test file doesn't exist // test file doesn't exist
{ {
directory_entry ent(file); directory_entry ent(file);
TEST_CHECK(!ent.is_symlink()); assert(!ent.is_symlink());
TEST_CHECK(ent.is_regular_file()); assert(ent.is_regular_file());
TEST_CHECK(ent.exists()); assert(ent.exists());
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.refresh(ec); ent.refresh(ec);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
CHECK_ACCESS(exists, false); CHECK_ACCESS(exists, false);
CHECK_ACCESS(is_symlink, false); CHECK_ACCESS(is_symlink, false);
CHECK_ACCESS(last_write_time, file_time_type::min()); CHECK_ACCESS(last_write_time, file_time_type::min());
CHECK_ACCESS(hard_link_count, uintmax_t(-1)); CHECK_ACCESS(hard_link_count, uintmax_t(-1));
} }
permissions(dir, old_perms); permissions(dir, old_perms);
{ {
directory_entry ent(sym_in_dir); directory_entry ent(sym_in_dir);
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
TEST_CHECK(ent.is_regular_file()); assert(ent.is_regular_file());
TEST_CHECK(ent.exists()); assert(ent.exists());
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.refresh(ec); ent.refresh(ec);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
CHECK_ACCESS(exists, false); CHECK_ACCESS(exists, false);
CHECK_ACCESS(is_symlink, false); CHECK_ACCESS(is_symlink, false);
CHECK_ACCESS(last_write_time, file_time_type::min()); CHECK_ACCESS(last_write_time, file_time_type::min());
CHECK_ACCESS(hard_link_count, uintmax_t(-1)); CHECK_ACCESS(hard_link_count, uintmax_t(-1));
} }
permissions(dir, old_perms); permissions(dir, old_perms);
{ {
directory_entry ent(sym); directory_entry ent(sym);
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
TEST_CHECK(ent.is_regular_file()); assert(ent.is_regular_file());
TEST_CHECK(ent.exists()); assert(ent.exists());
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.refresh(ec); ent.refresh(ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
CHECK_ACCESS(exists, false); CHECK_ACCESS(exists, false);
CHECK_ACCESS(is_regular_file, false); CHECK_ACCESS(is_regular_file, false);
CHECK_ACCESS(last_write_time, file_time_type::min()); CHECK_ACCESS(last_write_time, file_time_type::min());
CHECK_ACCESS(hard_link_count, uintmax_t(-1)); CHECK_ACCESS(hard_link_count, uintmax_t(-1));
} }
#undef CHECK_ACCESS #undef CHECK_ACCESS
} }
#endif #endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_SUITE_END() int main(int, char**) {
test_refresh_method();
test_refresh_ec_method();
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
refresh_on_file_dne();
#endif
refresh_on_bad_symlink();
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
refresh_cannot_resolve();
#endif
refresh_doesnt_throw_on_dne_but_reports_it();
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
access_cache_after_refresh_fails();
#endif
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/replace_filename.pass.cpp

Show All 16 Lines
// void assign(path const&); // void assign(path const&);
// void replace_filename(path const&); // void replace_filename(path const&);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
TEST_SUITE(directory_entry_mods_suite) static void test_replace_filename_method() {
TEST_CASE(test_replace_filename_method) {
using namespace fs; using namespace fs;
{ {
directory_entry e; directory_entry e;
path replace; path replace;
static_assert(noexcept(e.replace_filename(replace)) == false, static_assert(noexcept(e.replace_filename(replace)) == false,
"operation cannot be noexcept"); "operation cannot be noexcept");
static_assert( static_assert(
std::is_same<decltype(e.replace_filename(replace)), void>::value, std::is_same<decltype(e.replace_filename(replace)), void>::value,
"operation must return void"); "operation must return void");
} }
{ {
const path p("/path/to/foo.exe"); const path p("/path/to/foo.exe");
const path replace("bar.out"); const path replace("bar.out");
const path expect("/path/to/bar.out"); const path expect("/path/to/bar.out");
directory_entry e(p); directory_entry e(p);
TEST_CHECK(e.path() == p); assert(e.path() == p);
e.replace_filename(replace); e.replace_filename(replace);
TEST_CHECK(e.path() == expect); assert(e.path() == expect);
} }
} }
TEST_CASE(test_replace_filename_ec_method) { static void test_replace_filename_ec_method() {
using namespace fs; using namespace fs;
static_test_env static_env; static_test_env static_env;
{ {
directory_entry e; directory_entry e;
path replace; path replace;
std::error_code ec; std::error_code ec;
static_assert(noexcept(e.replace_filename(replace, ec)) == false, static_assert(noexcept(e.replace_filename(replace, ec)) == false,
"operation cannot be noexcept"); "operation cannot be noexcept");
static_assert( static_assert(
std::is_same<decltype(e.replace_filename(replace, ec)), void>::value, std::is_same<decltype(e.replace_filename(replace, ec)), void>::value,
"operation must return void"); "operation must return void");
} }
{ {
const path p("/path/to/foo.exe"); const path p("/path/to/foo.exe");
const path replace("bar.out"); const path replace("bar.out");
const path expect("/path/to/bar.out"); const path expect("/path/to/bar.out");
directory_entry e(p); directory_entry e(p);
TEST_CHECK(e.path() == p); assert(e.path() == p);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
e.replace_filename(replace, ec); e.replace_filename(replace, ec);
TEST_CHECK(e.path() == expect); assert(e.path() == expect);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
} }
{ {
const path p = static_env.EmptyFile; const path p = static_env.EmptyFile;
const path expect = static_env.NonEmptyFile; const path expect = static_env.NonEmptyFile;
const path replace = static_env.NonEmptyFile.filename(); const path replace = static_env.NonEmptyFile.filename();
TEST_REQUIRE(expect.parent_path() == p.parent_path()); assert(expect.parent_path() == p.parent_path());
directory_entry e(p); directory_entry e(p);
TEST_CHECK(e.path() == p); assert(e.path() == p);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
e.replace_filename(replace, ec); e.replace_filename(replace, ec);
TEST_CHECK(e.path() == expect); assert(e.path() == expect);
TEST_CHECK(!ec); assert(!ec);
} }
} }
TEST_CASE(test_replace_filename_calls_refresh) { static void test_replace_filename_calls_refresh() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path file_two = env.create_file("dir/file_two", 101); const path file_two = env.create_file("dir/file_two", 101);
const path sym = env.create_symlink("dir/file", "sym"); const path sym = env.create_symlink("dir/file", "sym");
const path sym_two = env.create_symlink("dir/file_two", "sym_two"); const path sym_two = env.create_symlink("dir/file_two", "sym_two");
{ {
directory_entry ent(file); directory_entry ent(file);
ent.replace_filename(file_two.filename()); ent.replace_filename(file_two.filename());
TEST_REQUIRE(ent.path() == file_two); assert(ent.path() == file_two);
// removing the file demonstrates that the values where cached previously. // removing the file demonstrates that the values where cached previously.
LIBCPP_ONLY(remove(file_two)); LIBCPP_ONLY(remove(file_two));
TEST_CHECK(ent.file_size() == 101); assert(ent.file_size() == 101);
} }
env.create_file("dir/file_two", 99); env.create_file("dir/file_two", 99);
{ {
directory_entry ent(sym); directory_entry ent(sym);
ent.replace_filename(sym_two.filename()); ent.replace_filename(sym_two.filename());
TEST_REQUIRE(ent.path() == sym_two); assert(ent.path() == sym_two);
LIBCPP_ONLY(remove(file_two)); LIBCPP_ONLY(remove(file_two));
LIBCPP_ONLY(remove(sym_two)); LIBCPP_ONLY(remove(sym_two));
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
TEST_CHECK(ent.is_regular_file()); assert(ent.is_regular_file());
TEST_CHECK(ent.file_size() == 99); assert(ent.file_size() == 99);
} }
} }
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. // reading directories.
TEST_CASE(test_replace_filename_propagates_error) { static void test_replace_filename_propagates_error() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path file_two = env.create_file("dir/file_two", 99); const path file_two = env.create_file("dir/file_two", 99);
const path file_out_of_dir = env.create_file("file_three", 101); const path file_out_of_dir = env.create_file("file_three", 101);
const path sym_out_of_dir = env.create_symlink("dir/file", "sym"); const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
const path sym_out_of_dir_two = env.create_symlink("dir/file", "sym_two"); const path sym_out_of_dir_two = env.create_symlink("dir/file", "sym_two");
const path sym_in_dir = env.create_symlink("file_two", "dir/sym_three"); const path sym_in_dir = env.create_symlink("file_two", "dir/sym_three");
const path sym_in_dir_two = env.create_symlink("file_two", "dir/sym_four"); const path sym_in_dir_two = env.create_symlink("file_two", "dir/sym_four");
const perms old_perms = status(dir).permissions(); const perms old_perms = status(dir).permissions();
{ {
directory_entry ent(file); directory_entry ent(file);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.replace_filename(file_two.filename(), ec); ent.replace_filename(file_two.filename(), ec);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
} }
permissions(dir, old_perms); permissions(dir, old_perms);
{ {
directory_entry ent(sym_in_dir); directory_entry ent(sym_in_dir);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.replace_filename(sym_in_dir_two.filename(), ec); ent.replace_filename(sym_in_dir_two.filename(), ec);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
} }
permissions(dir, old_perms); permissions(dir, old_perms);
{ {
directory_entry ent(sym_out_of_dir); directory_entry ent(sym_out_of_dir);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.replace_filename(sym_out_of_dir_two.filename(), ec); ent.replace_filename(sym_out_of_dir_two.filename(), ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(ent.is_symlink()); assert(ent.is_symlink());
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(!ent.exists(ec)); assert(!ent.exists(ec));
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
} }
} }
#endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
int main(int, char**) {
test_replace_filename_method();
test_replace_filename_ec_method();
test_replace_filename_calls_refresh();
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
test_replace_filename_propagates_error();
#endif #endif
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_size.pass.cpp

Show All 18 Lines
// uintmax_t file_size() const; // uintmax_t file_size() const;
// uintmax_t file_size(error_code const&) const noexcept; // uintmax_t file_size(error_code const&) const noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
#include "rapid-cxx-test.h"
#include "test_macros.h" #include "test_macros.h"
TEST_SUITE(directory_entry_obs_testsuite) static void signatures() {
TEST_CASE(signatures) {
using namespace fs; using namespace fs;
{ {
const fs::directory_entry e = {}; const fs::directory_entry e = {};
std::error_code ec; std::error_code ec;
static_assert(std::is_same<decltype(e.file_size()), uintmax_t>::value, ""); static_assert(std::is_same<decltype(e.file_size()), uintmax_t>::value, "");
static_assert(std::is_same<decltype(e.file_size(ec)), uintmax_t>::value, static_assert(std::is_same<decltype(e.file_size(ec)), uintmax_t>::value,
""); "");
static_assert(noexcept(e.file_size()) == false, ""); static_assert(noexcept(e.file_size()) == false, "");
static_assert(noexcept(e.file_size(ec)) == true, ""); static_assert(noexcept(e.file_size(ec)) == true, "");
} }
} }
TEST_CASE(basic) { static void basic() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path sym = env.create_symlink("file", "sym"); const path sym = env.create_symlink("file", "sym");
{ {
directory_entry ent(file); directory_entry ent(file);
uintmax_t expect = file_size(ent); uintmax_t expect = file_size(ent);
TEST_CHECK(expect == 42); assert(expect == 42);
// Remove the file to show that the results were already in the cache. // Remove the file to show that the results were already in the cache.
LIBCPP_ONLY(remove(file)); LIBCPP_ONLY(remove(file));
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(ent.file_size(ec) == expect); assert(ent.file_size(ec) == expect);
TEST_CHECK(!ec); assert(!ec);
} }
env.create_file("file", 99); env.create_file("file", 99);
{ {
directory_entry ent(sym); directory_entry ent(sym);
uintmax_t expect = file_size(ent); uintmax_t expect = file_size(ent);
TEST_CHECK(expect == 99); assert(expect == 99);
LIBCPP_ONLY(remove(ent)); LIBCPP_ONLY(remove(ent));
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(ent.file_size(ec) == 99); assert(ent.file_size(ec) == 99);
TEST_CHECK(!ec); assert(!ec);
} }
} }
TEST_CASE(not_regular_file) { static void not_regular_file() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
struct { struct {
const path p; const path p;
std::errc expected_err; std::errc expected_err;
} TestCases[] = { } TestCases[] = {
{env.create_dir("dir"), std::errc::is_a_directory}, {env.create_dir("dir"), std::errc::is_a_directory},
#ifndef _WIN32 #ifndef _WIN32
{env.create_fifo("fifo"), std::errc::not_supported}, {env.create_fifo("fifo"), std::errc::not_supported},
#endif #endif
{env.create_directory_symlink("dir", "sym"), std::errc::is_a_directory}}; {env.create_directory_symlink("dir", "sym"), std::errc::is_a_directory}};
for (auto const& TC : TestCases) { for (auto const& TC : TestCases) {
const path& p = TC.p; const path& p = TC.p;
directory_entry ent(p); directory_entry ent(p);
TEST_CHECK(ent.path() == p); assert(ent.path() == p);
std::error_code ec = GetTestEC(0); std::error_code ec = GetTestEC(0);
std::error_code other_ec = GetTestEC(1); std::error_code other_ec = GetTestEC(1);
uintmax_t expect = file_size(p, other_ec); uintmax_t expect = file_size(p, other_ec);
uintmax_t got = ent.file_size(ec); uintmax_t got = ent.file_size(ec);
TEST_CHECK(got == expect); assert(got == expect);
TEST_CHECK(got == uintmax_t(-1)); assert(got == uintmax_t(-1));
TEST_CHECK(ec == other_ec); assert(ec == other_ec);
TEST_CHECK(ErrorIs(ec, TC.expected_err)); assert(ErrorIs(ec, TC.expected_err));
ExceptionChecker Checker(p, TC.expected_err, "directory_entry::file_size"); ExceptionChecker Checker(p, TC.expected_err, "directory_entry::file_size");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
ldionneUnsubmitted
Done
ReplyInline Actions

You're missing an include of assert_macros.h here.

ldionne: You're missing an include of `assert_macros.h` here.
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

Agreed, the tests still worked due to filesystem_test_helper.h including this file.

Mordante: Agreed, the tests still worked due to `filesystem_test_helper.h` including this file.
} }
} }
TEST_CASE(error_reporting) { static void error_reporting() {
using namespace fs; using namespace fs;
static_test_env static_env; static_test_env static_env;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path file_out_of_dir = env.create_file("file2", 101); const path file_out_of_dir = env.create_file("file2", 101);
const path sym_out_of_dir = env.create_symlink("dir/file", "sym"); const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
const path sym_in_dir = env.create_symlink("file2", "dir/sym2"); const path sym_in_dir = env.create_symlink("file2", "dir/sym2");
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
const perms old_perms = status(dir).permissions(); const perms old_perms = status(dir).permissions();
#endif #endif
// test a file which doesn't exist // test a file which doesn't exist
{ {
directory_entry ent; directory_entry ent;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(static_env.DNE, ec); ent.assign(static_env.DNE, ec);
TEST_REQUIRE(ent.path() == static_env.DNE); assert(ent.path() == static_env.DNE);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.file_size(ec) == uintmax_t(-1)); assert(ent.file_size(ec) == uintmax_t(-1));
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ExceptionChecker Checker(static_env.DNE, ExceptionChecker Checker(static_env.DNE,
std::errc::no_such_file_or_directory, std::errc::no_such_file_or_directory,
"directory_entry::file_size"); "directory_entry::file_size");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
} }
// test a dead symlink // test a dead symlink
{ {
directory_entry ent; directory_entry ent;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
uintmax_t expect_bad = file_size(static_env.BadSymlink, ec); uintmax_t expect_bad = file_size(static_env.BadSymlink, ec);
TEST_CHECK(expect_bad == uintmax_t(-1)); assert(expect_bad == uintmax_t(-1));
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ec = GetTestEC(); ec = GetTestEC();
ent.assign(static_env.BadSymlink, ec); ent.assign(static_env.BadSymlink, ec);
TEST_REQUIRE(ent.path() == static_env.BadSymlink); assert(ent.path() == static_env.BadSymlink);
TEST_CHECK(!ec); assert(!ec);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.file_size(ec) == expect_bad); assert(ent.file_size(ec) == expect_bad);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ExceptionChecker Checker(static_env.BadSymlink, ExceptionChecker Checker(static_env.BadSymlink,
std::errc::no_such_file_or_directory, std::errc::no_such_file_or_directory,
"directory_entry::file_size"); "directory_entry::file_size");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
} }
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. // reading directories.
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
// test a file w/o appropriate permissions. // test a file w/o appropriate permissions.
{ {
directory_entry ent; directory_entry ent;
uintmax_t expect_good = file_size(file); uintmax_t expect_good = file_size(file);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(file, ec); ent.assign(file, ec);
TEST_REQUIRE(ent.path() == file); assert(ent.path() == file);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.file_size(ec) == uintmax_t(-1)); assert(ent.file_size(ec) == uintmax_t(-1));
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ExceptionChecker Checker(file, std::errc::permission_denied, "file_size"); ExceptionChecker Checker(file, std::errc::permission_denied, "file_size");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
permissions(dir, old_perms); permissions(dir, old_perms);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.file_size(ec) == expect_good); assert(ent.file_size(ec) == expect_good);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK_NO_THROW(ent.file_size()); TEST_DOES_NOT_THROW(ent.file_size());
} }
permissions(dir, old_perms); permissions(dir, old_perms);
// test a symlink w/o appropriate permissions. // test a symlink w/o appropriate permissions.
{ {
directory_entry ent; directory_entry ent;
uintmax_t expect_good = file_size(sym_in_dir); uintmax_t expect_good = file_size(sym_in_dir);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(sym_in_dir, ec); ent.assign(sym_in_dir, ec);
TEST_REQUIRE(ent.path() == sym_in_dir); assert(ent.path() == sym_in_dir);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.file_size(ec) == uintmax_t(-1)); assert(ent.file_size(ec) == uintmax_t(-1));
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied, ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied,
"file_size"); "file_size");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
permissions(dir, old_perms); permissions(dir, old_perms);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.file_size(ec) == expect_good); assert(ent.file_size(ec) == expect_good);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK_NO_THROW(ent.file_size()); TEST_DOES_NOT_THROW(ent.file_size());
} }
permissions(dir, old_perms); permissions(dir, old_perms);
// test a symlink to a file w/o appropriate permissions // test a symlink to a file w/o appropriate permissions
{ {
directory_entry ent; directory_entry ent;
uintmax_t expect_good = file_size(sym_out_of_dir); uintmax_t expect_good = file_size(sym_out_of_dir);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(sym_out_of_dir, ec); ent.assign(sym_out_of_dir, ec);
TEST_REQUIRE(ent.path() == sym_out_of_dir); assert(ent.path() == sym_out_of_dir);
TEST_CHECK(!ec); assert(!ec);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.file_size(ec) == uintmax_t(-1)); assert(ent.file_size(ec) == uintmax_t(-1));
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ExceptionChecker Checker(sym_out_of_dir, std::errc::permission_denied, ExceptionChecker Checker(sym_out_of_dir, std::errc::permission_denied,
"file_size"); "file_size");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
permissions(dir, old_perms); permissions(dir, old_perms);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.file_size(ec) == expect_good); assert(ent.file_size(ec) == expect_good);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK_NO_THROW(ent.file_size()); TEST_DOES_NOT_THROW(ent.file_size());
} }
#endif #endif
} }
TEST_SUITE_END() int main(int, char**) {
signatures();
basic();
not_regular_file();
error_reporting();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_type_obs.pass.cpp

Show All 14 Lines
// file_status status() const; // file_status status() const;
// file_status status(error_code const&) const noexcept; // file_status status(error_code const&) const noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
#include "rapid-cxx-test.h"
#include "test_macros.h" #include "test_macros.h"
TEST_SUITE(directory_entry_obs_testsuite) static void file_dne() {
TEST_CASE(file_dne) {
using namespace fs; using namespace fs;
directory_entry p("dne"); directory_entry p("dne");
} }
TEST_CASE(signatures) { static void signatures() {
using namespace fs; using namespace fs;
const directory_entry e = {}; const directory_entry e = {};
std::error_code ec; std::error_code ec;
#define TEST_FUNC(name) \ #define TEST_FUNC(name) \
static_assert(std::is_same<decltype(e.name()), bool>::value, \ static_assert(std::is_same<decltype(e.name()), bool>::value, \
"wrong return type"); \ "wrong return type"); \
static_assert(noexcept(e.name()) == false, "should not be noexcept"); \ static_assert(noexcept(e.name()) == false, "should not be noexcept"); \
static_assert(std::is_same<decltype(e.name(ec)), bool>::value, \ static_assert(std::is_same<decltype(e.name(ec)), bool>::value, \
"wrong return type"); \ "wrong return type"); \
static_assert(noexcept(e.name(ec)) == true, "should be noexcept") static_assert(noexcept(e.name(ec)) == true, "should be noexcept")
TEST_FUNC(exists); TEST_FUNC(exists);
TEST_FUNC(is_block_file); TEST_FUNC(is_block_file);
TEST_FUNC(is_character_file); TEST_FUNC(is_character_file);
TEST_FUNC(is_directory); TEST_FUNC(is_directory);
TEST_FUNC(is_fifo); TEST_FUNC(is_fifo);
TEST_FUNC(is_other); TEST_FUNC(is_other);
TEST_FUNC(is_regular_file); TEST_FUNC(is_regular_file);
TEST_FUNC(is_socket); TEST_FUNC(is_socket);
TEST_FUNC(is_symlink); TEST_FUNC(is_symlink);
#undef TEST_FUNC #undef TEST_FUNC
} }
TEST_CASE(test_without_ec) { static void test_without_ec() {
using namespace fs; using namespace fs;
using fs::directory_entry; using fs::directory_entry;
using fs::file_status; using fs::file_status;
using fs::path; using fs::path;
scoped_test_env env; scoped_test_env env;
path f = env.create_file("foo", 42); path f = env.create_file("foo", 42);
path d = env.create_dir("dir"); path d = env.create_dir("dir");
path hl = env.create_hardlink("foo", "hl"); path hl = env.create_hardlink("foo", "hl");
auto test_path = [=](const path &p) { auto test_path = [=](const path &p) {
directory_entry e(p); directory_entry e(p);
file_status st = status(p); file_status st = status(p);
file_status sym_st = symlink_status(p); file_status sym_st = symlink_status(p);
fs::remove(p); fs::remove(p);
TEST_REQUIRE(e.exists()); assert(e.exists());
TEST_REQUIRE(!exists(p)); assert(!exists(p));
TEST_CHECK(e.exists() == exists(st)); assert(e.exists() == exists(st));
TEST_CHECK(e.is_block_file() == is_block_file(st)); assert(e.is_block_file() == is_block_file(st));
TEST_CHECK(e.is_character_file() == is_character_file(st)); assert(e.is_character_file() == is_character_file(st));
TEST_CHECK(e.is_directory() == is_directory(st)); assert(e.is_directory() == is_directory(st));
TEST_CHECK(e.is_fifo() == is_fifo(st)); assert(e.is_fifo() == is_fifo(st));
TEST_CHECK(e.is_other() == is_other(st)); assert(e.is_other() == is_other(st));
TEST_CHECK(e.is_regular_file() == is_regular_file(st)); assert(e.is_regular_file() == is_regular_file(st));
TEST_CHECK(e.is_socket() == is_socket(st)); assert(e.is_socket() == is_socket(st));
TEST_CHECK(e.is_symlink() == is_symlink(sym_st)); assert(e.is_symlink() == is_symlink(sym_st));
}; };
test_path(f); test_path(f);
test_path(d); test_path(d);
test_path(hl); test_path(hl);
#ifndef _WIN32 #ifndef _WIN32
path fifo = env.create_fifo("fifo"); path fifo = env.create_fifo("fifo");
test_path(fifo); test_path(fifo);
#endif #endif
} }
TEST_CASE(test_with_ec) { static void test_with_ec() {
using namespace fs; using namespace fs;
using fs::directory_entry; using fs::directory_entry;
using fs::file_status; using fs::file_status;
using fs::path; using fs::path;
scoped_test_env env; scoped_test_env env;
path f = env.create_file("foo", 42); path f = env.create_file("foo", 42);
path d = env.create_dir("dir"); path d = env.create_dir("dir");
path hl = env.create_hardlink("foo", "hl"); path hl = env.create_hardlink("foo", "hl");
auto test_path = [=](const path &p) { auto test_path = [=](const path &p) {
directory_entry e(p); directory_entry e(p);
std::error_code status_ec = GetTestEC(); std::error_code status_ec = GetTestEC();
std::error_code sym_status_ec = GetTestEC(1); std::error_code sym_status_ec = GetTestEC(1);
file_status st = status(p, status_ec); file_status st = status(p, status_ec);
file_status sym_st = symlink_status(p, sym_status_ec); file_status sym_st = symlink_status(p, sym_status_ec);
fs::remove(p); fs::remove(p);
std::error_code ec = GetTestEC(2); std::error_code ec = GetTestEC(2);
auto CheckEC = [&](std::error_code const& other_ec) { auto CheckEC = [&](std::error_code const& other_ec) {
bool res = ec == other_ec; bool res = ec == other_ec;
ec = GetTestEC(2); ec = GetTestEC(2);
return res; return res;
}; };
TEST_REQUIRE(e.exists(ec)); assert(e.exists(ec));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_REQUIRE(!exists(p)); assert(!exists(p));
TEST_CHECK(e.exists(ec) == exists(st)); assert(e.exists(ec) == exists(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_block_file(ec) == is_block_file(st)); assert(e.is_block_file(ec) == is_block_file(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_character_file(ec) == is_character_file(st)); assert(e.is_character_file(ec) == is_character_file(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_directory(ec) == is_directory(st)); assert(e.is_directory(ec) == is_directory(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_fifo(ec) == is_fifo(st)); assert(e.is_fifo(ec) == is_fifo(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_other(ec) == is_other(st)); assert(e.is_other(ec) == is_other(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_regular_file(ec) == is_regular_file(st)); assert(e.is_regular_file(ec) == is_regular_file(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_socket(ec) == is_socket(st)); assert(e.is_socket(ec) == is_socket(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_symlink(ec) == is_symlink(sym_st)); assert(e.is_symlink(ec) == is_symlink(sym_st));
TEST_CHECK(CheckEC(sym_status_ec)); assert(CheckEC(sym_status_ec));
}; };
test_path(f); test_path(f);
test_path(d); test_path(d);
test_path(hl); test_path(hl);
#ifndef _WIN32 #ifndef _WIN32
path fifo = env.create_fifo("fifo"); path fifo = env.create_fifo("fifo");
test_path(fifo); test_path(fifo);
#endif #endif
} }
TEST_CASE(test_with_ec_dne) { static void test_with_ec_dne() {
using namespace fs; using namespace fs;
using fs::directory_entry; using fs::directory_entry;
using fs::file_status; using fs::file_status;
using fs::path; using fs::path;
static_test_env static_env; static_test_env static_env;
for (auto p : {static_env.DNE, static_env.BadSymlink}) { for (auto p : {static_env.DNE, static_env.BadSymlink}) {
directory_entry e(p); directory_entry e(p);
std::error_code status_ec = GetTestEC(); std::error_code status_ec = GetTestEC();
std::error_code sym_status_ec = GetTestEC(1); std::error_code sym_status_ec = GetTestEC(1);
file_status st = status(p, status_ec); file_status st = status(p, status_ec);
file_status sym_st = symlink_status(p, sym_status_ec); file_status sym_st = symlink_status(p, sym_status_ec);
std::error_code ec = GetTestEC(2); std::error_code ec = GetTestEC(2);
auto CheckEC = [&](std::error_code const& other_ec) { auto CheckEC = [&](std::error_code const& other_ec) {
bool res = ec == other_ec; bool res = ec == other_ec;
ec = GetTestEC(2); ec = GetTestEC(2);
return res; return res;
}; };
TEST_CHECK(e.exists(ec) == exists(st)); assert(e.exists(ec) == exists(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_block_file(ec) == is_block_file(st)); assert(e.is_block_file(ec) == is_block_file(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_character_file(ec) == is_character_file(st)); assert(e.is_character_file(ec) == is_character_file(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_directory(ec) == is_directory(st)); assert(e.is_directory(ec) == is_directory(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_fifo(ec) == is_fifo(st)); assert(e.is_fifo(ec) == is_fifo(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_other(ec) == is_other(st)); assert(e.is_other(ec) == is_other(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_regular_file(ec) == is_regular_file(st)); assert(e.is_regular_file(ec) == is_regular_file(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_socket(ec) == is_socket(st)); assert(e.is_socket(ec) == is_socket(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_symlink(ec) == is_symlink(sym_st)); assert(e.is_symlink(ec) == is_symlink(sym_st));
TEST_CHECK(CheckEC(sym_status_ec)); assert(CheckEC(sym_status_ec));
} }
} }
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. // reading directories.
TEST_CASE(test_with_ec_cannot_resolve) { static void test_with_ec_cannot_resolve() {
using namespace fs; using namespace fs;
using fs::directory_entry; using fs::directory_entry;
using fs::file_status; using fs::file_status;
using fs::path; using fs::path;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path file_out_of_dir = env.create_file("file2", 99); const path file_out_of_dir = env.create_file("file2", 99);
const path sym = env.create_symlink("file2", "dir/sym"); const path sym = env.create_symlink("file2", "dir/sym");
perms old_perms = fs::status(dir).permissions(); perms old_perms = fs::status(dir).permissions();
for (auto p : {file, sym}) { for (auto p : {file, sym}) {
permissions(dir, old_perms); permissions(dir, old_perms);
directory_entry e(p); directory_entry e(p);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code dummy_ec; std::error_code dummy_ec;
e.refresh(dummy_ec); e.refresh(dummy_ec);
TEST_REQUIRE(dummy_ec); assert(dummy_ec);
std::error_code status_ec = GetTestEC(); std::error_code status_ec = GetTestEC();
std::error_code sym_status_ec = GetTestEC(1); std::error_code sym_status_ec = GetTestEC(1);
file_status st = status(p, status_ec); file_status st = status(p, status_ec);
file_status sym_st = symlink_status(p, sym_status_ec); file_status sym_st = symlink_status(p, sym_status_ec);
std::error_code ec = GetTestEC(2); std::error_code ec = GetTestEC(2);
auto CheckEC = [&](std::error_code const& other_ec) { auto CheckEC = [&](std::error_code const& other_ec) {
bool res = ec == other_ec; bool res = ec == other_ec;
ec = GetTestEC(2); ec = GetTestEC(2);
return res; return res;
}; };
TEST_CHECK(e.exists(ec) == exists(st)); assert(e.exists(ec) == exists(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_block_file(ec) == is_block_file(st)); assert(e.is_block_file(ec) == is_block_file(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_character_file(ec) == is_character_file(st)); assert(e.is_character_file(ec) == is_character_file(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_directory(ec) == is_directory(st)); assert(e.is_directory(ec) == is_directory(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_fifo(ec) == is_fifo(st)); assert(e.is_fifo(ec) == is_fifo(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_other(ec) == is_other(st)); assert(e.is_other(ec) == is_other(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_regular_file(ec) == is_regular_file(st)); assert(e.is_regular_file(ec) == is_regular_file(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_socket(ec) == is_socket(st)); assert(e.is_socket(ec) == is_socket(st));
TEST_CHECK(CheckEC(status_ec)); assert(CheckEC(status_ec));
TEST_CHECK(e.is_symlink(ec) == is_symlink(sym_st)); assert(e.is_symlink(ec) == is_symlink(sym_st));
TEST_CHECK(CheckEC(sym_status_ec)); assert(CheckEC(sym_status_ec));
} }
} }
#endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
int main(int, char**) {
file_dne();
signatures();
test_without_ec();
test_with_ec();
test_with_ec_dne();
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
test_with_ec_cannot_resolve();
#endif #endif
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/hard_link_count.pass.cpp

Show All 18 Lines
// uintmax_t hard_link_count() const; // uintmax_t hard_link_count() const;
// uintmax_t hard_link_count(error_code const&) const noexcept; // uintmax_t hard_link_count(error_code const&) const noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
#include "rapid-cxx-test.h"
#include "test_macros.h" #include "test_macros.h"
TEST_SUITE(directory_entry_obs_testsuite) static void signatures() {
TEST_CASE(signatures) {
using namespace fs; using namespace fs;
{ {
const directory_entry e = {}; const directory_entry e = {};
std::error_code ec; std::error_code ec;
static_assert(std::is_same<decltype(e.hard_link_count()), uintmax_t>::value, ""); static_assert(std::is_same<decltype(e.hard_link_count()), uintmax_t>::value, "");
static_assert(std::is_same<decltype(e.hard_link_count(ec)), uintmax_t>::value, static_assert(std::is_same<decltype(e.hard_link_count(ec)), uintmax_t>::value,
""); "");
static_assert(noexcept(e.hard_link_count()) == false, ""); static_assert(noexcept(e.hard_link_count()) == false, "");
static_assert(noexcept(e.hard_link_count(ec)) == true, ""); static_assert(noexcept(e.hard_link_count(ec)) == true, "");
} }
} }
TEST_CASE(basic) { static void basic() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path sym = env.create_symlink("file", "sym"); const path sym = env.create_symlink("file", "sym");
{ {
directory_entry ent(file); directory_entry ent(file);
uintmax_t expect = hard_link_count(ent); uintmax_t expect = hard_link_count(ent);
// Remove the file to show that the results were already in the cache. // Remove the file to show that the results were already in the cache.
LIBCPP_ONLY(remove(file)); LIBCPP_ONLY(remove(file));
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(ent.hard_link_count(ec) == expect); assert(ent.hard_link_count(ec) == expect);
TEST_CHECK(!ec); assert(!ec);
} }
{ {
directory_entry ent(dir); directory_entry ent(dir);
uintmax_t expect = hard_link_count(ent); uintmax_t expect = hard_link_count(ent);
LIBCPP_ONLY(remove(dir)); LIBCPP_ONLY(remove(dir));
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(ent.hard_link_count(ec) == expect); assert(ent.hard_link_count(ec) == expect);
TEST_CHECK(!ec); assert(!ec);
} }
env.create_file("file", 99); env.create_file("file", 99);
env.create_hardlink("file", "hl"); env.create_hardlink("file", "hl");
{ {
directory_entry ent(sym); directory_entry ent(sym);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(ent.hard_link_count(ec) == 2); assert(ent.hard_link_count(ec) == 2);
TEST_CHECK(!ec); assert(!ec);
} }
} }
TEST_CASE(not_regular_file) { static void not_regular_file() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path dir2 = env.create_dir("dir/dir2"); const path dir2 = env.create_dir("dir/dir2");
const perms old_perms = status(dir).permissions(); const perms old_perms = status(dir).permissions();
auto test_path = [=](const path &p) { auto test_path = [=](const path &p) {
std::error_code dummy_ec = GetTestEC(); std::error_code dummy_ec = GetTestEC();
directory_entry ent(p, dummy_ec); directory_entry ent(p, dummy_ec);
TEST_CHECK(!dummy_ec); assert(!dummy_ec);
uintmax_t expect = hard_link_count(p); uintmax_t expect = hard_link_count(p);
LIBCPP_ONLY(permissions(dir, perms::none)); LIBCPP_ONLY(permissions(dir, perms::none));
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(ent.hard_link_count(ec) == expect); assert(ent.hard_link_count(ec) == expect);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK_NO_THROW(ent.hard_link_count()); TEST_DOES_NOT_THROW(ent.hard_link_count());
permissions(dir, old_perms); permissions(dir, old_perms);
}; };
test_path(dir2); test_path(dir2);
#ifndef _WIN32 #ifndef _WIN32
const path fifo = env.create_fifo("dir/fifo"); const path fifo = env.create_fifo("dir/fifo");
const path sym_to_fifo = env.create_symlink("dir/fifo", "dir/sym"); const path sym_to_fifo = env.create_symlink("dir/fifo", "dir/sym");
test_path(fifo); test_path(fifo);
test_path(sym_to_fifo); test_path(sym_to_fifo);
#endif #endif
} }
TEST_CASE(error_reporting) { static void error_reporting() {
using namespace fs; using namespace fs;
static_test_env static_env; static_test_env static_env;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path file_out_of_dir = env.create_file("file2", 101); const path file_out_of_dir = env.create_file("file2", 101);
const path sym_out_of_dir = env.create_symlink("dir/file", "sym"); const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
const path sym_in_dir = env.create_symlink("file2", "dir/sym2"); const path sym_in_dir = env.create_symlink("file2", "dir/sym2");
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
const perms old_perms = status(dir).permissions(); const perms old_perms = status(dir).permissions();
#endif #endif
// test a file which doesn't exist // test a file which doesn't exist
{ {
directory_entry ent; directory_entry ent;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(static_env.DNE, ec); ent.assign(static_env.DNE, ec);
TEST_CHECK(ec); assert(ec);
TEST_REQUIRE(ent.path() == static_env.DNE); assert(ent.path() == static_env.DNE);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.hard_link_count(ec) == uintmax_t(-1)); assert(ent.hard_link_count(ec) == uintmax_t(-1));
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ExceptionChecker Checker(static_env.DNE, ExceptionChecker Checker(static_env.DNE,
std::errc::no_such_file_or_directory, std::errc::no_such_file_or_directory,
"directory_entry::hard_link_count"); "directory_entry::hard_link_count");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
} }
// test a dead symlink // test a dead symlink
{ {
directory_entry ent; directory_entry ent;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
uintmax_t expect_bad = hard_link_count(static_env.BadSymlink, ec); uintmax_t expect_bad = hard_link_count(static_env.BadSymlink, ec);
TEST_CHECK(expect_bad == uintmax_t(-1)); assert(expect_bad == uintmax_t(-1));
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ec = GetTestEC(); ec = GetTestEC();
ent.assign(static_env.BadSymlink, ec); ent.assign(static_env.BadSymlink, ec);
TEST_REQUIRE(ent.path() == static_env.BadSymlink); assert(ent.path() == static_env.BadSymlink);
TEST_CHECK(!ec); assert(!ec);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.hard_link_count(ec) == expect_bad); assert(ent.hard_link_count(ec) == expect_bad);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ExceptionChecker Checker(static_env.BadSymlink, ExceptionChecker Checker(static_env.BadSymlink,
std::errc::no_such_file_or_directory, std::errc::no_such_file_or_directory,
"directory_entry::hard_link_count"); "directory_entry::hard_link_count");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
ldionneUnsubmitted
Done
ReplyInline Actions

Same here, and probably elsewhere.

ldionne: Same here, and probably elsewhere.
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

I had that already done locally.

Due to the changes in the parent patch I've given the patch another CI run to make sure everything still works.

Mordante: I had that already done locally. Due to the changes in the parent patch I've given the patch…
} }
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. // reading directories.
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
// test a file w/o appropriate permissions. // test a file w/o appropriate permissions.
{ {
directory_entry ent; directory_entry ent;
uintmax_t expect_good = hard_link_count(file); uintmax_t expect_good = hard_link_count(file);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(file, ec); ent.assign(file, ec);
TEST_REQUIRE(ent.path() == file); assert(ent.path() == file);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.hard_link_count(ec) == uintmax_t(-1)); assert(ent.hard_link_count(ec) == uintmax_t(-1));
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ExceptionChecker Checker(file, std::errc::permission_denied, ExceptionChecker Checker(file, std::errc::permission_denied,
"hard_link_count"); "hard_link_count");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
permissions(dir, old_perms); permissions(dir, old_perms);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.hard_link_count(ec) == expect_good); assert(ent.hard_link_count(ec) == expect_good);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK_NO_THROW(ent.hard_link_count()); TEST_DOES_NOT_THROW(ent.hard_link_count());
} }
permissions(dir, old_perms); permissions(dir, old_perms);
// test a symlink w/o appropriate permissions. // test a symlink w/o appropriate permissions.
{ {
directory_entry ent; directory_entry ent;
uintmax_t expect_good = hard_link_count(sym_in_dir); uintmax_t expect_good = hard_link_count(sym_in_dir);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(sym_in_dir, ec); ent.assign(sym_in_dir, ec);
TEST_REQUIRE(ent.path() == sym_in_dir); assert(ent.path() == sym_in_dir);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.hard_link_count(ec) == uintmax_t(-1)); assert(ent.hard_link_count(ec) == uintmax_t(-1));
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied, ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied,
"hard_link_count"); "hard_link_count");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
permissions(dir, old_perms); permissions(dir, old_perms);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.hard_link_count(ec) == expect_good); assert(ent.hard_link_count(ec) == expect_good);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK_NO_THROW(ent.hard_link_count()); TEST_DOES_NOT_THROW(ent.hard_link_count());
} }
permissions(dir, old_perms); permissions(dir, old_perms);
// test a symlink to a file w/o appropriate permissions // test a symlink to a file w/o appropriate permissions
{ {
directory_entry ent; directory_entry ent;
uintmax_t expect_good = hard_link_count(sym_out_of_dir); uintmax_t expect_good = hard_link_count(sym_out_of_dir);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(sym_out_of_dir, ec); ent.assign(sym_out_of_dir, ec);
TEST_REQUIRE(ent.path() == sym_out_of_dir); assert(ent.path() == sym_out_of_dir);
TEST_CHECK(!ec); assert(!ec);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.hard_link_count(ec) == uintmax_t(-1)); assert(ent.hard_link_count(ec) == uintmax_t(-1));
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ExceptionChecker Checker(sym_out_of_dir, std::errc::permission_denied, ExceptionChecker Checker(sym_out_of_dir, std::errc::permission_denied,
"hard_link_count"); "hard_link_count");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
permissions(dir, old_perms); permissions(dir, old_perms);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.hard_link_count(ec) == expect_good); assert(ent.hard_link_count(ec) == expect_good);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK_NO_THROW(ent.hard_link_count()); TEST_DOES_NOT_THROW(ent.hard_link_count());
} }
#endif #endif
} }
TEST_SUITE_END() int main(int, char**) {
signatures();
basic();
not_regular_file();
error_reporting();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/last_write_time.pass.cpp

Show All 18 Lines
// file_time_type last_write_time() const; // file_time_type last_write_time() const;
// file_time_type last_write_time(error_code const&) const noexcept; // file_time_type last_write_time(error_code const&) const noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
#include "rapid-cxx-test.h"
#include "test_macros.h" #include "test_macros.h"
TEST_SUITE(directory_entry_obs_testsuite) static void signatures() {
TEST_CASE(signatures) {
using namespace fs; using namespace fs;
{ {
const fs::directory_entry e = {}; const fs::directory_entry e = {};
std::error_code ec; std::error_code ec;
static_assert(std::is_same<decltype(e.last_write_time()), file_time_type>::value, static_assert(std::is_same<decltype(e.last_write_time()), file_time_type>::value,
""); "");
static_assert(std::is_same<decltype(e.last_write_time(ec)), file_time_type>::value, static_assert(std::is_same<decltype(e.last_write_time(ec)), file_time_type>::value,
""); "");
static_assert(noexcept(e.last_write_time()) == false, ""); static_assert(noexcept(e.last_write_time()) == false, "");
static_assert(noexcept(e.last_write_time(ec)) == true, ""); static_assert(noexcept(e.last_write_time(ec)) == true, "");
} }
} }
TEST_CASE(basic) { static void basic() {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path sym = env.create_symlink("file", "sym"); const path sym = env.create_symlink("file", "sym");
{ {
directory_entry ent(file); directory_entry ent(file);
file_time_type expect = last_write_time(ent); file_time_type expect = last_write_time(ent);
// Remove the file to show that the results were already in the cache. // Remove the file to show that the results were already in the cache.
LIBCPP_ONLY(remove(file)); LIBCPP_ONLY(remove(file));
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == expect); assert(ent.last_write_time(ec) == expect);
TEST_CHECK(!ec); assert(!ec);
} }
{ {
directory_entry ent(dir); directory_entry ent(dir);
file_time_type expect = last_write_time(ent); file_time_type expect = last_write_time(ent);
LIBCPP_ONLY(remove(dir)); LIBCPP_ONLY(remove(dir));
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == expect); assert(ent.last_write_time(ec) == expect);
TEST_CHECK(!ec); assert(!ec);
} }
env.create_file("file", 99); env.create_file("file", 99);
{ {
directory_entry ent(sym); directory_entry ent(sym);
file_time_type expect = last_write_time(sym); file_time_type expect = last_write_time(sym);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == expect); assert(ent.last_write_time(ec) == expect);
TEST_CHECK(!ec); assert(!ec);
} }
} }
TEST_CASE(error_reporting) { static void error_reporting() {
using namespace fs; using namespace fs;
static_test_env static_env; static_test_env static_env;
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path file_out_of_dir = env.create_file("file2", 101); const path file_out_of_dir = env.create_file("file2", 101);
const path sym_out_of_dir = env.create_symlink("dir/file", "sym"); const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
const path sym_in_dir = env.create_symlink("file2", "dir/sym2"); const path sym_in_dir = env.create_symlink("file2", "dir/sym2");
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
const perms old_perms = status(dir).permissions(); const perms old_perms = status(dir).permissions();
#endif #endif
// test a file which doesn't exist // test a file which doesn't exist
{ {
directory_entry ent; directory_entry ent;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(static_env.DNE, ec); ent.assign(static_env.DNE, ec);
TEST_REQUIRE(ent.path() == static_env.DNE); assert(ent.path() == static_env.DNE);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == file_time_type::min()); assert(ent.last_write_time(ec) == file_time_type::min());
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ExceptionChecker Checker(static_env.DNE, ExceptionChecker Checker(static_env.DNE,
std::errc::no_such_file_or_directory, std::errc::no_such_file_or_directory,
"directory_entry::last_write_time"); "directory_entry::last_write_time");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.last_write_time());
} }
// test a dead symlink // test a dead symlink
{ {
directory_entry ent; directory_entry ent;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
file_time_type expect_bad = last_write_time(static_env.BadSymlink, ec); file_time_type expect_bad = last_write_time(static_env.BadSymlink, ec);
TEST_CHECK(expect_bad == file_time_type::min()); assert(expect_bad == file_time_type::min());
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ec = GetTestEC(); ec = GetTestEC();
ent.assign(static_env.BadSymlink, ec); ent.assign(static_env.BadSymlink, ec);
TEST_REQUIRE(ent.path() == static_env.BadSymlink); assert(ent.path() == static_env.BadSymlink);
TEST_CHECK(!ec); assert(!ec);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == expect_bad); assert(ent.last_write_time(ec) == expect_bad);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ExceptionChecker Checker(static_env.BadSymlink, ExceptionChecker Checker(static_env.BadSymlink,
std::errc::no_such_file_or_directory, std::errc::no_such_file_or_directory,
"directory_entry::last_write_time"); "directory_entry::last_write_time");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.last_write_time());
} }
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. // reading directories.
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
// test a file w/o appropriate permissions. // test a file w/o appropriate permissions.
{ {
directory_entry ent; directory_entry ent;
file_time_type expect_good = last_write_time(file); file_time_type expect_good = last_write_time(file);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(file, ec); ent.assign(file, ec);
TEST_REQUIRE(ent.path() == file); assert(ent.path() == file);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == file_time_type::min()); assert(ent.last_write_time(ec) == file_time_type::min());
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ExceptionChecker Checker(file, std::errc::permission_denied, ExceptionChecker Checker(file, std::errc::permission_denied,
"last_write_time"); "last_write_time");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.last_write_time());
permissions(dir, old_perms); permissions(dir, old_perms);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == expect_good); assert(ent.last_write_time(ec) == expect_good);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK_NO_THROW(ent.last_write_time()); TEST_DOES_NOT_THROW(ent.last_write_time());
} }
permissions(dir, old_perms); permissions(dir, old_perms);
// test a symlink w/o appropriate permissions. // test a symlink w/o appropriate permissions.
{ {
directory_entry ent; directory_entry ent;
file_time_type expect_good = last_write_time(sym_in_dir); file_time_type expect_good = last_write_time(sym_in_dir);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(sym_in_dir, ec); ent.assign(sym_in_dir, ec);
TEST_REQUIRE(ent.path() == sym_in_dir); assert(ent.path() == sym_in_dir);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == file_time_type::min()); assert(ent.last_write_time(ec) == file_time_type::min());
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied, ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied,
"last_write_time"); "last_write_time");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.last_write_time());
permissions(dir, old_perms); permissions(dir, old_perms);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == expect_good); assert(ent.last_write_time(ec) == expect_good);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK_NO_THROW(ent.last_write_time()); TEST_DOES_NOT_THROW(ent.last_write_time());
} }
permissions(dir, old_perms); permissions(dir, old_perms);
// test a symlink to a file w/o appropriate permissions // test a symlink to a file w/o appropriate permissions
{ {
directory_entry ent; directory_entry ent;
file_time_type expect_good = last_write_time(sym_out_of_dir); file_time_type expect_good = last_write_time(sym_out_of_dir);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
ent.assign(sym_out_of_dir, ec); ent.assign(sym_out_of_dir, ec);
TEST_REQUIRE(ent.path() == sym_out_of_dir); assert(ent.path() == sym_out_of_dir);
TEST_CHECK(!ec); assert(!ec);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == file_time_type::min()); assert(ent.last_write_time(ec) == file_time_type::min());
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ExceptionChecker Checker(sym_out_of_dir, std::errc::permission_denied, ExceptionChecker Checker(sym_out_of_dir, std::errc::permission_denied,
"last_write_time"); "last_write_time");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time()); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.last_write_time());
permissions(dir, old_perms); permissions(dir, old_perms);
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(ent.last_write_time(ec) == expect_good); assert(ent.last_write_time(ec) == expect_good);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK_NO_THROW(ent.last_write_time()); TEST_DOES_NOT_THROW(ent.last_write_time());
} }
#endif #endif
} }
TEST_SUITE_END() int main(int, char**) {
signatures();
basic();
error_reporting();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/status.pass.cpp

Show All 14 Lines
// file_status status() const; // file_status status() const;
// file_status status(error_code const&) const noexcept; // file_status status(error_code const&) const noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
#include "rapid-cxx-test.h"
#include "test_macros.h" #include "test_macros.h"
TEST_SUITE(directory_entry_status_testsuite) static void test_basic() {
TEST_CASE(test_basic) {
using namespace fs; using namespace fs;
static_test_env static_env; static_test_env static_env;
{ {
const fs::directory_entry e("foo"); const fs::directory_entry e("foo");
std::error_code ec; std::error_code ec;
static_assert(std::is_same<decltype(e.status()), fs::file_status>::value, ""); static_assert(std::is_same<decltype(e.status()), fs::file_status>::value, "");
static_assert(std::is_same<decltype(e.status(ec)), fs::file_status>::value, ""); static_assert(std::is_same<decltype(e.status(ec)), fs::file_status>::value, "");
static_assert(noexcept(e.status()) == false, ""); static_assert(noexcept(e.status()) == false, "");
static_assert(noexcept(e.status(ec)) == true, ""); static_assert(noexcept(e.status(ec)) == true, "");
} }
path TestCases[] = {static_env.File, static_env.Dir, static_env.SymlinkToFile, path TestCases[] = {static_env.File, static_env.Dir, static_env.SymlinkToFile,
static_env.DNE}; static_env.DNE};
for (const auto& p : TestCases) { for (const auto& p : TestCases) {
const directory_entry e(p); const directory_entry e(p);
std::error_code pec = GetTestEC(), eec = GetTestEC(1); std::error_code pec = GetTestEC(), eec = GetTestEC(1);
file_status ps = fs::status(p, pec); file_status ps = fs::status(p, pec);
file_status es = e.status(eec); file_status es = e.status(eec);
TEST_CHECK(ps.type() == es.type()); assert(ps.type() == es.type());
TEST_CHECK(ps.permissions() == es.permissions()); assert(ps.permissions() == es.permissions());
TEST_CHECK(pec == eec); assert(pec == eec);
} }
for (const auto& p : TestCases) { for (const auto& p : TestCases) {
const directory_entry e(p); const directory_entry e(p);
file_status ps = fs::status(p); file_status ps = fs::status(p);
file_status es = e.status(); file_status es = e.status();
TEST_CHECK(ps.type() == es.type()); assert(ps.type() == es.type());
TEST_CHECK(ps.permissions() == es.permissions()); assert(ps.permissions() == es.permissions());
} }
} }
TEST_SUITE_END() int main(int, char**) {
test_basic();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/symlink_status.pass.cpp

Show All 14 Lines
// file_status symlink_status() const; // file_status symlink_status() const;
// file_status symlink_status(error_code&) const noexcept; // file_status symlink_status(error_code&) const noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
#include "rapid-cxx-test.h"
#include "test_macros.h" #include "test_macros.h"
TEST_SUITE(directory_entry_obs_suite) static void test_signature() {
TEST_CASE(test_signature) {
using namespace fs; using namespace fs;
static_test_env static_env; static_test_env static_env;
{ {
const directory_entry e("foo"); const directory_entry e("foo");
std::error_code ec; std::error_code ec;
static_assert(std::is_same<decltype(e.symlink_status()), file_status>::value, ""); static_assert(std::is_same<decltype(e.symlink_status()), file_status>::value, "");
static_assert(std::is_same<decltype(e.symlink_status(ec)), file_status>::value, ""); static_assert(std::is_same<decltype(e.symlink_status(ec)), file_status>::value, "");
static_assert(noexcept(e.symlink_status()) == false, ""); static_assert(noexcept(e.symlink_status()) == false, "");
static_assert(noexcept(e.symlink_status(ec)) == true, ""); static_assert(noexcept(e.symlink_status(ec)) == true, "");
} }
path TestCases[] = {static_env.File, static_env.Dir, static_env.SymlinkToFile, path TestCases[] = {static_env.File, static_env.Dir, static_env.SymlinkToFile,
static_env.DNE}; static_env.DNE};
for (const auto& p : TestCases) { for (const auto& p : TestCases) {
const directory_entry e(p); const directory_entry e(p);
std::error_code pec = GetTestEC(), eec = GetTestEC(1); std::error_code pec = GetTestEC(), eec = GetTestEC(1);
file_status ps = fs::symlink_status(p, pec); file_status ps = fs::symlink_status(p, pec);
file_status es = e.symlink_status(eec); file_status es = e.symlink_status(eec);
TEST_CHECK(ps.type() == es.type()); assert(ps.type() == es.type());
TEST_CHECK(ps.permissions() == es.permissions()); assert(ps.permissions() == es.permissions());
TEST_CHECK(pec == eec); assert(pec == eec);
} }
for (const auto& p : TestCases) { for (const auto& p : TestCases) {
const directory_entry e(p); const directory_entry e(p);
file_status ps = fs::symlink_status(p); file_status ps = fs::symlink_status(p);
file_status es = e.symlink_status(); file_status es = e.symlink_status();
TEST_CHECK(ps.type() == es.type()); assert(ps.type() == es.type());
TEST_CHECK(ps.permissions() == es.permissions()); assert(ps.permissions() == es.permissions());
} }
} }
TEST_SUITE_END() int main(int, char**) {
test_signature();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy.pass.cpp

Show All 14 Lines
// directory_iterator(directory_iterator const&); // directory_iterator(directory_iterator const&);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_copy_construct_tests) static void test_constructor_signature()
TEST_CASE(test_constructor_signature)
{ {
using D = directory_iterator; using D = directory_iterator;
static_assert(std::is_copy_constructible<D>::value, ""); static_assert(std::is_copy_constructible<D>::value, "");
} }
TEST_CASE(test_copy_end_iterator) static void test_copy_end_iterator()
{ {
const directory_iterator endIt; const directory_iterator endIt;
directory_iterator it(endIt); directory_iterator it(endIt);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
TEST_CASE(test_copy_valid_iterator) static void test_copy_valid_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const directory_iterator endIt{}; const directory_iterator endIt{};
const directory_iterator it(testDir); const directory_iterator it(testDir);
TEST_REQUIRE(it != endIt); assert(it != endIt);
const path entry = *it; const path entry = *it;
const directory_iterator it2(it); const directory_iterator it2(it);
TEST_REQUIRE(it2 == it); assert(it2 == it);
TEST_CHECK(*it2 == entry); assert(*it2 == entry);
TEST_CHECK(*it == entry); assert(*it == entry);
} }
TEST_SUITE_END() int main(int, char**) {
test_constructor_signature();
test_copy_end_iterator();
test_copy_valid_iterator();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy_assign.pass.cpp

Show All 14 Lines
// directory_iterator& operator=(directory_iterator const&); // directory_iterator& operator=(directory_iterator const&);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_copy_assign_tests) static void test_assignment_signature()
TEST_CASE(test_assignment_signature)
{ {
using D = directory_iterator; using D = directory_iterator;
static_assert(std::is_copy_assignable<D>::value, ""); static_assert(std::is_copy_assignable<D>::value, "");
} }
TEST_CASE(test_copy_to_end_iterator) static void test_copy_to_end_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const directory_iterator from(testDir); const directory_iterator from(testDir);
TEST_REQUIRE(from != directory_iterator{}); assert(from != directory_iterator{});
const path entry = *from; const path entry = *from;
directory_iterator to{}; directory_iterator to{};
to = from; to = from;
TEST_REQUIRE(to == from); assert(to == from);
TEST_CHECK(*to == entry); assert(*to == entry);
TEST_CHECK(*from == entry); assert(*from == entry);
} }
TEST_CASE(test_copy_from_end_iterator) static void test_copy_from_end_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const directory_iterator from{}; const directory_iterator from{};
directory_iterator to(testDir); directory_iterator to(testDir);
TEST_REQUIRE(to != directory_iterator{}); assert(to != directory_iterator{});
to = from; to = from;
TEST_REQUIRE(to == from); assert(to == from);
TEST_CHECK(to == directory_iterator{}); assert(to == directory_iterator{});
} }
TEST_CASE(test_copy_valid_iterator) static void test_copy_valid_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const directory_iterator endIt{}; const directory_iterator endIt{};
directory_iterator it_obj(testDir); directory_iterator it_obj(testDir);
const directory_iterator& it = it_obj; const directory_iterator& it = it_obj;
TEST_REQUIRE(it != endIt); assert(it != endIt);
++it_obj; ++it_obj;
TEST_REQUIRE(it != endIt); assert(it != endIt);
const path entry = *it; const path entry = *it;
directory_iterator it2(testDir); directory_iterator it2(testDir);
TEST_REQUIRE(it2 != it); assert(it2 != it);
const path entry2 = *it2; const path entry2 = *it2;
TEST_CHECK(entry2 != entry); assert(entry2 != entry);
it2 = it; it2 = it;
TEST_REQUIRE(it2 == it); assert(it2 == it);
TEST_CHECK(*it2 == entry); assert(*it2 == entry);
} }
TEST_CASE(test_returns_reference_to_self) static void test_returns_reference_to_self()
{ {
const directory_iterator it; const directory_iterator it;
directory_iterator it2; directory_iterator it2;
directory_iterator& ref = (it2 = it); directory_iterator& ref = (it2 = it);
TEST_CHECK(&ref == &it2); assert(&ref == &it2);
} }
int main(int, char**) {
test_assignment_signature();
test_copy_to_end_iterator();
test_copy_from_end_iterator();
test_copy_valid_iterator();
test_returns_reference_to_self();
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.pass.cpp

Show All 17 Lines
// directory_iterator(const path& p, directory_options options, error_code& ec); // directory_iterator(const path& p, directory_options options, error_code& ec);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_constructor_tests) static void test_constructor_signatures()
TEST_CASE(test_constructor_signatures)
{ {
using D = directory_iterator; using D = directory_iterator;
// explicit directory_iterator(path const&); // explicit directory_iterator(path const&);
static_assert(!std::is_convertible<path, D>::value, ""); static_assert(!std::is_convertible<path, D>::value, "");
static_assert(std::is_constructible<D, path>::value, ""); static_assert(std::is_constructible<D, path>::value, "");
static_assert(!std::is_nothrow_constructible<D, path>::value, ""); static_assert(!std::is_nothrow_constructible<D, path>::value, "");
Show All 10 Linesstatic void test_constructor_signatures()
// directory_iterator(path const&, directory_options, error_code&) // directory_iterator(path const&, directory_options, error_code&)
static_assert(std::is_constructible<D, path, directory_options, static_assert(std::is_constructible<D, path, directory_options,
std::error_code&>::value, ""); std::error_code&>::value, "");
static_assert(!std::is_nothrow_constructible<D, path, directory_options, static_assert(!std::is_nothrow_constructible<D, path, directory_options,
std::error_code&>::value, ""); std::error_code&>::value, "");
} }
TEST_CASE(test_construction_from_bad_path) static void test_construction_from_bad_path()
{ {
static_test_env static_env; static_test_env static_env;
std::error_code ec; std::error_code ec;
directory_options opts = directory_options::none; directory_options opts = directory_options::none;
const directory_iterator endIt; const directory_iterator endIt;
const path testPaths[] = { static_env.DNE, static_env.BadSymlink }; const path testPaths[] = { static_env.DNE, static_env.BadSymlink };
for (path const& testPath : testPaths) for (path const& testPath : testPaths)
{ {
{ {
directory_iterator it(testPath, ec); directory_iterator it(testPath, ec);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
{ {
directory_iterator it(testPath, opts, ec); directory_iterator it(testPath, opts, ec);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
{ {
TEST_CHECK_THROW(filesystem_error, directory_iterator(testPath)); TEST_THROWS_TYPE(filesystem_error, directory_iterator(testPath));
TEST_CHECK_THROW(filesystem_error, directory_iterator(testPath, opts)); TEST_THROWS_TYPE(filesystem_error, directory_iterator(testPath, opts));
} }
} }
} }
TEST_CASE(access_denied_test_case) static void access_denied_test_case()
{ {
using namespace fs; using namespace fs;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path testDir = GetWindowsInaccessibleDir(); const path testDir = GetWindowsInaccessibleDir();
if (testDir.empty()) if (testDir.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
scoped_test_env env; scoped_test_env env;
path const testDir = env.make_env_path("dir1"); path const testDir = env.make_env_path("dir1");
path const testFile = testDir / "testFile"; path const testFile = testDir / "testFile";
env.create_dir(testDir); env.create_dir(testDir);
env.create_file(testFile, 42); env.create_file(testFile, 42);
// Test that we can iterator over the directory before changing the perms // Test that we can iterator over the directory before changing the perms
{ {
directory_iterator it(testDir); directory_iterator it(testDir);
TEST_REQUIRE(it != directory_iterator{}); assert(it != directory_iterator{});
} }
// Change the permissions so we can no longer iterate // Change the permissions so we can no longer iterate
permissions(testDir, perms::none); permissions(testDir, perms::none);
#endif #endif
// Check that the construction fails when skip_permissions_denied is // Check that the construction fails when skip_permissions_denied is
// not given. // not given.
{ {
std::error_code ec; std::error_code ec;
directory_iterator it(testDir, ec); directory_iterator it(testDir, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(it == directory_iterator{}); assert(it == directory_iterator{});
} }
// Check that construction does not report an error when // Check that construction does not report an error when
// 'skip_permissions_denied' is given. // 'skip_permissions_denied' is given.
{ {
std::error_code ec; std::error_code ec;
directory_iterator it(testDir, directory_options::skip_permission_denied, ec); directory_iterator it(testDir, directory_options::skip_permission_denied, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(it == directory_iterator{}); assert(it == directory_iterator{});
} }
} }
TEST_CASE(access_denied_to_file_test_case) static void access_denied_to_file_test_case()
{ {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
path const testFile = env.make_env_path("file1"); path const testFile = env.make_env_path("file1");
env.create_file(testFile, 42); env.create_file(testFile, 42);
// Change the permissions so we can no longer iterate // Change the permissions so we can no longer iterate
permissions(testFile, perms::none); permissions(testFile, perms::none);
// Check that the construction fails when skip_permissions_denied is // Check that the construction fails when skip_permissions_denied is
// not given. // not given.
{ {
std::error_code ec; std::error_code ec;
directory_iterator it(testFile, ec); directory_iterator it(testFile, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(it == directory_iterator{}); assert(it == directory_iterator{});
} }
// Check that construction still fails when 'skip_permissions_denied' is given // Check that construction still fails when 'skip_permissions_denied' is given
// because we tried to open a file and not a directory. // because we tried to open a file and not a directory.
{ {
std::error_code ec; std::error_code ec;
directory_iterator it(testFile, directory_options::skip_permission_denied, ec); directory_iterator it(testFile, directory_options::skip_permission_denied, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(it == directory_iterator{}); assert(it == directory_iterator{});
} }
} }
TEST_CASE(test_open_on_empty_directory_equals_end) static void test_open_on_empty_directory_equals_end()
{ {
scoped_test_env env; scoped_test_env env;
const path testDir = env.make_env_path("dir1"); const path testDir = env.make_env_path("dir1");
env.create_dir(testDir); env.create_dir(testDir);
const directory_iterator endIt; const directory_iterator endIt;
{ {
std::error_code ec; std::error_code ec;
directory_iterator it(testDir, ec); directory_iterator it(testDir, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
{ {
directory_iterator it(testDir); directory_iterator it(testDir);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
} }
TEST_CASE(test_open_on_directory_succeeds) static void test_open_on_directory_succeeds()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
std::set<path> dir_contents(static_env.DirIterationList.begin(), std::set<path> dir_contents(static_env.DirIterationList.begin(),
static_env.DirIterationList.end()); static_env.DirIterationList.end());
const directory_iterator endIt{}; const directory_iterator endIt{};
{ {
std::error_code ec; std::error_code ec;
directory_iterator it(testDir, ec); directory_iterator it(testDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(it != endIt); assert(it != endIt);
TEST_CHECK(dir_contents.count(*it)); assert(dir_contents.count(*it));
} }
{ {
directory_iterator it(testDir); directory_iterator it(testDir);
TEST_CHECK(it != endIt); assert(it != endIt);
TEST_CHECK(dir_contents.count(*it)); assert(dir_contents.count(*it));
} }
} }
TEST_CASE(test_open_on_file_fails) static void test_open_on_file_fails()
{ {
static_test_env static_env; static_test_env static_env;
const path testFile = static_env.File; const path testFile = static_env.File;
const directory_iterator endIt{}; const directory_iterator endIt{};
{ {
std::error_code ec; std::error_code ec;
directory_iterator it(testFile, ec); directory_iterator it(testFile, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
{ {
TEST_CHECK_THROW(filesystem_error, directory_iterator(testFile)); TEST_THROWS_TYPE(filesystem_error, directory_iterator(testFile));
} }
} }
TEST_CASE(test_open_on_empty_string) static void test_open_on_empty_string()
{ {
const path testPath = ""; const path testPath = "";
const directory_iterator endIt{}; const directory_iterator endIt{};
std::error_code ec; std::error_code ec;
directory_iterator it(testPath, ec); directory_iterator it(testPath, ec);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
TEST_CASE(test_open_on_dot_dir) static void test_open_on_dot_dir()
{ {
const path testPath = "."; const path testPath = ".";
std::error_code ec; std::error_code ec;
directory_iterator it(testPath, ec); directory_iterator it(testPath, ec);
TEST_CHECK(!ec); assert(!ec);
} }
TEST_CASE(test_open_on_symlink) static void test_open_on_symlink()
{ {
static_test_env static_env; static_test_env static_env;
const path symlinkToDir = static_env.SymlinkToDir; const path symlinkToDir = static_env.SymlinkToDir;
std::set<path> dir_contents; std::set<path> dir_contents;
for (path const& p : static_env.DirIterationList) { for (path const& p : static_env.DirIterationList) {
dir_contents.insert(p.filename()); dir_contents.insert(p.filename());
} }
const directory_iterator endIt{}; const directory_iterator endIt{};
{ {
std::error_code ec; std::error_code ec;
directory_iterator it(symlinkToDir, ec); directory_iterator it(symlinkToDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(it != endIt); assert(it != endIt);
path const& entry = *it; path const& entry = *it;
TEST_CHECK(dir_contents.count(entry.filename())); assert(dir_contents.count(entry.filename()));
} }
{ {
std::error_code ec; std::error_code ec;
directory_iterator it(symlinkToDir, directory_iterator it(symlinkToDir,
directory_options::follow_directory_symlink, ec); directory_options::follow_directory_symlink, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(it != endIt); assert(it != endIt);
path const& entry = *it; path const& entry = *it;
TEST_CHECK(dir_contents.count(entry.filename())); assert(dir_contents.count(entry.filename()));
} }
} }
TEST_SUITE_END() int main(int, char**) {
test_constructor_signatures();
test_construction_from_bad_path();
access_denied_test_case();
access_denied_to_file_test_case();
test_open_on_empty_directory_equals_end();
test_open_on_directory_succeeds();
test_open_on_file_fails();
test_open_on_empty_string();
test_open_on_dot_dir();
test_open_on_symlink();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/increment.pass.cpp

Show All 15 Lines
// directory_iterator& increment(error_code& ec); // directory_iterator& increment(error_code& ec);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_increment_tests) static void test_increment_signatures()
TEST_CASE(test_increment_signatures)
{ {
directory_iterator d; ((void)d); directory_iterator d; ((void)d);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(++d), directory_iterator&); ASSERT_SAME_TYPE(decltype(++d), directory_iterator&);
ASSERT_NOT_NOEXCEPT(++d); ASSERT_NOT_NOEXCEPT(++d);
ASSERT_SAME_TYPE(decltype(d.increment(ec)), directory_iterator&); ASSERT_SAME_TYPE(decltype(d.increment(ec)), directory_iterator&);
ASSERT_NOT_NOEXCEPT(d.increment(ec)); ASSERT_NOT_NOEXCEPT(d.increment(ec));
} }
TEST_CASE(test_prefix_increment) static void test_prefix_increment()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const std::set<path> dir_contents(static_env.DirIterationList.begin(), const std::set<path> dir_contents(static_env.DirIterationList.begin(),
static_env.DirIterationList.end()); static_env.DirIterationList.end());
const directory_iterator endIt{}; const directory_iterator endIt{};
std::error_code ec; std::error_code ec;
directory_iterator it(testDir, ec); directory_iterator it(testDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
std::set<path> unseen_entries = dir_contents; std::set<path> unseen_entries = dir_contents;
while (!unseen_entries.empty()) { while (!unseen_entries.empty()) {
TEST_REQUIRE(it != endIt); assert(it != endIt);
const path entry = *it; const path entry = *it;
TEST_REQUIRE(unseen_entries.erase(entry) == 1); assert(unseen_entries.erase(entry) == 1);
directory_iterator& it_ref = ++it; directory_iterator& it_ref = ++it;
TEST_CHECK(&it_ref == &it); assert(&it_ref == &it);
} }
TEST_CHECK(it == endIt); assert(it == endIt);
} }
TEST_CASE(test_postfix_increment) static void test_postfix_increment()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const std::set<path> dir_contents(static_env.DirIterationList.begin(), const std::set<path> dir_contents(static_env.DirIterationList.begin(),
static_env.DirIterationList.end()); static_env.DirIterationList.end());
const directory_iterator endIt{}; const directory_iterator endIt{};
std::error_code ec; std::error_code ec;
directory_iterator it(testDir, ec); directory_iterator it(testDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
std::set<path> unseen_entries = dir_contents; std::set<path> unseen_entries = dir_contents;
while (!unseen_entries.empty()) { while (!unseen_entries.empty()) {
TEST_REQUIRE(it != endIt); assert(it != endIt);
const path entry = *it; const path entry = *it;
TEST_REQUIRE(unseen_entries.erase(entry) == 1); assert(unseen_entries.erase(entry) == 1);
const path entry2 = *it++; const path entry2 = *it++;
TEST_CHECK(entry2 == entry); assert(entry2 == entry);
} }
TEST_CHECK(it == endIt); assert(it == endIt);
} }
TEST_CASE(test_increment_method) static void test_increment_method()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const std::set<path> dir_contents(static_env.DirIterationList.begin(), const std::set<path> dir_contents(static_env.DirIterationList.begin(),
static_env.DirIterationList.end()); static_env.DirIterationList.end());
const directory_iterator endIt{}; const directory_iterator endIt{};
std::error_code ec; std::error_code ec;
directory_iterator it(testDir, ec); directory_iterator it(testDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
std::set<path> unseen_entries = dir_contents; std::set<path> unseen_entries = dir_contents;
while (!unseen_entries.empty()) { while (!unseen_entries.empty()) {
TEST_REQUIRE(it != endIt); assert(it != endIt);
const path entry = *it; const path entry = *it;
TEST_REQUIRE(unseen_entries.erase(entry) == 1); assert(unseen_entries.erase(entry) == 1);
directory_iterator& it_ref = it.increment(ec); directory_iterator& it_ref = it.increment(ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(&it_ref == &it); assert(&it_ref == &it);
} }
TEST_CHECK(it == endIt); assert(it == endIt);
} }
TEST_SUITE_END() int main(int, char**) {
test_increment_signatures();
test_prefix_increment();
test_postfix_increment();
test_increment_method();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move.pass.cpp

Show All 14 Lines
// directory_iterator(directory_iterator&&) noexcept; // directory_iterator(directory_iterator&&) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_move_construct_tests) static void test_constructor_signature()
TEST_CASE(test_constructor_signature)
{ {
using D = directory_iterator; using D = directory_iterator;
static_assert(std::is_nothrow_move_constructible<D>::value, ""); static_assert(std::is_nothrow_move_constructible<D>::value, "");
} }
TEST_CASE(test_move_end_iterator) static void test_move_end_iterator()
{ {
const directory_iterator endIt; const directory_iterator endIt;
directory_iterator endIt2{}; directory_iterator endIt2{};
directory_iterator it(std::move(endIt2)); directory_iterator it(std::move(endIt2));
TEST_CHECK(it == endIt); assert(it == endIt);
TEST_CHECK(endIt2 == endIt); assert(endIt2 == endIt);
} }
TEST_CASE(test_move_valid_iterator) static void test_move_valid_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const directory_iterator endIt{}; const directory_iterator endIt{};
directory_iterator it(testDir); directory_iterator it(testDir);
TEST_REQUIRE(it != endIt); assert(it != endIt);
const path entry = *it; const path entry = *it;
const directory_iterator it2(std::move(it)); const directory_iterator it2(std::move(it));
TEST_CHECK(*it2 == entry); assert(*it2 == entry);
TEST_CHECK(it == it2 || it == endIt); assert(it == it2 || it == endIt);
} }
TEST_SUITE_END() int main(int, char**) {
test_constructor_signature();
test_move_end_iterator();
test_move_valid_iterator();
return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_assign.pass.cpp

Show All 14 Lines
// directory_iterator& operator=(directory_iterator const&); // directory_iterator& operator=(directory_iterator const&);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
// The filesystem specification explicitly allows for self-move on // The filesystem specification explicitly allows for self-move on
// the directory iterators. Turn off this warning so we can test it. // the directory iterators. Turn off this warning so we can test it.
TEST_CLANG_DIAGNOSTIC_IGNORED("-Wself-move") TEST_CLANG_DIAGNOSTIC_IGNORED("-Wself-move")
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_move_assign_tests) static void test_assignment_signature()
TEST_CASE(test_assignment_signature)
{ {
using D = directory_iterator; using D = directory_iterator;
static_assert(std::is_nothrow_move_assignable<D>::value, ""); static_assert(std::is_nothrow_move_assignable<D>::value, "");
} }
TEST_CASE(test_move_to_end_iterator) static void test_move_to_end_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
directory_iterator from(testDir); directory_iterator from(testDir);
TEST_REQUIRE(from != directory_iterator{}); assert(from != directory_iterator{});
const path entry = *from; const path entry = *from;
directory_iterator to{}; directory_iterator to{};
to = std::move(from); to = std::move(from);
TEST_REQUIRE(to != directory_iterator{}); assert(to != directory_iterator{});
TEST_CHECK(*to == entry); assert(*to == entry);
} }
TEST_CASE(test_move_from_end_iterator) static void test_move_from_end_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
directory_iterator from{}; directory_iterator from{};
directory_iterator to(testDir); directory_iterator to(testDir);
TEST_REQUIRE(to != from); assert(to != from);
to = std::move(from); to = std::move(from);
TEST_REQUIRE(to == directory_iterator{}); assert(to == directory_iterator{});
TEST_REQUIRE(from == directory_iterator{}); assert(from == directory_iterator{});
} }
TEST_CASE(test_move_valid_iterator) static void test_move_valid_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const directory_iterator endIt{}; const directory_iterator endIt{};
directory_iterator it(testDir); directory_iterator it(testDir);
TEST_REQUIRE(it != endIt); assert(it != endIt);
++it; ++it;
TEST_REQUIRE(it != endIt); assert(it != endIt);
const path entry = *it; const path entry = *it;
directory_iterator it2(testDir); directory_iterator it2(testDir);
TEST_REQUIRE(it2 != it); assert(it2 != it);
const path entry2 = *it2; const path entry2 = *it2;
TEST_CHECK(entry2 != entry); assert(entry2 != entry);
it2 = std::move(it); it2 = std::move(it);
TEST_REQUIRE(it2 != directory_iterator{}); assert(it2 != directory_iterator{});
TEST_CHECK(*it2 == entry); assert(*it2 == entry);
} }
TEST_CASE(test_returns_reference_to_self) static void test_returns_reference_to_self()
{ {
directory_iterator it; directory_iterator it;
directory_iterator it2; directory_iterator it2;
directory_iterator& ref = (it2 = it); directory_iterator& ref = (it2 = it);
TEST_CHECK(&ref == &it2); assert(&ref == &it2);
} }
TEST_CASE(test_self_move) static void test_self_move()
{ {
static_test_env static_env; static_test_env static_env;
// Create two non-equal iterators that have exactly the same state. // Create two non-equal iterators that have exactly the same state.
directory_iterator it(static_env.Dir); directory_iterator it(static_env.Dir);
directory_iterator it2(static_env.Dir); directory_iterator it2(static_env.Dir);
++it; ++it2; ++it; ++it2;
TEST_CHECK(it != it2); assert(it != it2);
TEST_CHECK(*it2 == *it); assert(*it2 == *it);
it = std::move(it); it = std::move(it);
TEST_CHECK(*it2 == *it); assert(*it2 == *it);
} }
int main(int, char**) {
test_assignment_signature();
test_move_to_end_iterator();
test_move_from_end_iterator();
test_move_valid_iterator();
test_returns_reference_to_self();
test_self_move();
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.nonmembers/begin_end.pass.cpp

Show All 15 Lines
// directory_iterator end(directory_iterator iter) noexcept; // directory_iterator end(directory_iterator iter) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(directory_iterator_begin_end_tests) static void test_function_signatures()
TEST_CASE(test_function_signatures)
{ {
directory_iterator d; directory_iterator d;
ASSERT_SAME_TYPE(decltype(begin(d)), directory_iterator); ASSERT_SAME_TYPE(decltype(begin(d)), directory_iterator);
ASSERT_SAME_TYPE(decltype(begin(std::move(d))), directory_iterator); ASSERT_SAME_TYPE(decltype(begin(std::move(d))), directory_iterator);
ASSERT_NOEXCEPT(begin(d)); ASSERT_NOEXCEPT(begin(d));
ASSERT_NOEXCEPT(begin(std::move(d))); ASSERT_NOEXCEPT(begin(std::move(d)));
ASSERT_SAME_TYPE(decltype(end(d)), directory_iterator); ASSERT_SAME_TYPE(decltype(end(d)), directory_iterator);
ASSERT_SAME_TYPE(decltype(end(std::move(d))), directory_iterator); ASSERT_SAME_TYPE(decltype(end(std::move(d))), directory_iterator);
ASSERT_NOEXCEPT(end(d)); ASSERT_NOEXCEPT(end(d));
ASSERT_NOEXCEPT(end(std::move(d))); ASSERT_NOEXCEPT(end(std::move(d)));
} }
TEST_CASE(test_ranged_for_loop) static void test_ranged_for_loop()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
std::set<path> dir_contents(static_env.DirIterationList.begin(), std::set<path> dir_contents(static_env.DirIterationList.begin(),
static_env.DirIterationList.end()); static_env.DirIterationList.end());
std::error_code ec; std::error_code ec;
directory_iterator it(testDir, ec); directory_iterator it(testDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
for (auto& elem : it) { for (auto& elem : it) {
TEST_CHECK(dir_contents.erase(elem) == 1); assert(dir_contents.erase(elem) == 1);
} }
TEST_CHECK(dir_contents.empty()); assert(dir_contents.empty());
} }
TEST_SUITE_END() int main(int, char**) {
test_function_signatures();
test_ranged_for_loop();
return 0;
}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy.pass.cpp

Show All 14 Lines
// recursive_recursive_directory_iterator(recursive_recursive_directory_iterator const&); // recursive_recursive_directory_iterator(recursive_recursive_directory_iterator const&);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_copy_construct_tests) static void test_constructor_signature()
TEST_CASE(test_constructor_signature)
{ {
using D = recursive_directory_iterator; using D = recursive_directory_iterator;
static_assert(std::is_copy_constructible<D>::value, ""); static_assert(std::is_copy_constructible<D>::value, "");
//static_assert(!std::is_nothrow_copy_constructible<D>::value, ""); //static_assert(!std::is_nothrow_copy_constructible<D>::value, "");
} }
TEST_CASE(test_copy_end_iterator) static void test_copy_end_iterator()
{ {
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
recursive_directory_iterator it(endIt); recursive_directory_iterator it(endIt);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
TEST_CASE(test_copy_valid_iterator) static void test_copy_valid_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const recursive_directory_iterator endIt{}; const recursive_directory_iterator endIt{};
// build 'it' up with "interesting" non-default state so we can test // build 'it' up with "interesting" non-default state so we can test
// that it gets copied. We want to get 'it' into a state such that: // that it gets copied. We want to get 'it' into a state such that:
// it.options() != directory_options::none // it.options() != directory_options::none
// it.depth() != 0 // it.depth() != 0
// it.recursion_pending() != true // it.recursion_pending() != true
const directory_options opts = directory_options::skip_permission_denied; const directory_options opts = directory_options::skip_permission_denied;
recursive_directory_iterator it(testDir, opts); recursive_directory_iterator it(testDir, opts);
TEST_REQUIRE(it != endIt); assert(it != endIt);
while (it.depth() == 0) { while (it.depth() == 0) {
++it; ++it;
TEST_REQUIRE(it != endIt); assert(it != endIt);
} }
it.disable_recursion_pending(); it.disable_recursion_pending();
TEST_CHECK(it.options() == opts); assert(it.options() == opts);
TEST_CHECK(it.depth() == 1); assert(it.depth() == 1);
TEST_CHECK(it.recursion_pending() == false); assert(it.recursion_pending() == false);
const path entry = *it; const path entry = *it;
// OPERATION UNDER TEST // // OPERATION UNDER TEST //
const recursive_directory_iterator it2(it); const recursive_directory_iterator it2(it);
// ------------------- // // ------------------- //
TEST_REQUIRE(it2 == it); assert(it2 == it);
TEST_CHECK(*it2 == entry); assert(*it2 == entry);
TEST_CHECK(it2.depth() == 1); assert(it2.depth() == 1);
TEST_CHECK(it2.recursion_pending() == false); assert(it2.recursion_pending() == false);
TEST_CHECK(it != endIt); assert(it != endIt);
} }
TEST_SUITE_END() int main(int, char**) {
test_constructor_signature();
test_copy_end_iterator();
test_copy_valid_iterator();
return 0;
}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy_assign.pass.cpp

Show All 14 Lines
// recursive_directory_iterator& operator=(recursive_directory_iterator const&); // recursive_directory_iterator& operator=(recursive_directory_iterator const&);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_copy_assign_tests)
recursive_directory_iterator createInterestingIterator(const static_test_env &static_env) recursive_directory_iterator createInterestingIterator(const static_test_env &static_env)
// Create an "interesting" iterator where all fields are // Create an "interesting" iterator where all fields are
// in a non-default state. The returned 'it' is in a // in a non-default state. The returned 'it' is in a
// state such that: // state such that:
// it.options() == directory_options::skip_permission_denied // it.options() == directory_options::skip_permission_denied
// it.depth() == 1 // it.depth() == 1
// it.recursion_pending() == true // it.recursion_pending() == true
{ {
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
recursive_directory_iterator it(testDir, recursive_directory_iterator it(testDir,
directory_options::skip_permission_denied); directory_options::skip_permission_denied);
TEST_ASSERT(it != endIt); assert(it != endIt);
while (it.depth() != 1) { while (it.depth() != 1) {
++it; ++it;
TEST_ASSERT(it != endIt); assert(it != endIt);
} }
TEST_ASSERT(it.depth() == 1); assert(it.depth() == 1);
it.disable_recursion_pending(); it.disable_recursion_pending();
return it; return it;
} }
recursive_directory_iterator createDifferentInterestingIterator(const static_test_env &static_env) recursive_directory_iterator createDifferentInterestingIterator(const static_test_env &static_env)
// Create an "interesting" iterator where all fields are // Create an "interesting" iterator where all fields are
// in a non-default state. The returned 'it' is in a // in a non-default state. The returned 'it' is in a
// state such that: // state such that:
// it.options() == directory_options::follow_directory_symlink // it.options() == directory_options::follow_directory_symlink
// it.depth() == 2 // it.depth() == 2
// it.recursion_pending() == false // it.recursion_pending() == false
{ {
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
recursive_directory_iterator it(testDir, recursive_directory_iterator it(testDir,
directory_options::follow_directory_symlink); directory_options::follow_directory_symlink);
TEST_ASSERT(it != endIt); assert(it != endIt);
while (it.depth() != 2) { while (it.depth() != 2) {
++it; ++it;
TEST_ASSERT(it != endIt); assert(it != endIt);
} }
TEST_ASSERT(it.depth() == 2); assert(it.depth() == 2);
return it; return it;
} }
TEST_CASE(test_assignment_signature) { static void test_assignment_signature() {
using D = recursive_directory_iterator; using D = recursive_directory_iterator;
static_assert(std::is_copy_assignable<D>::value, ""); static_assert(std::is_copy_assignable<D>::value, "");
} }
TEST_CASE(test_copy_to_end_iterator) static void test_copy_to_end_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
const recursive_directory_iterator from = createInterestingIterator(static_env); const recursive_directory_iterator from = createInterestingIterator(static_env);
const path entry = *from; const path entry = *from;
recursive_directory_iterator to; recursive_directory_iterator to;
to = from; to = from;
TEST_REQUIRE(to == from); assert(to == from);
TEST_CHECK(*to == entry); assert(*to == entry);
TEST_CHECK(to.options() == from.options()); assert(to.options() == from.options());
TEST_CHECK(to.depth() == from.depth()); assert(to.depth() == from.depth());
TEST_CHECK(to.recursion_pending() == from.recursion_pending()); assert(to.recursion_pending() == from.recursion_pending());
} }
TEST_CASE(test_copy_from_end_iterator) static void test_copy_from_end_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const recursive_directory_iterator from; const recursive_directory_iterator from;
recursive_directory_iterator to = createInterestingIterator(static_env); recursive_directory_iterator to = createInterestingIterator(static_env);
to = from; to = from;
TEST_REQUIRE(to == from); assert(to == from);
TEST_CHECK(to == recursive_directory_iterator{}); assert(to == recursive_directory_iterator{});
} }
TEST_CASE(test_copy_valid_iterator) static void test_copy_valid_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
const recursive_directory_iterator it = createInterestingIterator(static_env); const recursive_directory_iterator it = createInterestingIterator(static_env);
const path entry = *it; const path entry = *it;
recursive_directory_iterator it2 = createDifferentInterestingIterator(static_env); recursive_directory_iterator it2 = createDifferentInterestingIterator(static_env);
TEST_REQUIRE(it2 != it); assert(it2 != it);
TEST_CHECK(it2.options() != it.options()); assert(it2.options() != it.options());
TEST_CHECK(it2.depth() != it.depth()); assert(it2.depth() != it.depth());
TEST_CHECK(it2.recursion_pending() != it.recursion_pending()); assert(it2.recursion_pending() != it.recursion_pending());
TEST_CHECK(*it2 != entry); assert(*it2 != entry);
it2 = it; it2 = it;
TEST_REQUIRE(it2 == it); assert(it2 == it);
TEST_CHECK(it2.options() == it.options()); assert(it2.options() == it.options());
TEST_CHECK(it2.depth() == it.depth()); assert(it2.depth() == it.depth());
TEST_CHECK(it2.recursion_pending() == it.recursion_pending()); assert(it2.recursion_pending() == it.recursion_pending());
TEST_CHECK(*it2 == entry); assert(*it2 == entry);
} }
TEST_CASE(test_returns_reference_to_self) static void test_returns_reference_to_self()
{ {
const recursive_directory_iterator it; const recursive_directory_iterator it;
recursive_directory_iterator it2; recursive_directory_iterator it2;
recursive_directory_iterator& ref = (it2 = it); recursive_directory_iterator& ref = (it2 = it);
TEST_CHECK(&ref == &it2); assert(&ref == &it2);
} }
TEST_CASE(test_self_copy) static void test_self_copy()
{ {
static_test_env static_env; static_test_env static_env;
// Create two non-equal iterators that have exactly the same state. // Create two non-equal iterators that have exactly the same state.
recursive_directory_iterator it = createInterestingIterator(static_env); recursive_directory_iterator it = createInterestingIterator(static_env);
recursive_directory_iterator it2 = createInterestingIterator(static_env); recursive_directory_iterator it2 = createInterestingIterator(static_env);
TEST_CHECK(it != it2); assert(it != it2);
TEST_CHECK(it2.options() == it.options()); assert(it2.options() == it.options());
TEST_CHECK(it2.depth() == it.depth()); assert(it2.depth() == it.depth());
TEST_CHECK(it2.recursion_pending() == it.recursion_pending()); assert(it2.recursion_pending() == it.recursion_pending());
TEST_CHECK(*it2 == *it); assert(*it2 == *it);
// perform a self-copy and check that the state still matches the // perform a self-copy and check that the state still matches the
// other unmodified iterator. // other unmodified iterator.
recursive_directory_iterator const& cit = it; recursive_directory_iterator const& cit = it;
it = cit; it = cit;
TEST_CHECK(it2.options() == it.options()); assert(it2.options() == it.options());
TEST_CHECK(it2.depth() == it.depth()); assert(it2.depth() == it.depth());
TEST_CHECK(it2.recursion_pending() == it.recursion_pending()); assert(it2.recursion_pending() == it.recursion_pending());
TEST_CHECK(*it2 == *it); assert(*it2 == *it);
} }
TEST_SUITE_END() int main(int, char**) {
test_assignment_signature();
test_copy_to_end_iterator();
test_copy_from_end_iterator();
test_copy_valid_iterator();
test_returns_reference_to_self();
test_self_copy();
return 0;
}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp

Show All 18 Lines
// recursive_directory_iterator(const path& p, directory_options options, error_code& ec); // recursive_directory_iterator(const path& p, directory_options options, error_code& ec);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "assert_macros.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
using RDI = recursive_directory_iterator; using RDI = recursive_directory_iterator;
TEST_SUITE(recursive_directory_iterator_constructor_tests) static void test_constructor_signatures()
TEST_CASE(test_constructor_signatures)
{ {
using D = recursive_directory_iterator; using D = recursive_directory_iterator;
// explicit directory_iterator(path const&); // explicit directory_iterator(path const&);
static_assert(!std::is_convertible<path, D>::value, ""); static_assert(!std::is_convertible<path, D>::value, "");
static_assert(std::is_constructible<D, path>::value, ""); static_assert(std::is_constructible<D, path>::value, "");
static_assert(!std::is_nothrow_constructible<D, path>::value, ""); static_assert(!std::is_nothrow_constructible<D, path>::value, "");
// directory_iterator(path const&, error_code&) // directory_iterator(path const&, error_code&)
static_assert(std::is_constructible<D, path, static_assert(std::is_constructible<D, path,
std::error_code&>::value, ""); std::error_code&>::value, "");
static_assert(!std::is_nothrow_constructible<D, path, static_assert(!std::is_nothrow_constructible<D, path,
std::error_code&>::value, ""); std::error_code&>::value, "");
// directory_iterator(path const&, directory_options); // directory_iterator(path const&, directory_options);
static_assert(std::is_constructible<D, path, directory_options>::value, ""); static_assert(std::is_constructible<D, path, directory_options>::value, "");
static_assert(!std::is_nothrow_constructible<D, path, directory_options>::value, ""); static_assert(!std::is_nothrow_constructible<D, path, directory_options>::value, "");
// directory_iterator(path const&, directory_options, error_code&) // directory_iterator(path const&, directory_options, error_code&)
static_assert(std::is_constructible<D, path, directory_options, std::error_code&>::value, ""); static_assert(std::is_constructible<D, path, directory_options, std::error_code&>::value, "");
static_assert(!std::is_nothrow_constructible<D, path, directory_options, std::error_code&>::value, ""); static_assert(!std::is_nothrow_constructible<D, path, directory_options, std::error_code&>::value, "");
} }
TEST_CASE(test_construction_from_bad_path) static void test_construction_from_bad_path()
{ {
static_test_env static_env; static_test_env static_env;
std::error_code ec; std::error_code ec;
directory_options opts = directory_options::none; directory_options opts = directory_options::none;
const RDI endIt; const RDI endIt;
const path testPaths[] = { static_env.DNE, static_env.BadSymlink }; const path testPaths[] = { static_env.DNE, static_env.BadSymlink };
for (path const& testPath : testPaths) for (path const& testPath : testPaths)
{ {
{ {
RDI it(testPath, ec); RDI it(testPath, ec);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
{ {
RDI it(testPath, opts, ec); RDI it(testPath, opts, ec);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
{ {
TEST_CHECK_THROW(filesystem_error, RDI(testPath)); TEST_THROWS_TYPE(filesystem_error, RDI(testPath));
TEST_CHECK_THROW(filesystem_error, RDI(testPath, opts)); TEST_THROWS_TYPE(filesystem_error, RDI(testPath, opts));
} }
} }
} }
TEST_CASE(access_denied_test_case) static void access_denied_test_case()
{ {
using namespace fs; using namespace fs;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path testDir = GetWindowsInaccessibleDir(); const path testDir = GetWindowsInaccessibleDir();
if (testDir.empty()) if (testDir.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
scoped_test_env env; scoped_test_env env;
path const testDir = env.make_env_path("dir1"); path const testDir = env.make_env_path("dir1");
path const testFile = testDir / "testFile"; path const testFile = testDir / "testFile";
env.create_dir(testDir); env.create_dir(testDir);
env.create_file(testFile, 42); env.create_file(testFile, 42);
// Test that we can iterator over the directory before changing the perms // Test that we can iterator over the directory before changing the perms
{ {
RDI it(testDir); RDI it(testDir);
TEST_REQUIRE(it != RDI{}); assert(it != RDI{});
} }
// Change the permissions so we can no longer iterate // Change the permissions so we can no longer iterate
permissions(testDir, perms::none); permissions(testDir, perms::none);
#endif #endif
// Check that the construction fails when skip_permissions_denied is // Check that the construction fails when skip_permissions_denied is
// not given. // not given.
{ {
std::error_code ec; std::error_code ec;
RDI it(testDir, ec); RDI it(testDir, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(it == RDI{}); assert(it == RDI{});
} }
// Check that construction does not report an error when // Check that construction does not report an error when
// 'skip_permissions_denied' is given. // 'skip_permissions_denied' is given.
{ {
std::error_code ec; std::error_code ec;
RDI it(testDir, directory_options::skip_permission_denied, ec); RDI it(testDir, directory_options::skip_permission_denied, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(it == RDI{}); assert(it == RDI{});
} }
} }
TEST_CASE(access_denied_to_file_test_case) static void access_denied_to_file_test_case()
{ {
using namespace fs; using namespace fs;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path testDir = GetWindowsInaccessibleDir(); const path testDir = GetWindowsInaccessibleDir();
if (testDir.empty()) if (testDir.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
path const testFile = testDir / "inaccessible_file"; path const testFile = testDir / "inaccessible_file";
#else #else
scoped_test_env env; scoped_test_env env;
path const testFile = env.make_env_path("file1"); path const testFile = env.make_env_path("file1");
env.create_file(testFile, 42); env.create_file(testFile, 42);
// Change the permissions so we can no longer iterate // Change the permissions so we can no longer iterate
permissions(testFile, perms::none); permissions(testFile, perms::none);
#endif #endif
// Check that the construction fails when skip_permissions_denied is // Check that the construction fails when skip_permissions_denied is
// not given. // not given.
{ {
std::error_code ec; std::error_code ec;
RDI it(testFile, ec); RDI it(testFile, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(it == RDI{}); assert(it == RDI{});
} }
// Check that construction still fails when 'skip_permissions_denied' is given // Check that construction still fails when 'skip_permissions_denied' is given
// because we tried to open a file and not a directory. // because we tried to open a file and not a directory.
{ {
std::error_code ec; std::error_code ec;
RDI it(testFile, directory_options::skip_permission_denied, ec); RDI it(testFile, directory_options::skip_permission_denied, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(it == RDI{}); assert(it == RDI{});
} }
} }
TEST_CASE(test_open_on_empty_directory_equals_end) static void test_open_on_empty_directory_equals_end()
{ {
scoped_test_env env; scoped_test_env env;
const path testDir = env.make_env_path("dir1"); const path testDir = env.make_env_path("dir1");
env.create_dir(testDir); env.create_dir(testDir);
const RDI endIt; const RDI endIt;
{ {
std::error_code ec; std::error_code ec;
RDI it(testDir, ec); RDI it(testDir, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
{ {
RDI it(testDir); RDI it(testDir);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
} }
TEST_CASE(test_open_on_directory_succeeds) static void test_open_on_directory_succeeds()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
std::set<path> dir_contents(static_env.DirIterationList.begin(), std::set<path> dir_contents(static_env.DirIterationList.begin(),
static_env.DirIterationList.end()); static_env.DirIterationList.end());
const RDI endIt{}; const RDI endIt{};
{ {
std::error_code ec; std::error_code ec;
RDI it(testDir, ec); RDI it(testDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(it != endIt); assert(it != endIt);
TEST_CHECK(dir_contents.count(*it)); assert(dir_contents.count(*it));
} }
{ {
RDI it(testDir); RDI it(testDir);
TEST_CHECK(it != endIt); assert(it != endIt);
TEST_CHECK(dir_contents.count(*it)); assert(dir_contents.count(*it));
} }
} }
TEST_CASE(test_open_on_file_fails) static void test_open_on_file_fails()
{ {
static_test_env static_env; static_test_env static_env;
const path testFile = static_env.File; const path testFile = static_env.File;
const RDI endIt{}; const RDI endIt{};
{ {
std::error_code ec; std::error_code ec;
RDI it(testFile, ec); RDI it(testFile, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
{ {
TEST_CHECK_THROW(filesystem_error, RDI(testFile)); TEST_THROWS_TYPE(filesystem_error, RDI(testFile));
} }
} }
TEST_CASE(test_options_post_conditions) static void test_options_post_conditions()
{ {
static_test_env static_env; static_test_env static_env;
const path goodDir = static_env.Dir; const path goodDir = static_env.Dir;
const path badDir = static_env.DNE; const path badDir = static_env.DNE;
{ {
std::error_code ec; std::error_code ec;
RDI it1(goodDir, ec); RDI it1(goodDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(it1.options() == directory_options::none); assert(it1.options() == directory_options::none);
RDI it2(badDir, ec); RDI it2(badDir, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_REQUIRE(it2 == RDI{}); assert(it2 == RDI{});
} }
{ {
std::error_code ec; std::error_code ec;
const directory_options opts = directory_options::skip_permission_denied; const directory_options opts = directory_options::skip_permission_denied;
RDI it1(goodDir, opts, ec); RDI it1(goodDir, opts, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(it1.options() == opts); assert(it1.options() == opts);
RDI it2(badDir, opts, ec); RDI it2(badDir, opts, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_REQUIRE(it2 == RDI{}); assert(it2 == RDI{});
} }
{ {
RDI it(goodDir); RDI it(goodDir);
TEST_CHECK(it.options() == directory_options::none); assert(it.options() == directory_options::none);
} }
{ {
const directory_options opts = directory_options::follow_directory_symlink; const directory_options opts = directory_options::follow_directory_symlink;
RDI it(goodDir, opts); RDI it(goodDir, opts);
TEST_CHECK(it.options() == opts); assert(it.options() == opts);
}
} }
int main(int, char**) {
test_constructor_signatures();
test_construction_from_bad_path();
access_denied_test_case();
access_denied_to_file_test_case();
test_open_on_empty_directory_equals_end();
test_open_on_directory_succeeds();
test_open_on_file_fails();
test_options_post_conditions();
return 0;
} }
TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/depth.pass.cpp

Show All 14 Lines
// int depth() const // int depth() const
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_depth_tests) static void test_depth()
TEST_CASE(test_depth)
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const path DirDepth1 = static_env.Dir2; const path DirDepth1 = static_env.Dir2;
const path DirDepth2 = static_env.Dir3; const path DirDepth2 = static_env.Dir3;
const recursive_directory_iterator endIt{}; const recursive_directory_iterator endIt{};
std::error_code ec; std::error_code ec;
recursive_directory_iterator it(testDir, ec); recursive_directory_iterator it(testDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(it.depth() == 0); assert(it.depth() == 0);
bool seen_d1, seen_d2; bool seen_d1, seen_d2;
seen_d1 = seen_d2 = false; seen_d1 = seen_d2 = false;
while (it != endIt) { while (it != endIt) {
const path entry = *it; const path entry = *it;
const path parent = entry.parent_path(); const path parent = entry.parent_path();
if (parent == testDir) { if (parent == testDir) {
TEST_CHECK(it.depth() == 0); assert(it.depth() == 0);
} else if (parent == DirDepth1) { } else if (parent == DirDepth1) {
TEST_CHECK(it.depth() == 1); assert(it.depth() == 1);
seen_d1 = true; seen_d1 = true;
} else if (parent == DirDepth2) { } else if (parent == DirDepth2) {
TEST_CHECK(it.depth() == 2); assert(it.depth() == 2);
seen_d2 = true; seen_d2 = true;
} else { } else {
TEST_CHECK(!"Unexpected depth while iterating over static env"); assert(!"Unexpected depth while iterating over static env");
} }
++it; ++it;
} }
TEST_REQUIRE(seen_d1 && seen_d2); assert(seen_d1 && seen_d2);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
TEST_SUITE_END() int main(int, char**) {
test_depth();
return 0;
}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/disable_recursion_pending.pass.cpp

Show All 14 Lines
// void disable_recursion_pending(); // void disable_recursion_pending();
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_disable_recursion_pending_tests)
// NOTE: The main semantics of disable_recursion_pending are tested // NOTE: The main semantics of disable_recursion_pending are tested
// in the 'recursion_pending()' tests. // in the 'recursion_pending()' tests.
TEST_CASE(basic_test) static void basic_test()
{ {
static_test_env static_env; static_test_env static_env;
recursive_directory_iterator it(static_env.Dir); recursive_directory_iterator it(static_env.Dir);
TEST_REQUIRE(it.recursion_pending() == true); assert(it.recursion_pending() == true);
it.disable_recursion_pending(); it.disable_recursion_pending();
TEST_CHECK(it.recursion_pending() == false); assert(it.recursion_pending() == false);
it.disable_recursion_pending(); it.disable_recursion_pending();
TEST_CHECK(it.recursion_pending() == false); assert(it.recursion_pending() == false);
} }
TEST_SUITE_END() int main(int, char**) {
basic_test();
return 0;
}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp

Show All 15 Lines
// recursive_directory_iterator& increment(error_code& ec) noexcept; // recursive_directory_iterator& increment(error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_increment_tests) static void test_increment_signatures()
TEST_CASE(test_increment_signatures)
{ {
recursive_directory_iterator d; ((void)d); recursive_directory_iterator d; ((void)d);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(++d), recursive_directory_iterator&); ASSERT_SAME_TYPE(decltype(++d), recursive_directory_iterator&);
ASSERT_NOT_NOEXCEPT(++d); ASSERT_NOT_NOEXCEPT(++d);
ASSERT_SAME_TYPE(decltype(d.increment(ec)), recursive_directory_iterator&); ASSERT_SAME_TYPE(decltype(d.increment(ec)), recursive_directory_iterator&);
ASSERT_NOT_NOEXCEPT(d.increment(ec)); ASSERT_NOT_NOEXCEPT(d.increment(ec));
} }
TEST_CASE(test_prefix_increment) static void test_prefix_increment()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const std::set<path> dir_contents(static_env.RecDirIterationList.begin(), const std::set<path> dir_contents(static_env.RecDirIterationList.begin(),
static_env.RecDirIterationList.end()); static_env.RecDirIterationList.end());
const recursive_directory_iterator endIt{}; const recursive_directory_iterator endIt{};
std::error_code ec; std::error_code ec;
recursive_directory_iterator it(testDir, ec); recursive_directory_iterator it(testDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
std::set<path> unseen_entries = dir_contents; std::set<path> unseen_entries = dir_contents;
while (!unseen_entries.empty()) { while (!unseen_entries.empty()) {
TEST_REQUIRE(it != endIt); assert(it != endIt);
const path entry = *it; const path entry = *it;
TEST_REQUIRE(unseen_entries.erase(entry) == 1); assert(unseen_entries.erase(entry) == 1);
recursive_directory_iterator& it_ref = ++it; recursive_directory_iterator& it_ref = ++it;
TEST_CHECK(&it_ref == &it); assert(&it_ref == &it);
} }
TEST_CHECK(it == endIt); assert(it == endIt);
} }
TEST_CASE(test_postfix_increment) static void test_postfix_increment()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const std::set<path> dir_contents(static_env.RecDirIterationList.begin(), const std::set<path> dir_contents(static_env.RecDirIterationList.begin(),
static_env.RecDirIterationList.end()); static_env.RecDirIterationList.end());
const recursive_directory_iterator endIt{}; const recursive_directory_iterator endIt{};
std::error_code ec; std::error_code ec;
recursive_directory_iterator it(testDir, ec); recursive_directory_iterator it(testDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
std::set<path> unseen_entries = dir_contents; std::set<path> unseen_entries = dir_contents;
while (!unseen_entries.empty()) { while (!unseen_entries.empty()) {
TEST_REQUIRE(it != endIt); assert(it != endIt);
const path entry = *it; const path entry = *it;
TEST_REQUIRE(unseen_entries.erase(entry) == 1); assert(unseen_entries.erase(entry) == 1);
const path entry2 = *it++; const path entry2 = *it++;
TEST_CHECK(entry2 == entry); assert(entry2 == entry);
} }
TEST_CHECK(it == endIt); assert(it == endIt);
} }
TEST_CASE(test_increment_method) static void test_increment_method()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const std::set<path> dir_contents(static_env.RecDirIterationList.begin(), const std::set<path> dir_contents(static_env.RecDirIterationList.begin(),
static_env.RecDirIterationList.end()); static_env.RecDirIterationList.end());
const recursive_directory_iterator endIt{}; const recursive_directory_iterator endIt{};
std::error_code ec; std::error_code ec;
recursive_directory_iterator it(testDir, ec); recursive_directory_iterator it(testDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
std::set<path> unseen_entries = dir_contents; std::set<path> unseen_entries = dir_contents;
while (!unseen_entries.empty()) { while (!unseen_entries.empty()) {
TEST_REQUIRE(it != endIt); assert(it != endIt);
const path entry = *it; const path entry = *it;
TEST_REQUIRE(unseen_entries.erase(entry) == 1); assert(unseen_entries.erase(entry) == 1);
recursive_directory_iterator& it_ref = it.increment(ec); recursive_directory_iterator& it_ref = it.increment(ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(&it_ref == &it); assert(&it_ref == &it);
} }
TEST_CHECK(it == endIt); assert(it == endIt);
} }
TEST_CASE(test_follow_symlinks) static void test_follow_symlinks()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
auto const& IterList = static_env.RecDirFollowSymlinksIterationList; auto const& IterList = static_env.RecDirFollowSymlinksIterationList;
const std::set<path> dir_contents(IterList.begin(), IterList.end()); const std::set<path> dir_contents(IterList.begin(), IterList.end());
const recursive_directory_iterator endIt{}; const recursive_directory_iterator endIt{};
std::error_code ec; std::error_code ec;
recursive_directory_iterator it(testDir, recursive_directory_iterator it(testDir,
directory_options::follow_directory_symlink, ec); directory_options::follow_directory_symlink, ec);
TEST_REQUIRE(!ec); assert(!ec);
std::set<path> unseen_entries = dir_contents; std::set<path> unseen_entries = dir_contents;
while (!unseen_entries.empty()) { while (!unseen_entries.empty()) {
TEST_REQUIRE(it != endIt); assert(it != endIt);
const path entry = *it; const path entry = *it;
TEST_REQUIRE(unseen_entries.erase(entry) == 1); assert(unseen_entries.erase(entry) == 1);
recursive_directory_iterator& it_ref = it.increment(ec); recursive_directory_iterator& it_ref = it.increment(ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(&it_ref == &it); assert(&it_ref == &it);
} }
TEST_CHECK(it == endIt); assert(it == endIt);
} }
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. // reading directories.
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_CASE(access_denied_on_recursion_test_case) static void access_denied_on_recursion_test_case()
{ {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path testFiles[] = { const path testFiles[] = {
env.create_dir("dir1"), env.create_dir("dir1"),
env.create_dir("dir1/dir2"), env.create_dir("dir1/dir2"),
env.create_file("dir1/dir2/file1"), env.create_file("dir1/dir2/file1"),
env.create_file("dir1/file2") env.create_file("dir1/file2")
}; };
const path startDir = testFiles[0]; const path startDir = testFiles[0];
const path permDeniedDir = testFiles[1]; const path permDeniedDir = testFiles[1];
const path otherFile = testFiles[3]; const path otherFile = testFiles[3];
auto SkipEPerm = directory_options::skip_permission_denied; auto SkipEPerm = directory_options::skip_permission_denied;
// Change the permissions so we can no longer iterate // Change the permissions so we can no longer iterate
permissions(permDeniedDir, perms::none); permissions(permDeniedDir, perms::none);
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
// Test that recursion resulting in a "EACCESS" error is not ignored // Test that recursion resulting in a "EACCESS" error is not ignored
// by default. // by default.
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
recursive_directory_iterator it(startDir, ec); recursive_directory_iterator it(startDir, ec);
TEST_REQUIRE(ec != GetTestEC()); assert(ec != GetTestEC());
TEST_REQUIRE(!ec); assert(!ec);
while (it != endIt && it->path() != permDeniedDir) while (it != endIt && it->path() != permDeniedDir)
++it; ++it;
TEST_REQUIRE(it != endIt); assert(it != endIt);
TEST_REQUIRE(*it == permDeniedDir); assert(*it == permDeniedDir);
it.increment(ec); it.increment(ec);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(it == endIt); assert(it == endIt);
} }
// Same as above but test operator++(). // Same as above but test operator++().
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
recursive_directory_iterator it(startDir, ec); recursive_directory_iterator it(startDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
while (it != endIt && it->path() != permDeniedDir) while (it != endIt && it->path() != permDeniedDir)
++it; ++it;
TEST_REQUIRE(it != endIt); assert(it != endIt);
TEST_REQUIRE(*it == permDeniedDir); assert(*it == permDeniedDir);
TEST_REQUIRE_THROW(filesystem_error, ++it); TEST_THROWS_TYPE(filesystem_error, ++it);
} }
// Test that recursion resulting in a "EACCESS" error is ignored when the // Test that recursion resulting in a "EACCESS" error is ignored when the
// correct options are given to the constructor. // correct options are given to the constructor.
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
recursive_directory_iterator it(startDir, SkipEPerm, ec); recursive_directory_iterator it(startDir, SkipEPerm, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_REQUIRE(it != endIt); assert(it != endIt);
bool seenOtherFile = false; bool seenOtherFile = false;
if (*it == otherFile) { if (*it == otherFile) {
++it; ++it;
seenOtherFile = true; seenOtherFile = true;
TEST_REQUIRE (it != endIt); assert (it != endIt);
} }
TEST_REQUIRE(*it == permDeniedDir); assert(*it == permDeniedDir);
ec = GetTestEC(); ec = GetTestEC();
it.increment(ec); it.increment(ec);
TEST_REQUIRE(!ec); assert(!ec);
if (seenOtherFile) { if (seenOtherFile) {
TEST_CHECK(it == endIt); assert(it == endIt);
} else { } else {
TEST_CHECK(it != endIt); assert(it != endIt);
TEST_CHECK(*it == otherFile); assert(*it == otherFile);
} }
} }
// Test that construction resulting in a "EACCESS" error is not ignored // Test that construction resulting in a "EACCESS" error is not ignored
// by default. // by default.
{ {
std::error_code ec; std::error_code ec;
recursive_directory_iterator it(permDeniedDir, ec); recursive_directory_iterator it(permDeniedDir, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_REQUIRE(it == endIt); assert(it == endIt);
} }
// Same as above but testing the throwing constructors // Same as above but testing the throwing constructors
{ {
TEST_REQUIRE_THROW(filesystem_error, TEST_THROWS_TYPE(filesystem_error,
recursive_directory_iterator(permDeniedDir)); recursive_directory_iterator(permDeniedDir));
} }
// Test that construction resulting in a "EACCESS" error constructs the // Test that construction resulting in a "EACCESS" error constructs the
// end iterator when the correct options are given. // end iterator when the correct options are given.
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
recursive_directory_iterator it(permDeniedDir, SkipEPerm, ec); recursive_directory_iterator it(permDeniedDir, SkipEPerm, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_REQUIRE(it == endIt); assert(it == endIt);
} }
} }
// See llvm.org/PR35078 // See llvm.org/PR35078
TEST_CASE(test_PR35078) static void test_PR35078()
{ {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path testFiles[] = { const path testFiles[] = {
env.create_dir("dir1"), env.create_dir("dir1"),
env.create_dir("dir1/dir2"), env.create_dir("dir1/dir2"),
env.create_dir("dir1/dir2/dir3"), env.create_dir("dir1/dir2/dir3"),
env.create_file("dir1/file1"), env.create_file("dir1/file1"),
Show All 25 Lines auto SetupState = [&](bool AllowEAccess, bool& SeenFile3) {
it.increment(ec); it.increment(ec);
} }
return it; return it;
}; };
{ {
bool SeenNestedFile = false; bool SeenNestedFile = false;
recursive_directory_iterator it = SetupState(false, SeenNestedFile); recursive_directory_iterator it = SetupState(false, SeenNestedFile);
TEST_REQUIRE(it != endIt); assert(it != endIt);
TEST_REQUIRE(*it == nestedDir); assert(*it == nestedDir);
ec = GetTestEC(); ec = GetTestEC();
it.increment(ec); it.increment(ec);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ErrorIs(ec, eacess)); assert(ErrorIs(ec, eacess));
TEST_CHECK(it == endIt); assert(it == endIt);
} }
{ {
bool SeenNestedFile = false; bool SeenNestedFile = false;
recursive_directory_iterator it = SetupState(true, SeenNestedFile); recursive_directory_iterator it = SetupState(true, SeenNestedFile);
TEST_REQUIRE(it != endIt); assert(it != endIt);
TEST_REQUIRE(*it == nestedDir); assert(*it == nestedDir);
ec = GetTestEC(); ec = GetTestEC();
it.increment(ec); it.increment(ec);
TEST_CHECK(!ec); assert(!ec);
if (SeenNestedFile) { if (SeenNestedFile) {
TEST_CHECK(it == endIt); assert(it == endIt);
} else { } else {
TEST_REQUIRE(it != endIt); assert(it != endIt);
TEST_CHECK(*it == nestedFile); assert(*it == nestedFile);
} }
} }
{ {
bool SeenNestedFile = false; bool SeenNestedFile = false;
recursive_directory_iterator it = SetupState(false, SeenNestedFile); recursive_directory_iterator it = SetupState(false, SeenNestedFile);
TEST_REQUIRE(it != endIt); assert(it != endIt);
TEST_REQUIRE(*it == nestedDir); assert(*it == nestedDir);
ExceptionChecker Checker(std::errc::permission_denied, ExceptionChecker Checker(std::errc::permission_denied,
"recursive_directory_iterator::operator++()", "recursive_directory_iterator::operator++()",
format_string("attempting recursion into \"%s\"", format_string("attempting recursion into \"%s\"",
nestedDir.string().c_str())); nestedDir.string().c_str()));
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ++it); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ++it);
} }
} }
// See llvm.org/PR35078 // See llvm.org/PR35078
TEST_CASE(test_PR35078_with_symlink) static void test_PR35078_with_symlink()
{ {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path testFiles[] = { const path testFiles[] = {
env.create_dir("dir1"), env.create_dir("dir1"),
env.create_file("dir1/file1"), env.create_file("dir1/file1"),
env.create_dir("sym_dir"), env.create_dir("sym_dir"),
env.create_dir("sym_dir/nested_sym_dir"), env.create_dir("sym_dir/nested_sym_dir"),
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines struct {
// Failing cases // Failing cases
{false, true, false} {false, true, false}
}; };
for (auto TC : TestCases) { for (auto TC : TestCases) {
bool SeenNestedFile = false; bool SeenNestedFile = false;
recursive_directory_iterator it = SetupState(TC.SkipPermDenied, recursive_directory_iterator it = SetupState(TC.SkipPermDenied,
TC.FollowSymlinks, TC.FollowSymlinks,
SeenNestedFile); SeenNestedFile);
TEST_REQUIRE(!ec); assert(!ec);
TEST_REQUIRE(it != endIt); assert(it != endIt);
TEST_REQUIRE(*it == symDir); assert(*it == symDir);
ec = GetTestEC(); ec = GetTestEC();
it.increment(ec); it.increment(ec);
if (TC.ExpectSuccess) { if (TC.ExpectSuccess) {
TEST_CHECK(!ec); assert(!ec);
if (SeenNestedFile) { if (SeenNestedFile) {
TEST_CHECK(it == endIt); assert(it == endIt);
} else { } else {
TEST_REQUIRE(it != endIt); assert(it != endIt);
TEST_CHECK(*it == nestedFile); assert(*it == nestedFile);
} }
} else { } else {
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ErrorIs(ec, eacess)); assert(ErrorIs(ec, eacess));
TEST_CHECK(it == endIt); assert(it == endIt);
} }
} }
} }
// See llvm.org/PR35078 // See llvm.org/PR35078
TEST_CASE(test_PR35078_with_symlink_file) static void test_PR35078_with_symlink_file()
{ {
using namespace fs; using namespace fs;
scoped_test_env env; scoped_test_env env;
const path testFiles[] = { const path testFiles[] = {
env.create_dir("dir1"), env.create_dir("dir1"),
env.create_dir("dir1/dir2"), env.create_dir("dir1/dir2"),
env.create_file("dir1/file2"), env.create_file("dir1/file2"),
env.create_dir("sym_dir"), env.create_dir("sym_dir"),
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines struct {
// Failing cases // Failing cases
{false, true, false} {false, true, false}
}; };
for (auto TC : TestCases){ for (auto TC : TestCases){
bool SeenNestedFile = false; bool SeenNestedFile = false;
recursive_directory_iterator it = SetupState(TC.SkipPermDenied, recursive_directory_iterator it = SetupState(TC.SkipPermDenied,
TC.FollowSymlinks, TC.FollowSymlinks,
SeenNestedFile); SeenNestedFile);
TEST_REQUIRE(!ec); assert(!ec);
TEST_REQUIRE(it != EndIt); assert(it != EndIt);
TEST_REQUIRE(*it == nestedDir); assert(*it == nestedDir);
ec = GetTestEC(); ec = GetTestEC();
it.increment(ec); it.increment(ec);
TEST_REQUIRE(it != EndIt); assert(it != EndIt);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(*it == symFile); assert(*it == symFile);
ec = GetTestEC(); ec = GetTestEC();
it.increment(ec); it.increment(ec);
if (TC.ExpectSuccess) { if (TC.ExpectSuccess) {
if (!SeenNestedFile) { if (!SeenNestedFile) {
TEST_CHECK(!ec); assert(!ec);
TEST_REQUIRE(it != EndIt); assert(it != EndIt);
TEST_CHECK(*it == nestedFile); assert(*it == nestedFile);
ec = GetTestEC(); ec = GetTestEC();
it.increment(ec); it.increment(ec);
} }
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(it == EndIt); assert(it == EndIt);
} else { } else {
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ErrorIs(ec, eacess)); assert(ErrorIs(ec, eacess));
TEST_CHECK(it == EndIt); assert(it == EndIt);
} }
} }
} }
#endif #endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
int main(int, char**) {
test_increment_signatures();
test_prefix_increment();
test_postfix_increment();
test_increment_method();
test_follow_symlinks();
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
access_denied_on_recursion_test_case();
test_PR35078();
test_PR35078_with_symlink();
test_PR35078_with_symlink_file();
#endif
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move.pass.cpp

Show All 14 Lines
// recursive_directory_iterator(recursive_directory_iterator&&) noexcept; // recursive_directory_iterator(recursive_directory_iterator&&) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_move_construct_tests) static void test_constructor_signature()
TEST_CASE(test_constructor_signature)
{ {
using D = recursive_directory_iterator; using D = recursive_directory_iterator;
static_assert(std::is_nothrow_move_constructible<D>::value, ""); static_assert(std::is_nothrow_move_constructible<D>::value, "");
} }
TEST_CASE(test_move_end_iterator) static void test_move_end_iterator()
{ {
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
recursive_directory_iterator endIt2{}; recursive_directory_iterator endIt2{};
recursive_directory_iterator it(std::move(endIt2)); recursive_directory_iterator it(std::move(endIt2));
TEST_CHECK(it == endIt); assert(it == endIt);
TEST_CHECK(endIt2 == endIt); assert(endIt2 == endIt);
} }
TEST_CASE(test_move_valid_iterator) static void test_move_valid_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const recursive_directory_iterator endIt{}; const recursive_directory_iterator endIt{};
// build 'it' up with "interesting" non-default state so we can test // build 'it' up with "interesting" non-default state so we can test
// that it gets copied. We want to get 'it' into a state such that: // that it gets copied. We want to get 'it' into a state such that:
// it.options() != directory_options::none // it.options() != directory_options::none
// it.depth() != 0 // it.depth() != 0
// it.recursion_pending() != true // it.recursion_pending() != true
const directory_options opts = directory_options::skip_permission_denied; const directory_options opts = directory_options::skip_permission_denied;
recursive_directory_iterator it(testDir, opts); recursive_directory_iterator it(testDir, opts);
TEST_REQUIRE(it != endIt); assert(it != endIt);
while (it.depth() == 0) { while (it.depth() == 0) {
++it; ++it;
TEST_REQUIRE(it != endIt); assert(it != endIt);
} }
it.disable_recursion_pending(); it.disable_recursion_pending();
TEST_CHECK(it.options() == opts); assert(it.options() == opts);
TEST_CHECK(it.depth() == 1); assert(it.depth() == 1);
TEST_CHECK(it.recursion_pending() == false); assert(it.recursion_pending() == false);
const path entry = *it; const path entry = *it;
// OPERATION UNDER TEST // // OPERATION UNDER TEST //
const recursive_directory_iterator it2(std::move(it)); const recursive_directory_iterator it2(std::move(it));
// ------------------- // // ------------------- //
TEST_REQUIRE(it2 != endIt); assert(it2 != endIt);
TEST_CHECK(*it2 == entry); assert(*it2 == entry);
TEST_CHECK(it2.depth() == 1); assert(it2.depth() == 1);
TEST_CHECK(it2.recursion_pending() == false); assert(it2.recursion_pending() == false);
} }
TEST_SUITE_END() int main(int, char**) {
test_constructor_signature();
test_move_end_iterator();
test_move_valid_iterator();
return 0;
}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move_assign.pass.cpp

Show All 14 Lines
// recursive_directory_iterator& operator=(recursive_directory_iterator const&); // recursive_directory_iterator& operator=(recursive_directory_iterator const&);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
// The filesystem specification explicitly allows for self-move on // The filesystem specification explicitly allows for self-move on
// the directory iterators. Turn off this warning so we can test it. // the directory iterators. Turn off this warning so we can test it.
TEST_CLANG_DIAGNOSTIC_IGNORED("-Wself-move") TEST_CLANG_DIAGNOSTIC_IGNORED("-Wself-move")
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_move_assign_tests)
recursive_directory_iterator createInterestingIterator(const static_test_env &static_env) recursive_directory_iterator createInterestingIterator(const static_test_env &static_env)
// Create an "interesting" iterator where all fields are // Create an "interesting" iterator where all fields are
// in a non-default state. The returned 'it' is in a // in a non-default state. The returned 'it' is in a
// state such that: // state such that:
// it.options() == directory_options::skip_permission_denied // it.options() == directory_options::skip_permission_denied
// it.depth() == 1 // it.depth() == 1
// it.recursion_pending() == true // it.recursion_pending() == true
{ {
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
recursive_directory_iterator it(testDir, recursive_directory_iterator it(testDir,
directory_options::skip_permission_denied); directory_options::skip_permission_denied);
TEST_ASSERT(it != endIt); assert(it != endIt);
while (it.depth() != 1) { while (it.depth() != 1) {
++it; ++it;
TEST_ASSERT(it != endIt); assert(it != endIt);
} }
TEST_ASSERT(it.depth() == 1); assert(it.depth() == 1);
it.disable_recursion_pending(); it.disable_recursion_pending();
return it; return it;
} }
recursive_directory_iterator createDifferentInterestingIterator(const static_test_env &static_env) recursive_directory_iterator createDifferentInterestingIterator(const static_test_env &static_env)
// Create an "interesting" iterator where all fields are // Create an "interesting" iterator where all fields are
// in a non-default state. The returned 'it' is in a // in a non-default state. The returned 'it' is in a
// state such that: // state such that:
// it.options() == directory_options::follow_directory_symlink // it.options() == directory_options::follow_directory_symlink
// it.depth() == 2 // it.depth() == 2
// it.recursion_pending() == false // it.recursion_pending() == false
{ {
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
recursive_directory_iterator it(testDir, recursive_directory_iterator it(testDir,
directory_options::follow_directory_symlink); directory_options::follow_directory_symlink);
TEST_ASSERT(it != endIt); assert(it != endIt);
while (it.depth() != 2) { while (it.depth() != 2) {
++it; ++it;
TEST_ASSERT(it != endIt); assert(it != endIt);
} }
TEST_ASSERT(it.depth() == 2); assert(it.depth() == 2);
return it; return it;
} }
TEST_CASE(test_assignment_signature) static void test_assignment_signature()
{ {
using D = recursive_directory_iterator; using D = recursive_directory_iterator;
static_assert(std::is_nothrow_move_assignable<D>::value, ""); static_assert(std::is_nothrow_move_assignable<D>::value, "");
} }
TEST_CASE(test_move_to_end_iterator) static void test_move_to_end_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
recursive_directory_iterator from = createInterestingIterator(static_env); recursive_directory_iterator from = createInterestingIterator(static_env);
const recursive_directory_iterator from_copy(from); const recursive_directory_iterator from_copy(from);
const path entry = *from; const path entry = *from;
recursive_directory_iterator to; recursive_directory_iterator to;
to = std::move(from); to = std::move(from);
TEST_REQUIRE(to != endIt); assert(to != endIt);
TEST_CHECK(*to == entry); assert(*to == entry);
TEST_CHECK(to.options() == from_copy.options()); assert(to.options() == from_copy.options());
TEST_CHECK(to.depth() == from_copy.depth()); assert(to.depth() == from_copy.depth());
TEST_CHECK(to.recursion_pending() == from_copy.recursion_pending()); assert(to.recursion_pending() == from_copy.recursion_pending());
TEST_CHECK(from == endIt || from == to); assert(from == endIt || from == to);
} }
TEST_CASE(test_move_from_end_iterator) static void test_move_from_end_iterator()
{ {
static_test_env static_env; static_test_env static_env;
recursive_directory_iterator from; recursive_directory_iterator from;
recursive_directory_iterator to = createInterestingIterator(static_env); recursive_directory_iterator to = createInterestingIterator(static_env);
to = std::move(from); to = std::move(from);
TEST_REQUIRE(to == from); assert(to == from);
TEST_CHECK(to == recursive_directory_iterator{}); assert(to == recursive_directory_iterator{});
} }
TEST_CASE(test_move_valid_iterator) static void test_move_valid_iterator()
{ {
static_test_env static_env; static_test_env static_env;
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
recursive_directory_iterator it = createInterestingIterator(static_env); recursive_directory_iterator it = createInterestingIterator(static_env);
const recursive_directory_iterator it_copy(it); const recursive_directory_iterator it_copy(it);
const path entry = *it; const path entry = *it;
recursive_directory_iterator it2 = createDifferentInterestingIterator(static_env); recursive_directory_iterator it2 = createDifferentInterestingIterator(static_env);
const recursive_directory_iterator it2_copy(it2); const recursive_directory_iterator it2_copy(it2);
TEST_REQUIRE(it2 != it); assert(it2 != it);
TEST_CHECK(it2.options() != it.options()); assert(it2.options() != it.options());
TEST_CHECK(it2.depth() != it.depth()); assert(it2.depth() != it.depth());
TEST_CHECK(it2.recursion_pending() != it.recursion_pending()); assert(it2.recursion_pending() != it.recursion_pending());
TEST_CHECK(*it2 != entry); assert(*it2 != entry);
it2 = std::move(it); it2 = std::move(it);
TEST_REQUIRE(it2 != it2_copy && it2 != endIt); assert(it2 != it2_copy && it2 != endIt);
TEST_CHECK(it2.options() == it_copy.options()); assert(it2.options() == it_copy.options());
TEST_CHECK(it2.depth() == it_copy.depth()); assert(it2.depth() == it_copy.depth());
TEST_CHECK(it2.recursion_pending() == it_copy.recursion_pending()); assert(it2.recursion_pending() == it_copy.recursion_pending());
TEST_CHECK(*it2 == entry); assert(*it2 == entry);
TEST_CHECK(it == endIt || it == it2); assert(it == endIt || it == it2);
} }
TEST_CASE(test_returns_reference_to_self) static void test_returns_reference_to_self()
{ {
recursive_directory_iterator it; recursive_directory_iterator it;
recursive_directory_iterator it2; recursive_directory_iterator it2;
recursive_directory_iterator& ref = (it2 = std::move(it)); recursive_directory_iterator& ref = (it2 = std::move(it));
TEST_CHECK(&ref == &it2); assert(&ref == &it2);
} }
TEST_CASE(test_self_move) static void test_self_move()
{ {
static_test_env static_env; static_test_env static_env;
// Create two non-equal iterators that have exactly the same state. // Create two non-equal iterators that have exactly the same state.
recursive_directory_iterator it = createInterestingIterator(static_env); recursive_directory_iterator it = createInterestingIterator(static_env);
recursive_directory_iterator it2 = createInterestingIterator(static_env); recursive_directory_iterator it2 = createInterestingIterator(static_env);
TEST_CHECK(it != it2); assert(it != it2);
TEST_CHECK(it2.options() == it.options()); assert(it2.options() == it.options());
TEST_CHECK(it2.depth() == it.depth()); assert(it2.depth() == it.depth());
TEST_CHECK(it2.recursion_pending() == it.recursion_pending()); assert(it2.recursion_pending() == it.recursion_pending());
TEST_CHECK(*it2 == *it); assert(*it2 == *it);
it = std::move(it); it = std::move(it);
TEST_CHECK(it2.options() == it.options()); assert(it2.options() == it.options());
TEST_CHECK(it2.depth() == it.depth()); assert(it2.depth() == it.depth());
TEST_CHECK(it2.recursion_pending() == it.recursion_pending()); assert(it2.recursion_pending() == it.recursion_pending());
TEST_CHECK(*it2 == *it); assert(*it2 == *it);
} }
int main(int, char**) {
test_assignment_signature();
test_move_to_end_iterator();
test_move_from_end_iterator();
test_move_valid_iterator();
test_returns_reference_to_self();
test_self_move();
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/pop.pass.cpp

Show All 14 Lines
// void pop(); // void pop();
// void pop(error_code& ec); // void pop(error_code& ec);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_pop_tests) static void signature_tests()
TEST_CASE(signature_tests)
{ {
recursive_directory_iterator it{}; ((void)it); recursive_directory_iterator it{}; ((void)it);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(it.pop()); ASSERT_NOT_NOEXCEPT(it.pop());
ASSERT_NOT_NOEXCEPT(it.pop(ec)); // may require allocation or other things ASSERT_NOT_NOEXCEPT(it.pop(ec)); // may require allocation or other things
} }
// NOTE: Since the order of iteration is unspecified we use a list of // NOTE: Since the order of iteration is unspecified we use a list of
// seen files at each depth to determine the new depth after a 'pop()' operation. // seen files at each depth to determine the new depth after a 'pop()' operation.
TEST_CASE(test_depth) static void test_depth()
{ {
static_test_env static_env; static_test_env static_env;
const recursive_directory_iterator endIt{}; const recursive_directory_iterator endIt{};
auto& DE0 = static_env.DirIterationList; auto& DE0 = static_env.DirIterationList;
std::set<path> notSeenDepth0(DE0.begin(), DE0.end()); std::set<path> notSeenDepth0(DE0.begin(), DE0.end());
auto& DE1 = static_env.DirIterationListDepth1; auto& DE1 = static_env.DirIterationListDepth1;
std::set<path> notSeenDepth1(DE1.begin(), DE1.end()); std::set<path> notSeenDepth1(DE1.begin(), DE1.end());
std::error_code ec; std::error_code ec;
recursive_directory_iterator it(static_env.Dir, ec); recursive_directory_iterator it(static_env.Dir, ec);
TEST_REQUIRE(it != endIt); assert(it != endIt);
TEST_CHECK(it.depth() == 0); assert(it.depth() == 0);
while (it.depth() != 2) { while (it.depth() != 2) {
if (it.depth() == 0) if (it.depth() == 0)
notSeenDepth0.erase(it->path()); notSeenDepth0.erase(it->path());
else else
notSeenDepth1.erase(it->path()); notSeenDepth1.erase(it->path());
++it; ++it;
TEST_REQUIRE(it != endIt); assert(it != endIt);
} }
while (true) { while (true) {
auto set_ec = std::make_error_code(std::errc::address_in_use); auto set_ec = std::make_error_code(std::errc::address_in_use);
it.pop(set_ec); it.pop(set_ec);
TEST_REQUIRE(!set_ec); assert(!set_ec);
if (it == endIt) { if (it == endIt) {
// We must have seen every entry at depth 0 and 1. // We must have seen every entry at depth 0 and 1.
TEST_REQUIRE(notSeenDepth0.empty() && notSeenDepth1.empty()); assert(notSeenDepth0.empty() && notSeenDepth1.empty());
break; break;
} }
else if (it.depth() == 1) { else if (it.depth() == 1) {
// If we popped to depth 1 then there must be unseen entries // If we popped to depth 1 then there must be unseen entries
// at this level. // at this level.
TEST_REQUIRE(!notSeenDepth1.empty()); assert(!notSeenDepth1.empty());
TEST_CHECK(notSeenDepth1.count(it->path())); assert(notSeenDepth1.count(it->path()));
notSeenDepth1.clear(); notSeenDepth1.clear();
} }
else if (it.depth() == 0) { else if (it.depth() == 0) {
// If we popped to depth 0 there must be unseen entries at this // If we popped to depth 0 there must be unseen entries at this
// level. There should also be no unseen entries at depth 1. // level. There should also be no unseen entries at depth 1.
TEST_REQUIRE(!notSeenDepth0.empty()); assert(!notSeenDepth0.empty());
TEST_REQUIRE(notSeenDepth1.empty()); assert(notSeenDepth1.empty());
TEST_CHECK(notSeenDepth0.count(it->path())); assert(notSeenDepth0.count(it->path()));
notSeenDepth0.clear(); notSeenDepth0.clear();
} }
} }
} }
TEST_SUITE_END() int main(int, char**) {
signature_tests();
test_depth();
return 0;
}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.pass.cpp

Show All 14 Lines
// bool recursion_pending() const; // bool recursion_pending() const;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_recursion_pending_tests) static void initial_value_test()
TEST_CASE(initial_value_test)
{ {
static_test_env static_env; static_test_env static_env;
recursive_directory_iterator it(static_env.Dir); recursive_directory_iterator it(static_env.Dir);
TEST_REQUIRE(it.recursion_pending() == true); assert(it.recursion_pending() == true);
} }
TEST_CASE(value_after_copy_construction_and_assignment_test) static void value_after_copy_construction_and_assignment_test()
{ {
static_test_env static_env; static_test_env static_env;
recursive_directory_iterator rec_pending_it(static_env.Dir); recursive_directory_iterator rec_pending_it(static_env.Dir);
recursive_directory_iterator no_rec_pending_it(static_env.Dir); recursive_directory_iterator no_rec_pending_it(static_env.Dir);
no_rec_pending_it.disable_recursion_pending(); no_rec_pending_it.disable_recursion_pending();
{ // copy construction { // copy construction
recursive_directory_iterator it(rec_pending_it); recursive_directory_iterator it(rec_pending_it);
TEST_CHECK(it.recursion_pending() == true); assert(it.recursion_pending() == true);
it.disable_recursion_pending(); it.disable_recursion_pending();
TEST_REQUIRE(rec_pending_it.recursion_pending() == true); assert(rec_pending_it.recursion_pending() == true);
recursive_directory_iterator it2(no_rec_pending_it); recursive_directory_iterator it2(no_rec_pending_it);
TEST_CHECK(it2.recursion_pending() == false); assert(it2.recursion_pending() == false);
} }
{ // copy assignment { // copy assignment
recursive_directory_iterator it(static_env.Dir); recursive_directory_iterator it(static_env.Dir);
it.disable_recursion_pending(); it.disable_recursion_pending();
it = rec_pending_it; it = rec_pending_it;
TEST_CHECK(it.recursion_pending() == true); assert(it.recursion_pending() == true);
it.disable_recursion_pending(); it.disable_recursion_pending();
TEST_REQUIRE(rec_pending_it.recursion_pending() == true); assert(rec_pending_it.recursion_pending() == true);
recursive_directory_iterator it2(static_env.Dir); recursive_directory_iterator it2(static_env.Dir);
it2 = no_rec_pending_it; it2 = no_rec_pending_it;
TEST_CHECK(it2.recursion_pending() == false); assert(it2.recursion_pending() == false);
} }
TEST_CHECK(rec_pending_it.recursion_pending() == true); assert(rec_pending_it.recursion_pending() == true);
TEST_CHECK(no_rec_pending_it.recursion_pending() == false); assert(no_rec_pending_it.recursion_pending() == false);
} }
TEST_CASE(value_after_move_construction_and_assignment_test) static void value_after_move_construction_and_assignment_test()
{ {
static_test_env static_env; static_test_env static_env;
recursive_directory_iterator rec_pending_it(static_env.Dir); recursive_directory_iterator rec_pending_it(static_env.Dir);
recursive_directory_iterator no_rec_pending_it(static_env.Dir); recursive_directory_iterator no_rec_pending_it(static_env.Dir);
no_rec_pending_it.disable_recursion_pending(); no_rec_pending_it.disable_recursion_pending();
{ // move construction { // move construction
recursive_directory_iterator it_cp(rec_pending_it); recursive_directory_iterator it_cp(rec_pending_it);
recursive_directory_iterator it(std::move(it_cp)); recursive_directory_iterator it(std::move(it_cp));
TEST_CHECK(it.recursion_pending() == true); assert(it.recursion_pending() == true);
recursive_directory_iterator it_cp2(no_rec_pending_it); recursive_directory_iterator it_cp2(no_rec_pending_it);
recursive_directory_iterator it2(std::move(it_cp2)); recursive_directory_iterator it2(std::move(it_cp2));
TEST_CHECK(it2.recursion_pending() == false); assert(it2.recursion_pending() == false);
} }
{ // copy assignment { // copy assignment
recursive_directory_iterator it(static_env.Dir); recursive_directory_iterator it(static_env.Dir);
it.disable_recursion_pending(); it.disable_recursion_pending();
recursive_directory_iterator it_cp(rec_pending_it); recursive_directory_iterator it_cp(rec_pending_it);
it = std::move(it_cp); it = std::move(it_cp);
TEST_CHECK(it.recursion_pending() == true); assert(it.recursion_pending() == true);
recursive_directory_iterator it2(static_env.Dir); recursive_directory_iterator it2(static_env.Dir);
recursive_directory_iterator it_cp2(no_rec_pending_it); recursive_directory_iterator it_cp2(no_rec_pending_it);
it2 = std::move(it_cp2); it2 = std::move(it_cp2);
TEST_CHECK(it2.recursion_pending() == false); assert(it2.recursion_pending() == false);
} }
TEST_CHECK(rec_pending_it.recursion_pending() == true); assert(rec_pending_it.recursion_pending() == true);
TEST_CHECK(no_rec_pending_it.recursion_pending() == false); assert(no_rec_pending_it.recursion_pending() == false);
} }
TEST_CASE(increment_resets_value) static void increment_resets_value()
{ {
static_test_env static_env; static_test_env static_env;
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
{ {
recursive_directory_iterator it(static_env.Dir); recursive_directory_iterator it(static_env.Dir);
it.disable_recursion_pending(); it.disable_recursion_pending();
TEST_CHECK(it.recursion_pending() == false); assert(it.recursion_pending() == false);
++it; ++it;
TEST_CHECK(it.recursion_pending() == true); assert(it.recursion_pending() == true);
TEST_CHECK(it.depth() == 0); assert(it.depth() == 0);
} }
{ {
recursive_directory_iterator it(static_env.Dir); recursive_directory_iterator it(static_env.Dir);
it.disable_recursion_pending(); it.disable_recursion_pending();
TEST_CHECK(it.recursion_pending() == false); assert(it.recursion_pending() == false);
it++; it++;
TEST_CHECK(it.recursion_pending() == true); assert(it.recursion_pending() == true);
TEST_CHECK(it.depth() == 0); assert(it.depth() == 0);
} }
{ {
recursive_directory_iterator it(static_env.Dir); recursive_directory_iterator it(static_env.Dir);
it.disable_recursion_pending(); it.disable_recursion_pending();
TEST_CHECK(it.recursion_pending() == false); assert(it.recursion_pending() == false);
std::error_code ec; std::error_code ec;
it.increment(ec); it.increment(ec);
TEST_CHECK(it.recursion_pending() == true); assert(it.recursion_pending() == true);
TEST_CHECK(it.depth() == 0); assert(it.depth() == 0);
} }
} }
TEST_CASE(pop_does_not_reset_value) static void pop_does_not_reset_value()
{ {
static_test_env static_env; static_test_env static_env;
const recursive_directory_iterator endIt; const recursive_directory_iterator endIt;
auto& DE0 = static_env.DirIterationList; auto& DE0 = static_env.DirIterationList;
std::set<path> notSeenDepth0(DE0.begin(), DE0.end()); std::set<path> notSeenDepth0(DE0.begin(), DE0.end());
recursive_directory_iterator it(static_env.Dir); recursive_directory_iterator it(static_env.Dir);
TEST_REQUIRE(it != endIt); assert(it != endIt);
while (it.depth() == 0) { while (it.depth() == 0) {
notSeenDepth0.erase(it->path()); notSeenDepth0.erase(it->path());
++it; ++it;
TEST_REQUIRE(it != endIt); assert(it != endIt);
} }
TEST_REQUIRE(it.depth() == 1); assert(it.depth() == 1);
it.disable_recursion_pending(); it.disable_recursion_pending();
it.pop(); it.pop();
// Since the order of iteration is unspecified the pop() could result // Since the order of iteration is unspecified the pop() could result
// in the end iterator. When this is the case it is undefined behavior // in the end iterator. When this is the case it is undefined behavior
// to call recursion_pending(). // to call recursion_pending().
if (it == endIt) { if (it == endIt) {
TEST_CHECK(notSeenDepth0.empty()); assert(notSeenDepth0.empty());
#if defined(_LIBCPP_VERSION) #if defined(_LIBCPP_VERSION)
TEST_CHECK(it.recursion_pending() == false); assert(it.recursion_pending() == false);
#endif #endif
} else { } else {
TEST_CHECK(! notSeenDepth0.empty()); assert(! notSeenDepth0.empty());
TEST_CHECK(it.recursion_pending() == false); assert(it.recursion_pending() == false);
} }
} }
TEST_SUITE_END() int main(int, char**) {
initial_value_test();
value_after_copy_construction_and_assignment_test();
value_after_move_construction_and_assignment_test();
increment_resets_value();
pop_does_not_reset_value();
return 0;
}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.nonmembers/begin_end.pass.cpp

Show All 15 Lines
// recursive_directory_iterator end(recursive_directory_iterator iter) noexcept; // recursive_directory_iterator end(recursive_directory_iterator iter) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <set> #include <set>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(recursive_directory_iterator_begin_end_tests) static void test_function_signatures()
TEST_CASE(test_function_signatures)
{ {
recursive_directory_iterator d; recursive_directory_iterator d;
ASSERT_SAME_TYPE(decltype(begin(d)), recursive_directory_iterator); ASSERT_SAME_TYPE(decltype(begin(d)), recursive_directory_iterator);
ASSERT_SAME_TYPE(decltype(begin(std::move(d))), recursive_directory_iterator); ASSERT_SAME_TYPE(decltype(begin(std::move(d))), recursive_directory_iterator);
ASSERT_NOEXCEPT(begin(d)); ASSERT_NOEXCEPT(begin(d));
ASSERT_NOEXCEPT(begin(std::move(d))); ASSERT_NOEXCEPT(begin(std::move(d)));
ASSERT_SAME_TYPE(decltype(end(d)), recursive_directory_iterator); ASSERT_SAME_TYPE(decltype(end(d)), recursive_directory_iterator);
ASSERT_SAME_TYPE(decltype(end(std::move(d))), recursive_directory_iterator); ASSERT_SAME_TYPE(decltype(end(std::move(d))), recursive_directory_iterator);
ASSERT_NOEXCEPT(end(d)); ASSERT_NOEXCEPT(end(d));
ASSERT_NOEXCEPT(end(std::move(d))); ASSERT_NOEXCEPT(end(std::move(d)));
} }
TEST_CASE(test_ranged_for_loop) static void test_ranged_for_loop()
{ {
static_test_env static_env; static_test_env static_env;
const path testDir = static_env.Dir; const path testDir = static_env.Dir;
std::set<path> dir_contents(static_env.RecDirIterationList.begin(), std::set<path> dir_contents(static_env.RecDirIterationList.begin(),
static_env.RecDirIterationList.end()); static_env.RecDirIterationList.end());
std::error_code ec; std::error_code ec;
recursive_directory_iterator it(testDir, ec); recursive_directory_iterator it(testDir, ec);
TEST_REQUIRE(!ec); assert(!ec);
for (auto& elem : it) { for (auto& elem : it) {
TEST_CHECK(dir_contents.erase(elem) == 1); assert(dir_contents.erase(elem) == 1);
} }
TEST_CHECK(dir_contents.empty()); assert(dir_contents.empty());
} }
TEST_SUITE_END() int main(int, char**) {
test_function_signatures();
test_ranged_for_loop();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.pass.cpp

Show All 12 Lines
// uintmax_t hard_link_count(const path& p); // uintmax_t hard_link_count(const path& p);
// uintmax_t hard_link_count(const path& p, std::error_code& ec) noexcept; // uintmax_t hard_link_count(const path& p, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(hard_link_count_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(hard_link_count(p)), uintmax_t); ASSERT_SAME_TYPE(decltype(hard_link_count(p)), uintmax_t);
ASSERT_SAME_TYPE(decltype(hard_link_count(p, ec)), uintmax_t); ASSERT_SAME_TYPE(decltype(hard_link_count(p, ec)), uintmax_t);
ASSERT_NOT_NOEXCEPT(hard_link_count(p)); ASSERT_NOT_NOEXCEPT(hard_link_count(p));
ASSERT_NOEXCEPT(hard_link_count(p, ec)); ASSERT_NOEXCEPT(hard_link_count(p, ec));
} }
TEST_CASE(hard_link_count_for_file) static void hard_link_count_for_file()
{ {
static_test_env static_env; static_test_env static_env;
TEST_CHECK(hard_link_count(static_env.File) == 1); assert(hard_link_count(static_env.File) == 1);
std::error_code ec; std::error_code ec;
TEST_CHECK(hard_link_count(static_env.File, ec) == 1); assert(hard_link_count(static_env.File, ec) == 1);
} }
TEST_CASE(hard_link_count_for_directory) static void hard_link_count_for_directory()
{ {
static_test_env static_env; static_test_env static_env;
uintmax_t DirExpect = 3; // hard link from . .. and Dir2 uintmax_t DirExpect = 3; // hard link from . .. and Dir2
uintmax_t Dir3Expect = 2; // hard link from . .. uintmax_t Dir3Expect = 2; // hard link from . ..
uintmax_t DirExpectAlt = DirExpect; uintmax_t DirExpectAlt = DirExpect;
uintmax_t Dir3ExpectAlt = Dir3Expect; uintmax_t Dir3ExpectAlt = Dir3Expect;
#if defined(__APPLE__) #if defined(__APPLE__)
// Filesystems formatted with case sensitive hfs+ behave unixish as // Filesystems formatted with case sensitive hfs+ behave unixish as
// expected. Normal hfs+ filesystems report the number of directory // expected. Normal hfs+ filesystems report the number of directory
// entries instead. // entries instead.
DirExpectAlt = 5; // . .. Dir2 file1 file2 DirExpectAlt = 5; // . .. Dir2 file1 file2
Dir3Expect = 3; // . .. file5 Dir3Expect = 3; // . .. file5
#endif #endif
TEST_CHECK(hard_link_count(static_env.Dir) == DirExpect || assert(hard_link_count(static_env.Dir) == DirExpect ||
hard_link_count(static_env.Dir) == DirExpectAlt || hard_link_count(static_env.Dir) == DirExpectAlt ||
hard_link_count(static_env.Dir) == 1); hard_link_count(static_env.Dir) == 1);
TEST_CHECK(hard_link_count(static_env.Dir3) == Dir3Expect || assert(hard_link_count(static_env.Dir3) == Dir3Expect ||
hard_link_count(static_env.Dir3) == Dir3ExpectAlt || hard_link_count(static_env.Dir3) == Dir3ExpectAlt ||
hard_link_count(static_env.Dir3) == 1); hard_link_count(static_env.Dir3) == 1);
std::error_code ec; std::error_code ec;
TEST_CHECK(hard_link_count(static_env.Dir, ec) == DirExpect || assert(hard_link_count(static_env.Dir, ec) == DirExpect ||
hard_link_count(static_env.Dir, ec) == DirExpectAlt || hard_link_count(static_env.Dir, ec) == DirExpectAlt ||
hard_link_count(static_env.Dir) == 1); hard_link_count(static_env.Dir) == 1);
TEST_CHECK(hard_link_count(static_env.Dir3, ec) == Dir3Expect || assert(hard_link_count(static_env.Dir3, ec) == Dir3Expect ||
hard_link_count(static_env.Dir3, ec) == Dir3ExpectAlt || hard_link_count(static_env.Dir3, ec) == Dir3ExpectAlt ||
hard_link_count(static_env.Dir3) == 1); hard_link_count(static_env.Dir3) == 1);
} }
TEST_CASE(hard_link_count_increments_test)
static void hard_link_count_increments_test()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
TEST_CHECK(hard_link_count(file) == 1); assert(hard_link_count(file) == 1);
env.create_hardlink(file, "file_hl"); env.create_hardlink(file, "file_hl");
TEST_CHECK(hard_link_count(file) == 2); assert(hard_link_count(file) == 2);
} }
TEST_CASE(hard_link_count_error_cases) static void hard_link_count_error_cases()
{ {
static_test_env static_env; static_test_env static_env;
const path testCases[] = { const path testCases[] = {
static_env.BadSymlink, static_env.BadSymlink,
static_env.DNE static_env.DNE
}; };
const uintmax_t expect = static_cast<uintmax_t>(-1); const uintmax_t expect = static_cast<uintmax_t>(-1);
for (auto& TC : testCases) { for (auto& TC : testCases) {
std::error_code ec; std::error_code ec;
TEST_CHECK(hard_link_count(TC, ec) == expect); assert(hard_link_count(TC, ec) == expect);
TEST_CHECK(ec); assert(ec);
} }
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
hard_link_count_for_file();
hard_link_count_for_directory();
hard_link_count_increments_test();
hard_link_count_error_cases();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.absolute/absolute.pass.cpp

Show All 11 Lines
// path absolute(const path& p, const path& base=current_path()); // path absolute(const path& p, const path& base=current_path());
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_absolute_path_test_suite) static void absolute_signature_test()
TEST_CASE(absolute_signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; std::error_code ec;
ASSERT_NOT_NOEXCEPT(absolute(p)); ASSERT_NOT_NOEXCEPT(absolute(p));
ASSERT_NOT_NOEXCEPT(absolute(p, ec)); ASSERT_NOT_NOEXCEPT(absolute(p, ec));
} }
TEST_CASE(basic_test) static void basic_test()
{ {
const fs::path cwd = fs::current_path(); const fs::path cwd = fs::current_path();
const struct { const struct {
std::string input; std::string input;
fs::path expect; fs::path expect;
} TestCases [] = { } TestCases [] = {
{"", cwd / ""}, {"", cwd / ""},
{"foo", cwd / "foo"}, {"foo", cwd / "foo"},
{"foo/", cwd / "foo/"}, {"foo/", cwd / "foo/"},
{"/already_absolute", cwd.root_name() / "/already_absolute"} {"/already_absolute", cwd.root_name() / "/already_absolute"}
}; };
for (auto& TC : TestCases) { for (auto& TC : TestCases) {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
const path ret = absolute(TC.input, ec); const path ret = absolute(TC.input, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(ret.is_absolute()); assert(ret.is_absolute());
TEST_CHECK(PathEqIgnoreSep(ret, TC.expect)); assert(PathEqIgnoreSep(ret, TC.expect));
LIBCPP_ONLY(TEST_CHECK(PathEq(ret, TC.expect))); LIBCPP_ONLY(assert(PathEq(ret, TC.expect)));
} }
} }
TEST_SUITE_END() int main(int, char**) {
absolute_signature_test();
basic_test();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.canonical/canonical.pass.cpp

Show All 12 Lines
// path canonical(const path& p); // path canonical(const path& p);
// path canonical(const path& p, error_code& ec); // path canonical(const path& p, error_code& ec);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_canonical_path_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(canonical(p)); ASSERT_NOT_NOEXCEPT(canonical(p));
ASSERT_NOT_NOEXCEPT(canonical(p, ec)); ASSERT_NOT_NOEXCEPT(canonical(p, ec));
} }
// There are 4 cases is the proposal for absolute path. // There are 4 cases is the proposal for absolute path.
// Each scope tests one of the cases. // Each scope tests one of the cases.
TEST_CASE(test_canonical) static void test_canonical()
{ {
static_test_env static_env; static_test_env static_env;
CWDGuard guard; CWDGuard guard;
// has_root_name() && has_root_directory() // has_root_name() && has_root_directory()
const path Root = static_env.Root; const path Root = static_env.Root;
const path RootName = Root.filename(); const path RootName = Root.filename();
const path DirName = static_env.Dir.filename(); const path DirName = static_env.Dir.filename();
const path SymlinkName = static_env.SymlinkToFile.filename(); const path SymlinkName = static_env.SymlinkToFile.filename();
Show All 16 Lines const TestCase testCases[] = {
Root }, Root },
{ static_env.SymlinkToFile, static_env.File, Root }, { static_env.SymlinkToFile, static_env.File, Root },
{ SymlinkName, static_env.File, Root} { SymlinkName, static_env.File, Root}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::current_path(TC.base); fs::current_path(TC.base);
const path ret = canonical(TC.p, ec); const path ret = canonical(TC.p, ec);
TEST_REQUIRE(!ec); assert(!ec);
const path ret2 = canonical(TC.p); const path ret2 = canonical(TC.p);
TEST_CHECK(PathEq(ret, TC.expect)); assert(PathEq(ret, TC.expect));
TEST_CHECK(PathEq(ret, ret2)); assert(PathEq(ret, ret2));
TEST_CHECK(ret.is_absolute()); assert(ret.is_absolute());
} }
} }
TEST_CASE(test_dne_path) static void test_dne_path()
{ {
static_test_env static_env; static_test_env static_env;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
{ {
const path ret = canonical(static_env.DNE, ec); const path ret = canonical(static_env.DNE, ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(ret == path{}); assert(ret == path{});
} }
{ {
TEST_CHECK_THROW(filesystem_error, canonical(static_env.DNE)); TEST_THROWS_TYPE(filesystem_error, canonical(static_env.DNE));
} }
} }
TEST_CASE(test_exception_contains_paths) static void test_exception_contains_paths()
{ {
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
static_test_env static_env; static_test_env static_env;
CWDGuard guard; CWDGuard guard;
const path p = "blabla/dne"; const path p = "blabla/dne";
try { try {
(void)canonical(p); (void)canonical(p);
TEST_REQUIRE(false); assert(false);
} catch (filesystem_error const& err) { } catch (filesystem_error const& err) {
TEST_CHECK(err.path1() == p); assert(err.path1() == p);
// libc++ provides the current path as the second path in the exception // libc++ provides the current path as the second path in the exception
LIBCPP_ONLY(TEST_CHECK(err.path2() == current_path())); LIBCPP_ONLY(assert(err.path2() == current_path()));
} }
fs::current_path(static_env.Dir); fs::current_path(static_env.Dir);
try { try {
(void)canonical(p); (void)canonical(p);
TEST_REQUIRE(false); assert(false);
} catch (filesystem_error const& err) { } catch (filesystem_error const& err) {
TEST_CHECK(err.path1() == p); assert(err.path1() == p);
LIBCPP_ONLY(TEST_CHECK(err.path2() == static_env.Dir)); LIBCPP_ONLY(assert(err.path2() == static_env.Dir));
} }
#endif #endif
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
test_canonical();
test_dne_path();
test_exception_contains_paths();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy/copy.pass.cpp

Show All 16 Lines
// error_code& ec); // error_code& ec);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cstddef> #include <cstddef>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
using CO = fs::copy_options; using CO = fs::copy_options;
TEST_SUITE(filesystem_copy_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
const copy_options opts{}; ((void)opts); const copy_options opts{}; ((void)opts);
ASSERT_NOT_NOEXCEPT(fs::copy(p, p)); ASSERT_NOT_NOEXCEPT(fs::copy(p, p));
ASSERT_NOT_NOEXCEPT(fs::copy(p, p, ec)); ASSERT_NOT_NOEXCEPT(fs::copy(p, p, ec));
ASSERT_NOT_NOEXCEPT(copy(p, p, opts)); ASSERT_NOT_NOEXCEPT(copy(p, p, opts));
ASSERT_NOT_NOEXCEPT(copy(p, p, opts, ec)); ASSERT_NOT_NOEXCEPT(copy(p, p, opts, ec));
} }
// There are 4 cases is the proposal for absolute path. // There are 4 cases is the proposal for absolute path.
// Each scope tests one of the cases. // Each scope tests one of the cases.
TEST_CASE(test_error_reporting) static void test_error_reporting()
{ {
auto checkThrow = [](path const& f, path const& t, const std::error_code& ec) auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
{ {
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try { try {
fs::copy(f, t); fs::copy(f, t);
return false; return false;
} catch (filesystem_error const& err) { } catch (filesystem_error const& err) {
return err.path1() == f return err.path1() == f
&& err.path2() == t && err.path2() == t
&& err.code() == ec; && err.code() == ec;
} }
#else #else
((void)f); ((void)t); ((void)ec); ((void)f); ((void)t); ((void)ec);
return true; return true;
#endif #endif
}; };
static_test_env static_env; static_test_env static_env;
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file1", 42); const path file = env.create_file("file1", 42);
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
#ifndef _WIN32 #ifndef _WIN32
const path fifo = env.create_fifo("fifo"); const path fifo = env.create_fifo("fifo");
TEST_REQUIRE(is_other(fifo)); assert(is_other(fifo));
#endif #endif
const auto test_ec = GetTestEC(); const auto test_ec = GetTestEC();
// !exists(f) // !exists(f)
{ {
std::error_code ec = test_ec; std::error_code ec = test_ec;
const path f = static_env.DNE; const path f = static_env.DNE;
const path t = env.test_root; const path t = env.test_root;
fs::copy(f, t, ec); fs::copy(f, t, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_REQUIRE(ec != test_ec); assert(ec != test_ec);
TEST_CHECK(checkThrow(f, t, ec)); assert(checkThrow(f, t, ec));
} }
{ // equivalent(f, t) == true { // equivalent(f, t) == true
std::error_code ec = test_ec; std::error_code ec = test_ec;
fs::copy(file, file, ec); fs::copy(file, file, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_REQUIRE(ec != test_ec); assert(ec != test_ec);
TEST_CHECK(checkThrow(file, file, ec)); assert(checkThrow(file, file, ec));
} }
{ // is_directory(from) && is_file(to) { // is_directory(from) && is_file(to)
std::error_code ec = test_ec; std::error_code ec = test_ec;
fs::copy(dir, file, ec); fs::copy(dir, file, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_REQUIRE(ec != test_ec); assert(ec != test_ec);
TEST_CHECK(checkThrow(dir, file, ec)); assert(checkThrow(dir, file, ec));
} }
#ifndef _WIN32 #ifndef _WIN32
{ // is_other(from) { // is_other(from)
std::error_code ec = test_ec; std::error_code ec = test_ec;
fs::copy(fifo, dir, ec); fs::copy(fifo, dir, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_REQUIRE(ec != test_ec); assert(ec != test_ec);
TEST_CHECK(checkThrow(fifo, dir, ec)); assert(checkThrow(fifo, dir, ec));
} }
{ // is_other(to) { // is_other(to)
std::error_code ec = test_ec; std::error_code ec = test_ec;
fs::copy(file, fifo, ec); fs::copy(file, fifo, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_REQUIRE(ec != test_ec); assert(ec != test_ec);
TEST_CHECK(checkThrow(file, fifo, ec)); assert(checkThrow(file, fifo, ec));
} }
#endif #endif
} }
TEST_CASE(from_is_symlink) static void from_is_symlink()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path symlink = env.create_symlink(file, "sym"); const path symlink = env.create_symlink(file, "sym");
const path dne = env.make_env_path("dne"); const path dne = env.make_env_path("dne");
{ // skip symlinks { // skip symlinks
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(symlink, dne, copy_options::skip_symlinks, ec); fs::copy(symlink, dne, copy_options::skip_symlinks, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(!exists(dne)); assert(!exists(dne));
} }
{ {
const path dest = env.make_env_path("dest"); const path dest = env.make_env_path("dest");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(symlink, dest, copy_options::copy_symlinks, ec); fs::copy(symlink, dest, copy_options::copy_symlinks, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(exists(dest)); assert(exists(dest));
TEST_CHECK(is_symlink(dest)); assert(is_symlink(dest));
} }
{ // copy symlink but target exists { // copy symlink but target exists
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(symlink, file, copy_options::copy_symlinks, ec); fs::copy(symlink, file, copy_options::copy_symlinks, ec);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
} }
{ // create symlinks but target exists { // create symlinks but target exists
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(symlink, file, copy_options::create_symlinks, ec); fs::copy(symlink, file, copy_options::create_symlinks, ec);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
} }
} }
TEST_CASE(from_is_regular_file) static void from_is_regular_file()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
{ // skip copy because of directory { // skip copy because of directory
const path dest = env.make_env_path("dest1"); const path dest = env.make_env_path("dest1");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(file, dest, CO::directories_only, ec); fs::copy(file, dest, CO::directories_only, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(!exists(dest)); assert(!exists(dest));
} }
{ // create symlink to file { // create symlink to file
const path dest = env.make_env_path("sym"); const path dest = env.make_env_path("sym");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(file, dest, CO::create_symlinks, ec); fs::copy(file, dest, CO::create_symlinks, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(is_symlink(dest)); assert(is_symlink(dest));
TEST_CHECK(equivalent(file, canonical(dest))); assert(equivalent(file, canonical(dest)));
} }
{ // create hard link to file { // create hard link to file
const path dest = env.make_env_path("hardlink"); const path dest = env.make_env_path("hardlink");
TEST_CHECK(hard_link_count(file) == 1); assert(hard_link_count(file) == 1);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(file, dest, CO::create_hard_links, ec); fs::copy(file, dest, CO::create_hard_links, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(exists(dest)); assert(exists(dest));
TEST_CHECK(hard_link_count(file) == 2); assert(hard_link_count(file) == 2);
} }
{ // is_directory(t) { // is_directory(t)
const path dest_dir = env.create_dir("dest_dir"); const path dest_dir = env.create_dir("dest_dir");
const path expect_dest = dest_dir / file.filename(); const path expect_dest = dest_dir / file.filename();
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(file, dest_dir, ec); fs::copy(file, dest_dir, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(is_regular_file(expect_dest)); assert(is_regular_file(expect_dest));
} }
{ // otherwise copy_file(from, to, ...) { // otherwise copy_file(from, to, ...)
const path dest = env.make_env_path("file_copy"); const path dest = env.make_env_path("file_copy");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(file, dest, ec); fs::copy(file, dest, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(is_regular_file(dest)); assert(is_regular_file(dest));
} }
} }
TEST_CASE(from_is_directory) static void from_is_directory()
{ {
struct FileInfo { struct FileInfo {
path filename; path filename;
std::size_t size; std::size_t size;
}; };
const FileInfo files[] = { const FileInfo files[] = {
{"file1", 0}, {"file1", 0},
{"file2", 42}, {"file2", 42},
{"file3", 300} {"file3", 300}
}; };
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path nested_dir_name = "dir2"; const path nested_dir_name = "dir2";
const path nested_dir = env.create_dir("dir/dir2"); const path nested_dir = env.create_dir("dir/dir2");
for (auto& FI : files) { for (auto& FI : files) {
env.create_file(dir / FI.filename, FI.size); env.create_file(dir / FI.filename, FI.size);
env.create_file(nested_dir / FI.filename, FI.size); env.create_file(nested_dir / FI.filename, FI.size);
} }
{ // test for non-existent directory { // test for non-existent directory
const path dest = env.make_env_path("dest_dir1"); const path dest = env.make_env_path("dest_dir1");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(dir, dest, ec); fs::copy(dir, dest, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(is_directory(dest)); assert(is_directory(dest));
for (auto& FI : files) { for (auto& FI : files) {
path created = dest / FI.filename; path created = dest / FI.filename;
TEST_CHECK(is_regular_file(created)); assert(is_regular_file(created));
TEST_CHECK(file_size(created) == FI.size); assert(file_size(created) == FI.size);
} }
TEST_CHECK(!is_directory(dest / nested_dir_name)); assert(!is_directory(dest / nested_dir_name));
} }
{ // test for existing directory { // test for existing directory
const path dest = env.create_dir("dest_dir2"); const path dest = env.create_dir("dest_dir2");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(dir, dest, ec); fs::copy(dir, dest, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(is_directory(dest)); assert(is_directory(dest));
for (auto& FI : files) { for (auto& FI : files) {
path created = dest / FI.filename; path created = dest / FI.filename;
TEST_CHECK(is_regular_file(created)); assert(is_regular_file(created));
TEST_CHECK(file_size(created) == FI.size); assert(file_size(created) == FI.size);
} }
TEST_CHECK(!is_directory(dest / nested_dir_name)); assert(!is_directory(dest / nested_dir_name));
} }
{ // test recursive copy { // test recursive copy
const path dest = env.make_env_path("dest_dir3"); const path dest = env.make_env_path("dest_dir3");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(dir, dest, CO::recursive, ec); fs::copy(dir, dest, CO::recursive, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(is_directory(dest)); assert(is_directory(dest));
const path nested_dest = dest / nested_dir_name; const path nested_dest = dest / nested_dir_name;
TEST_REQUIRE(is_directory(nested_dest)); assert(is_directory(nested_dest));
for (auto& FI : files) { for (auto& FI : files) {
path created = dest / FI.filename; path created = dest / FI.filename;
path nested_created = nested_dest / FI.filename; path nested_created = nested_dest / FI.filename;
TEST_CHECK(is_regular_file(created)); assert(is_regular_file(created));
TEST_CHECK(file_size(created) == FI.size); assert(file_size(created) == FI.size);
TEST_CHECK(is_regular_file(nested_created)); assert(is_regular_file(nested_created));
TEST_CHECK(file_size(nested_created) == FI.size); assert(file_size(nested_created) == FI.size);
} }
} }
} }
TEST_CASE(test_copy_symlinks_to_symlink_dir) static void test_copy_symlinks_to_symlink_dir()
{ {
scoped_test_env env; scoped_test_env env;
const path file1 = env.create_file("file1", 42); const path file1 = env.create_file("file1", 42);
const path file2 = env.create_file("file2", 101); const path file2 = env.create_file("file2", 101);
const path file2_sym = env.create_symlink(file2, "file2_sym"); const path file2_sym = env.create_symlink(file2, "file2_sym");
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path dir_sym = env.create_directory_symlink(dir, "dir_sym"); const path dir_sym = env.create_directory_symlink(dir, "dir_sym");
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(file1, dir_sym, copy_options::copy_symlinks, ec); fs::copy(file1, dir_sym, copy_options::copy_symlinks, ec);
TEST_CHECK(!ec); assert(!ec);
const path dest = env.make_env_path("dir/file1"); const path dest = env.make_env_path("dir/file1");
TEST_CHECK(exists(dest)); assert(exists(dest));
TEST_CHECK(!is_symlink(dest)); assert(!is_symlink(dest));
TEST_CHECK(file_size(dest) == 42); assert(file_size(dest) == 42);
} }
} }
TEST_CASE(test_dir_create_symlink) static void test_dir_create_symlink()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir1"); const path dir = env.create_dir("dir1");
const path dest = env.make_env_path("dne"); const path dest = env.make_env_path("dne");
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(dir, dest, copy_options::create_symlinks, ec); fs::copy(dir, dest, copy_options::create_symlinks, ec);
TEST_CHECK(ErrorIs(ec, std::errc::is_a_directory)); assert(ErrorIs(ec, std::errc::is_a_directory));
TEST_CHECK(!exists(dest)); assert(!exists(dest));
TEST_CHECK(!is_symlink(dest)); assert(!is_symlink(dest));
} }
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::copy(dir, dest, copy_options::create_symlinks|copy_options::recursive, ec); fs::copy(dir, dest, copy_options::create_symlinks|copy_options::recursive, ec);
TEST_CHECK(ErrorIs(ec, std::errc::is_a_directory)); assert(ErrorIs(ec, std::errc::is_a_directory));
TEST_CHECK(!exists(dest)); assert(!exists(dest));
TEST_CHECK(!is_symlink(dest)); assert(!is_symlink(dest));
} }
} }
TEST_CASE(test_otherwise_no_effects_clause) static void test_otherwise_no_effects_clause()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir1"); const path dir = env.create_dir("dir1");
{ // skip copy because of directory { // skip copy because of directory
const path dest = env.make_env_path("dest1"); const path dest = env.make_env_path("dest1");
std::error_code ec; std::error_code ec;
fs::copy(dir, dest, CO::directories_only, ec); fs::copy(dir, dest, CO::directories_only, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(!exists(dest)); assert(!exists(dest));
} }
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
test_error_reporting();
from_is_symlink();
from_is_regular_file();
from_is_directory();
test_copy_symlinks_to_symlink_dir();
test_dir_create_symlink();
test_otherwise_no_effects_clause();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file.pass.cpp

Show All 20 Lines
// error_code& ec) noexcept; // error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
using CO = fs::copy_options; using CO = fs::copy_options;
TEST_SUITE(filesystem_copy_file_test_suite) static void test_signatures() {
TEST_CASE(test_signatures) {
const path p; const path p;
((void)p); ((void)p);
const copy_options opts{}; const copy_options opts{};
((void)opts); ((void)opts);
std::error_code ec; std::error_code ec;
((void)ec); ((void)ec);
ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p)), bool); ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p)), bool);
ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p, opts)), bool); ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p, opts)), bool);
ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p, ec)), bool); ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p, ec)), bool);
ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p, opts, ec)), bool); ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p, opts, ec)), bool);
ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p)); ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p));
ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p, opts)); ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p, opts));
ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p, ec)); ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p, ec));
ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p, opts, ec)); ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p, opts, ec));
} }
TEST_CASE(test_error_reporting) { static void test_error_reporting() {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file1", 42); const path file = env.create_file("file1", 42);
const path file2 = env.create_file("file2", 55); const path file2 = env.create_file("file2", 55);
{ // exists(to) && equivalent(to, from) { // exists(to) && equivalent(to, from)
std::error_code ec; std::error_code ec;
TEST_CHECK(fs::copy_file(file, file, copy_options::overwrite_existing, assert(fs::copy_file(file, file, copy_options::overwrite_existing,
ec) == false); ec) == false);
TEST_CHECK(ErrorIs(ec, std::errc::file_exists)); assert(ErrorIs(ec, std::errc::file_exists));
ExceptionChecker Checker(file, file, std::errc::file_exists, "copy_file"); ExceptionChecker Checker(file, file, std::errc::file_exists, "copy_file");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, copy_file(file, file, copy_options::overwrite_existing)); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, copy_file(file, file, copy_options::overwrite_existing));
} }
{ // exists(to) && !(skip_existing | overwrite_existing | update_existing) { // exists(to) && !(skip_existing | overwrite_existing | update_existing)
std::error_code ec; std::error_code ec;
TEST_CHECK(fs::copy_file(file, file2, ec) == false); assert(fs::copy_file(file, file2, ec) == false);
TEST_CHECK(ErrorIs(ec, std::errc::file_exists)); assert(ErrorIs(ec, std::errc::file_exists));
ExceptionChecker Checker(file, file, std::errc::file_exists, "copy_file"); ExceptionChecker Checker(file, file, std::errc::file_exists, "copy_file");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, copy_file(file, file, copy_options::overwrite_existing)); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, copy_file(file, file, copy_options::overwrite_existing));
} }
} }
#ifndef _WIN32 #ifndef _WIN32
TEST_CASE(non_regular_file_test) { static void non_regular_file_test() {
scoped_test_env env; scoped_test_env env;
const path fifo = env.create_fifo("fifo"); const path fifo = env.create_fifo("fifo");
const path dest = env.make_env_path("dest"); const path dest = env.make_env_path("dest");
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_REQUIRE(fs::copy_file(fifo, dest, ec) == false); assert(fs::copy_file(fifo, dest, ec) == false);
TEST_CHECK(ErrorIs(ec, std::errc::not_supported)); assert(ErrorIs(ec, std::errc::not_supported));
TEST_CHECK(!exists(dest)); assert(!exists(dest));
} }
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_REQUIRE(fs::copy_file(file, fifo, copy_options::overwrite_existing, assert(fs::copy_file(file, fifo, copy_options::overwrite_existing,
ec) == false); ec) == false);
TEST_CHECK(ErrorIs(ec, std::errc::not_supported)); assert(ErrorIs(ec, std::errc::not_supported));
TEST_CHECK(is_fifo(fifo)); assert(is_fifo(fifo));
} }
} }
#endif #endif // _WIN32
TEST_CASE(test_attributes_get_copied) { static void test_attributes_get_copied() {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file1", 42); const path file = env.create_file("file1", 42);
const path dest = env.make_env_path("file2"); const path dest = env.make_env_path("file2");
(void)status(file); (void)status(file);
perms new_perms = perms::owner_read; perms new_perms = perms::owner_read;
permissions(file, new_perms); permissions(file, new_perms);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_REQUIRE(fs::copy_file(file, dest, ec) == true); assert(fs::copy_file(file, dest, ec) == true);
TEST_CHECK(!ec); assert(!ec);
auto new_st = status(dest); auto new_st = status(dest);
TEST_CHECK(new_st.permissions() == NormalizeExpectedPerms(new_perms)); assert(new_st.permissions() == NormalizeExpectedPerms(new_perms));
} }
TEST_CASE(copy_dir_test) { static void copy_dir_test() {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file1", 42); const path file = env.create_file("file1", 42);
const path dest = env.create_dir("dir1"); const path dest = env.create_dir("dir1");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(fs::copy_file(file, dest, ec) == false); assert(fs::copy_file(file, dest, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
ec = GetTestEC(); ec = GetTestEC();
TEST_CHECK(fs::copy_file(dest, file, ec) == false); assert(fs::copy_file(dest, file, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
} }
TEST_CASE(copy_file) { static void copy_file() {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file1", 42); const path file = env.create_file("file1", 42);
{ // !exists(to) { // !exists(to)
const path dest = env.make_env_path("dest1"); const path dest = env.make_env_path("dest1");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_REQUIRE(fs::copy_file(file, dest, ec) == true); assert(fs::copy_file(file, dest, ec) == true);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(file_size(dest) == 42); assert(file_size(dest) == 42);
} }
{ // exists(to) && overwrite_existing { // exists(to) && overwrite_existing
const path dest = env.create_file("dest2", 55); const path dest = env.create_file("dest2", 55);
permissions(dest, perms::all); permissions(dest, perms::all);
permissions(file, permissions(file,
perms::group_write | perms::owner_write | perms::others_write, perms::group_write | perms::owner_write | perms::others_write,
perm_options::remove); perm_options::remove);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_REQUIRE(fs::copy_file(file, dest, copy_options::overwrite_existing, assert(fs::copy_file(file, dest, copy_options::overwrite_existing,
ec) == true); ec) == true);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(file_size(dest) == 42); assert(file_size(dest) == 42);
TEST_CHECK(status(dest).permissions() == status(file).permissions()); assert(status(dest).permissions() == status(file).permissions());
} }
{ // exists(to) && update_existing { // exists(to) && update_existing
using Sec = std::chrono::seconds; using Sec = std::chrono::seconds;
const path older = env.create_file("older_file", 1); const path older = env.create_file("older_file", 1);
SleepFor(Sec(2)); SleepFor(Sec(2));
const path from = env.create_file("update_from", 55); const path from = env.create_file("update_from", 55);
SleepFor(Sec(2)); SleepFor(Sec(2));
const path newer = env.create_file("newer_file", 2); const path newer = env.create_file("newer_file", 2);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_REQUIRE( assert(
fs::copy_file(from, older, copy_options::update_existing, ec) == true); fs::copy_file(from, older, copy_options::update_existing, ec) == true);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(file_size(older) == 55); assert(file_size(older) == 55);
TEST_REQUIRE( assert(
fs::copy_file(from, newer, copy_options::update_existing, ec) == false); fs::copy_file(from, newer, copy_options::update_existing, ec) == false);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(file_size(newer) == 2); assert(file_size(newer) == 2);
} }
{ // skip_existing { // skip_existing
const path file2 = env.create_file("file2", 55); const path file2 = env.create_file("file2", 55);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_REQUIRE(fs::copy_file(file, file2, copy_options::skip_existing, ec) == assert(fs::copy_file(file, file2, copy_options::skip_existing, ec) ==
false); false);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(file_size(file2) == 55); assert(file_size(file2) == 55);
} }
} }
int main(int, char**) {
test_signatures();
test_error_reporting();
#ifndef _WIN32
non_regular_file_test();
#endif
test_attributes_get_copied();
copy_dir_test();
copy_file();
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file_large.pass.cpp

Show All 17 Lines
// error_code& ec) noexcept; // error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <cassert> #include <cassert>
#include <cstdio> #include <cstdio>
#include <string> #include <string>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_copy_file_test_suite)
// This test is intended to test 'sendfile's 2gb limit for a single call, and // This test is intended to test 'sendfile's 2gb limit for a single call, and
// to ensure that libc++ correctly copies files larger than that limit. // to ensure that libc++ correctly copies files larger than that limit.
// However it requires allocating ~5GB of filesystem space. This might not // However it requires allocating ~5GB of filesystem space. This might not
// be acceptable on all systems. // be acceptable on all systems.
TEST_CASE(large_file) { static void large_file() {
using namespace fs; using namespace fs;
constexpr uintmax_t sendfile_size_limit = 2147479552ull; constexpr uintmax_t sendfile_size_limit = 2147479552ull;
constexpr uintmax_t additional_size = 1024; constexpr uintmax_t additional_size = 1024;
constexpr uintmax_t test_file_size = sendfile_size_limit + additional_size; constexpr uintmax_t test_file_size = sendfile_size_limit + additional_size;
static_assert(test_file_size > sendfile_size_limit, ""); static_assert(test_file_size > sendfile_size_limit, "");
scoped_test_env env; scoped_test_env env;
// Check that we have more than sufficient room to create the files needed // Check that we have more than sufficient room to create the files needed
// to perform the test. // to perform the test.
if (space(env.test_root).available < 3 * test_file_size) { if (space(env.test_root).available < 3 * test_file_size) {
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
} }
// Create a file right at the size limit. The file is full of '\0's. // Create a file right at the size limit. The file is full of '\0's.
const path source = env.create_file("source", sendfile_size_limit); const path source = env.create_file("source", sendfile_size_limit);
const std::string additional_data(additional_size, 'x'); const std::string additional_data(additional_size, 'x');
// Append known data to the end of the source file. // Append known data to the end of the source file.
{ {
std::FILE* outf = std::fopen(source.string().c_str(), "a"); std::FILE* outf = std::fopen(source.string().c_str(), "a");
TEST_REQUIRE(outf != nullptr); assert(outf != nullptr);
std::fputs(additional_data.c_str(), outf); std::fputs(additional_data.c_str(), outf);
std::fclose(outf); std::fclose(outf);
} }
TEST_REQUIRE(file_size(source) == test_file_size); assert(file_size(source) == test_file_size);
const path dest = env.make_env_path("dest"); const path dest = env.make_env_path("dest");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(copy_file(source, dest, ec)); assert(copy_file(source, dest, ec));
TEST_CHECK(!ec); assert(!ec);
TEST_REQUIRE(is_regular_file(dest)); assert(is_regular_file(dest));
TEST_CHECK(file_size(dest) == test_file_size); assert(file_size(dest) == test_file_size);
// Read the data from the end of the destination file, and ensure it matches // Read the data from the end of the destination file, and ensure it matches
// the data at the end of the source file. // the data at the end of the source file.
std::string out_data(additional_size, 'z'); std::string out_data(additional_size, 'z');
{ {
std::FILE* dest_file = std::fopen(dest.string().c_str(), "rb"); std::FILE* dest_file = std::fopen(dest.string().c_str(), "rb");
TEST_REQUIRE(dest_file != nullptr); assert(dest_file != nullptr);
TEST_REQUIRE(std::fseek(dest_file, sendfile_size_limit, SEEK_SET) == 0); assert(std::fseek(dest_file, sendfile_size_limit, SEEK_SET) == 0);
TEST_REQUIRE(std::fread(&out_data[0], sizeof(out_data[0]), additional_size, dest_file) == additional_size); assert(std::fread(&out_data[0], sizeof(out_data[0]), additional_size, dest_file) == additional_size);
std::fclose(dest_file); std::fclose(dest_file);
} }
TEST_CHECK(out_data.size() == additional_data.size()); assert(out_data.size() == additional_data.size());
TEST_CHECK(out_data == additional_data); assert(out_data == additional_data);
} }
TEST_SUITE_END() int main(int, char**) {
large_file();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_symlink/copy_symlink.pass.cpp

Show All 13 Lines
// void copy_symlink(const path& existing_symlink, const path& new_symlink, // void copy_symlink(const path& existing_symlink, const path& new_symlink,
// error_code& ec) noexcept; // error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_copy_symlink_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(fs::copy_symlink(p, p)); ASSERT_NOT_NOEXCEPT(fs::copy_symlink(p, p));
ASSERT_NOEXCEPT(fs::copy_symlink(p, p, ec)); ASSERT_NOEXCEPT(fs::copy_symlink(p, p, ec));
} }
TEST_CASE(test_error_reporting) static void test_error_reporting()
{ {
auto checkThrow = [](path const& f, path const& t, const std::error_code& ec) auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
{ {
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try { try {
fs::copy_symlink(f, t); fs::copy_symlink(f, t);
return true; return true;
} catch (filesystem_error const& err) { } catch (filesystem_error const& err) {
Show All 10 Lines#endif
const path file = env.create_file("file1", 42); const path file = env.create_file("file1", 42);
const path file2 = env.create_file("file2", 55); const path file2 = env.create_file("file2", 55);
const path sym = env.create_symlink(file, "sym"); const path sym = env.create_symlink(file, "sym");
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path dne = env.make_env_path("dne"); const path dne = env.make_env_path("dne");
{ // from is a file, not a symlink { // from is a file, not a symlink
std::error_code ec; std::error_code ec;
fs::copy_symlink(file, dne, ec); fs::copy_symlink(file, dne, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(checkThrow(file, dne, ec)); assert(checkThrow(file, dne, ec));
} }
{ // from is a file, not a symlink { // from is a file, not a symlink
std::error_code ec; std::error_code ec;
fs::copy_symlink(dir, dne, ec); fs::copy_symlink(dir, dne, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(checkThrow(dir, dne, ec)); assert(checkThrow(dir, dne, ec));
} }
{ // destination exists { // destination exists
std::error_code ec; std::error_code ec;
fs::copy_symlink(sym, file2, ec); fs::copy_symlink(sym, file2, ec);
TEST_REQUIRE(ec); assert(ec);
} }
} }
TEST_CASE(copy_symlink_basic) static void copy_symlink_basic()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path dir_sym = env.create_directory_symlink(dir, "dir_sym"); const path dir_sym = env.create_directory_symlink(dir, "dir_sym");
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path file_sym = env.create_symlink(file, "file_sym"); const path file_sym = env.create_symlink(file, "file_sym");
{ // test for directory symlinks { // test for directory symlinks
const path dest = env.make_env_path("dest1"); const path dest = env.make_env_path("dest1");
std::error_code ec; std::error_code ec;
fs::copy_symlink(dir_sym, dest, ec); fs::copy_symlink(dir_sym, dest, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(is_symlink(dest)); assert(is_symlink(dest));
TEST_CHECK(equivalent(dest, dir)); assert(equivalent(dest, dir));
} }
{ // test for file symlinks { // test for file symlinks
const path dest = env.make_env_path("dest2"); const path dest = env.make_env_path("dest2");
std::error_code ec; std::error_code ec;
fs::copy_symlink(file_sym, dest, ec); fs::copy_symlink(file_sym, dest, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(is_symlink(dest)); assert(is_symlink(dest));
TEST_CHECK(equivalent(dest, file)); assert(equivalent(dest, file));
} }
} }
int main(int, char**) {
test_signatures();
test_error_reporting();
copy_symlink_basic();
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directories/create_directories.pass.cpp

Show All 15 Lines
// bool create_directories(const path& p); // bool create_directories(const path& p);
// bool create_directories(const path& p, error_code& ec) noexcept; // bool create_directories(const path& p, error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_create_directories_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(fs::create_directories(p)), bool); ASSERT_SAME_TYPE(decltype(fs::create_directories(p)), bool);
ASSERT_SAME_TYPE(decltype(fs::create_directories(p, ec)), bool); ASSERT_SAME_TYPE(decltype(fs::create_directories(p, ec)), bool);
ASSERT_NOT_NOEXCEPT(fs::create_directories(p)); ASSERT_NOT_NOEXCEPT(fs::create_directories(p));
ASSERT_NOT_NOEXCEPT(fs::create_directories(p, ec)); ASSERT_NOT_NOEXCEPT(fs::create_directories(p, ec));
} }
TEST_CASE(create_existing_directory) static void create_existing_directory()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir1"); const path dir = env.create_dir("dir1");
std::error_code ec; std::error_code ec;
TEST_CHECK(fs::create_directories(dir, ec) == false); assert(fs::create_directories(dir, ec) == false);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(is_directory(dir)); assert(is_directory(dir));
} }
TEST_CASE(create_directory_one_level) static void create_directory_one_level()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.make_env_path("dir1"); const path dir = env.make_env_path("dir1");
std::error_code ec; std::error_code ec;
TEST_CHECK(fs::create_directories(dir, ec) == true); assert(fs::create_directories(dir, ec) == true);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(is_directory(dir)); assert(is_directory(dir));
} }
TEST_CASE(create_directories_multi_level) static void create_directories_multi_level()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.make_env_path("dir1/dir2/dir3"); const path dir = env.make_env_path("dir1/dir2/dir3");
std::error_code ec; std::error_code ec;
TEST_CHECK(fs::create_directories(dir, ec) == true); assert(fs::create_directories(dir, ec) == true);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(is_directory(dir)); assert(is_directory(dir));
} }
TEST_CASE(create_directory_symlinks) { static void create_directory_symlinks() {
scoped_test_env env; scoped_test_env env;
const path root = env.create_dir("dir"); const path root = env.create_dir("dir");
const path sym_dest_dead = env.make_env_path("dead"); const path sym_dest_dead = env.make_env_path("dead");
const path dead_sym = env.create_directory_symlink(sym_dest_dead, "dir/sym_dir"); const path dead_sym = env.create_directory_symlink(sym_dest_dead, "dir/sym_dir");
const path target = env.make_env_path("dir/sym_dir/foo"); const path target = env.make_env_path("dir/sym_dir/foo");
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(create_directories(target, ec) == false); assert(create_directories(target, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ErrorIs(ec, std::errc::file_exists)); assert(ErrorIs(ec, std::errc::file_exists));
TEST_CHECK(!exists(sym_dest_dead)); assert(!exists(sym_dest_dead));
TEST_CHECK(!exists(dead_sym)); assert(!exists(dead_sym));
} }
} }
TEST_CASE(create_directory_through_symlinks) { static void create_directory_through_symlinks() {
scoped_test_env env; scoped_test_env env;
const path root = env.create_dir("dir"); const path root = env.create_dir("dir");
const path sym_dir = env.create_directory_symlink(root, "sym_dir"); const path sym_dir = env.create_directory_symlink(root, "sym_dir");
const path target = env.make_env_path("sym_dir/foo"); const path target = env.make_env_path("sym_dir/foo");
const path resolved_target = env.make_env_path("dir/foo"); const path resolved_target = env.make_env_path("dir/foo");
TEST_REQUIRE(is_directory(sym_dir)); assert(is_directory(sym_dir));
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(create_directories(target, ec) == true); assert(create_directories(target, ec) == true);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(is_directory(target)); assert(is_directory(target));
TEST_CHECK(is_directory(resolved_target)); assert(is_directory(resolved_target));
} }
} }
TEST_CASE(dest_is_file) static void dest_is_file()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(fs::create_directories(file, ec) == false); assert(fs::create_directories(file, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ErrorIs(ec, std::errc::file_exists)); assert(ErrorIs(ec, std::errc::file_exists));
TEST_CHECK(is_regular_file(file)); assert(is_regular_file(file));
} }
TEST_CASE(dest_part_is_file) static void dest_part_is_file()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file"); const path file = env.create_file("file");
const path dir = env.make_env_path("file/dir1"); const path dir = env.make_env_path("file/dir1");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(fs::create_directories(dir, ec) == false); assert(fs::create_directories(dir, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ErrorIs(ec, std::errc::not_a_directory)); assert(ErrorIs(ec, std::errc::not_a_directory));
TEST_CHECK(is_regular_file(file)); assert(is_regular_file(file));
TEST_CHECK(!exists(dir)); assert(!exists(dir));
} }
TEST_CASE(dest_final_part_is_file) static void dest_final_part_is_file()
{ {
scoped_test_env env; scoped_test_env env;
env.create_dir("dir"); env.create_dir("dir");
const path file = env.create_file("dir/file"); const path file = env.create_file("dir/file");
const path dir = env.make_env_path("dir/file/dir1"); const path dir = env.make_env_path("dir/file/dir1");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(fs::create_directories(dir, ec) == false); assert(fs::create_directories(dir, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ErrorIs(ec, std::errc::not_a_directory)); assert(ErrorIs(ec, std::errc::not_a_directory));
TEST_CHECK(is_regular_file(file)); assert(is_regular_file(file));
TEST_CHECK(!exists(dir)); assert(!exists(dir));
} }
TEST_CASE(dest_is_empty_path) static void dest_is_empty_path()
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(fs::create_directories(fs::path{}, ec) == false); assert(fs::create_directories(fs::path{}, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
ExceptionChecker Checker(path{}, std::errc::no_such_file_or_directory, ExceptionChecker Checker(path{}, std::errc::no_such_file_or_directory,
"create_directories"); "create_directories");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, TEST_VALIDATE_EXCEPTION(filesystem_error, Checker,
fs::create_directories(path{})); fs::create_directories(path{}));
} }
#ifdef _WIN32 #ifdef _WIN32
TEST_CASE(nonexistent_root) static void nonexistent_root()
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
// If Q:\ doesn't exist, create_directories would try to recurse upwards // If Q:\ doesn't exist, create_directories would try to recurse upwards
// to parent_path() until it finds a directory that does exist. As the // to parent_path() until it finds a directory that does exist. As the
// whole path is the root name, parent_path() returns itself, and it // whole path is the root name, parent_path() returns itself, and it
// would recurse indefinitely, unless the recursion is broken. // would recurse indefinitely, unless the recursion is broken.
if (!exists("Q:\\")) if (!exists("Q:\\"))
TEST_CHECK(fs::create_directories("Q:\\", ec) == false); assert(fs::create_directories("Q:\\", ec) == false);
TEST_CHECK(fs::create_directories("\\\\nonexistentserver", ec) == false); assert(fs::create_directories("\\\\nonexistentserver", ec) == false);
} }
#endif // _WIN32
int main(int, char**) {
test_signatures();
create_existing_directory();
create_directory_one_level();
create_directories_multi_level();
create_directory_symlinks();
create_directory_through_symlinks();
dest_is_file();
dest_part_is_file();
dest_final_part_is_file();
dest_is_empty_path();
#ifdef _WIN32
nonexistent_root();
#endif #endif
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory.pass.cpp

Show All 17 Lines
// bool create_directory(const path& p, const path& attr); // bool create_directory(const path& p, const path& attr);
// bool create_directory(const path& p, const path& attr, error_code& ec) noexcept; // bool create_directory(const path& p, const path& attr, error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
using namespace fs; using namespace fs;
fs::perms read_umask() { fs::perms read_umask() {
auto old_mask = umask(0); // int on Windows, mode_t on POSIX. auto old_mask = umask(0); // int on Windows, mode_t on POSIX.
umask(old_mask); // reset the mask to the old value. umask(old_mask); // reset the mask to the old value.
return static_cast<fs::perms>(old_mask); return static_cast<fs::perms>(old_mask);
} }
TEST_SUITE(filesystem_create_directory_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(fs::create_directory(p)), bool); ASSERT_SAME_TYPE(decltype(fs::create_directory(p)), bool);
ASSERT_SAME_TYPE(decltype(fs::create_directory(p, ec)), bool); ASSERT_SAME_TYPE(decltype(fs::create_directory(p, ec)), bool);
ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p)), bool); ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p)), bool);
ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p, ec)), bool); ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p, ec)), bool);
ASSERT_NOT_NOEXCEPT(fs::create_directory(p)); ASSERT_NOT_NOEXCEPT(fs::create_directory(p));
ASSERT_NOEXCEPT(fs::create_directory(p, ec)); ASSERT_NOEXCEPT(fs::create_directory(p, ec));
ASSERT_NOT_NOEXCEPT(fs::create_directory(p, p)); ASSERT_NOT_NOEXCEPT(fs::create_directory(p, p));
ASSERT_NOEXCEPT(fs::create_directory(p, p, ec)); ASSERT_NOEXCEPT(fs::create_directory(p, p, ec));
} }
TEST_CASE(create_existing_directory) static void create_existing_directory()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir1"); const path dir = env.create_dir("dir1");
std::error_code ec; std::error_code ec;
TEST_CHECK(fs::create_directory(dir, ec) == false); assert(fs::create_directory(dir, ec) == false);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(is_directory(dir)); assert(is_directory(dir));
// Test throwing version // Test throwing version
TEST_CHECK(fs::create_directory(dir) == false); assert(fs::create_directory(dir) == false);
} }
TEST_CASE(create_directory_one_level) static void create_directory_one_level()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.make_env_path("dir1"); const path dir = env.make_env_path("dir1");
std::error_code ec; std::error_code ec;
TEST_CHECK(fs::create_directory(dir, ec) == true); assert(fs::create_directory(dir, ec) == true);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(is_directory(dir)); assert(is_directory(dir));
auto st = status(dir); auto st = status(dir);
const perms expect_perms = perms::all & ~(read_umask()); const perms expect_perms = perms::all & ~(read_umask());
TEST_CHECK((st.permissions() & perms::all) == expect_perms); assert((st.permissions() & perms::all) == expect_perms);
} }
TEST_CASE(create_directory_multi_level) static void create_directory_multi_level()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.make_env_path("dir1/dir2"); const path dir = env.make_env_path("dir1/dir2");
const path dir1 = env.make_env_path("dir1"); const path dir1 = env.make_env_path("dir1");
std::error_code ec; std::error_code ec;
TEST_CHECK(fs::create_directory(dir, ec) == false); assert(fs::create_directory(dir, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(!is_directory(dir)); assert(!is_directory(dir));
TEST_CHECK(!is_directory(dir1)); assert(!is_directory(dir1));
} }
TEST_CASE(dest_is_file) static void dest_is_file()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(fs::create_directory(file, ec) == false); assert(fs::create_directory(file, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(is_regular_file(file)); assert(is_regular_file(file));
} }
TEST_CASE(dest_part_is_file) static void dest_part_is_file()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file"); const path file = env.create_file("file");
const path dir = env.make_env_path("file/dir1"); const path dir = env.make_env_path("file/dir1");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(fs::create_directory(dir, ec) == false); assert(fs::create_directory(dir, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(is_regular_file(file)); assert(is_regular_file(file));
TEST_CHECK(!exists(dir)); assert(!exists(dir));
} }
TEST_CASE(dest_is_symlink_to_dir) static void dest_is_symlink_to_dir()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path sym = env.create_directory_symlink(dir, "sym_name"); const path sym = env.create_directory_symlink(dir, "sym_name");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(create_directory(sym, ec) == false); assert(create_directory(sym, ec) == false);
TEST_CHECK(!ec); assert(!ec);
} }
TEST_CASE(dest_is_symlink_to_file) static void dest_is_symlink_to_file()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file"); const path file = env.create_file("file");
const path sym = env.create_symlink(file, "sym_name"); const path sym = env.create_symlink(file, "sym_name");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(create_directory(sym, ec) == false); assert(create_directory(sym, ec) == false);
TEST_CHECK(ec); assert(ec);
} }
TEST_SUITE_END() int main(int, char**) {
test_signatures();
create_existing_directory();
create_directory_one_level();
create_directory_multi_level();
dest_is_file();
dest_part_is_file();
dest_is_symlink_to_dir();
dest_is_symlink_to_file();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.pass.cpp

Show All 15 Lines
// bool create_directory(const path& p, const path& attr); // bool create_directory(const path& p, const path& attr);
// bool create_directory(const path& p, const path& attr, error_code& ec) noexcept; // bool create_directory(const path& p, const path& attr, error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_create_directory_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p)), bool); ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p)), bool);
ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p, ec)), bool); ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p, ec)), bool);
ASSERT_NOT_NOEXCEPT(fs::create_directory(p, p)); ASSERT_NOT_NOEXCEPT(fs::create_directory(p, p));
ASSERT_NOEXCEPT(fs::create_directory(p, p, ec)); ASSERT_NOEXCEPT(fs::create_directory(p, p, ec));
} }
TEST_CASE(create_existing_directory) static void create_existing_directory()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir1"); const path dir = env.create_dir("dir1");
const path dir2 = env.create_dir("dir2"); const path dir2 = env.create_dir("dir2");
const perms orig_p = status(dir).permissions(); const perms orig_p = status(dir).permissions();
permissions(dir2, perms::none); permissions(dir2, perms::none);
std::error_code ec; std::error_code ec;
TEST_CHECK(fs::create_directory(dir, dir2, ec) == false); assert(fs::create_directory(dir, dir2, ec) == false);
TEST_CHECK(!ec); assert(!ec);
// Check that the permissions were unchanged // Check that the permissions were unchanged
TEST_CHECK(orig_p == status(dir).permissions()); assert(orig_p == status(dir).permissions());
// Test throwing version // Test throwing version
TEST_CHECK(fs::create_directory(dir, dir2) == false); assert(fs::create_directory(dir, dir2) == false);
} }
// Windows doesn't have the concept of perms::none on directories. // Windows doesn't have the concept of perms::none on directories.
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_CASE(create_directory_one_level) static void create_directory_one_level()
{ {
scoped_test_env env; scoped_test_env env;
// Remove setgid which mkdir would inherit // Remove setgid which mkdir would inherit
permissions(env.test_root, perms::set_gid, perm_options::remove); permissions(env.test_root, perms::set_gid, perm_options::remove);
const path dir = env.make_env_path("dir1"); const path dir = env.make_env_path("dir1");
const path attr_dir = env.create_dir("dir2"); const path attr_dir = env.create_dir("dir2");
permissions(attr_dir, perms::none); permissions(attr_dir, perms::none);
std::error_code ec; std::error_code ec;
TEST_CHECK(fs::create_directory(dir, attr_dir, ec) == true); assert(fs::create_directory(dir, attr_dir, ec) == true);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(is_directory(dir)); assert(is_directory(dir));
// Check that the new directory has the same permissions as attr_dir // Check that the new directory has the same permissions as attr_dir
auto st = status(dir); auto st = status(dir);
TEST_CHECK(st.permissions() == perms::none); assert(st.permissions() == perms::none);
} }
#endif #endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_CASE(create_directory_multi_level) static void create_directory_multi_level()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.make_env_path("dir1/dir2"); const path dir = env.make_env_path("dir1/dir2");
const path dir1 = env.make_env_path("dir1"); const path dir1 = env.make_env_path("dir1");
const path attr_dir = env.create_dir("attr_dir"); const path attr_dir = env.create_dir("attr_dir");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(fs::create_directory(dir, attr_dir, ec) == false); assert(fs::create_directory(dir, attr_dir, ec) == false);
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
TEST_CHECK(!is_directory(dir)); assert(!is_directory(dir));
TEST_CHECK(!is_directory(dir1)); assert(!is_directory(dir1));
} }
TEST_CASE(dest_is_file) static void dest_is_file()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path attr_dir = env.create_dir("attr_dir"); const path attr_dir = env.create_dir("attr_dir");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(fs::create_directory(file, attr_dir, ec) == false); assert(fs::create_directory(file, attr_dir, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(is_regular_file(file)); assert(is_regular_file(file));
} }
TEST_CASE(dest_part_is_file) static void dest_part_is_file()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path dir = env.make_env_path("file/dir1"); const path dir = env.make_env_path("file/dir1");
const path attr_dir = env.create_dir("attr_dir"); const path attr_dir = env.create_dir("attr_dir");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(fs::create_directory(dir, attr_dir, ec) == false); assert(fs::create_directory(dir, attr_dir, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(is_regular_file(file)); assert(is_regular_file(file));
TEST_CHECK(!exists(dir)); assert(!exists(dir));
} }
TEST_CASE(attr_dir_is_invalid) { static void attr_dir_is_invalid() {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path dest = env.make_env_path("dir"); const path dest = env.make_env_path("dir");
const path dne = env.make_env_path("dne"); const path dne = env.make_env_path("dne");
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(create_directory(dest, file, ec) == false); assert(create_directory(dest, file, ec) == false);
TEST_CHECK(ErrorIs(ec, std::errc::not_a_directory)); assert(ErrorIs(ec, std::errc::not_a_directory));
} }
TEST_REQUIRE(!exists(dest)); assert(!exists(dest));
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(create_directory(dest, dne, ec) == false); assert(create_directory(dest, dne, ec) == false);
TEST_CHECK(ErrorIs(ec, std::errc::not_a_directory)); assert(ErrorIs(ec, std::errc::not_a_directory));
} }
} }
TEST_CASE(dest_is_symlink_to_unexisting) { static void dest_is_symlink_to_unexisting() {
scoped_test_env env; scoped_test_env env;
const path attr_dir = env.create_dir("attr_dir"); const path attr_dir = env.create_dir("attr_dir");
const path sym = env.create_symlink("dne_sym", "dne_sym_name"); const path sym = env.create_symlink("dne_sym", "dne_sym_name");
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(create_directory(sym, attr_dir, ec) == false); assert(create_directory(sym, attr_dir, ec) == false);
TEST_CHECK(ec); assert(ec);
} }
} }
TEST_CASE(dest_is_symlink_to_dir) { static void dest_is_symlink_to_dir() {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path sym = env.create_directory_symlink(dir, "sym_name"); const path sym = env.create_directory_symlink(dir, "sym_name");
const path attr_dir = env.create_dir("attr_dir"); const path attr_dir = env.create_dir("attr_dir");
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(create_directory(sym, attr_dir, ec) == false); assert(create_directory(sym, attr_dir, ec) == false);
TEST_CHECK(!ec); assert(!ec);
} }
} }
TEST_CASE(dest_is_symlink_to_file) { static void dest_is_symlink_to_file() {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file"); const path file = env.create_file("file");
const path sym = env.create_symlink(file, "sym_name"); const path sym = env.create_symlink(file, "sym_name");
const path attr_dir = env.create_dir("attr_dir"); const path attr_dir = env.create_dir("attr_dir");
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(create_directory(sym, attr_dir, ec) == false); assert(create_directory(sym, attr_dir, ec) == false);
TEST_CHECK(ec); assert(ec);
} }
} }
TEST_SUITE_END() int main(int, char**) {
test_signatures();
create_existing_directory();
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
create_directory_one_level();
#endif
create_directory_multi_level();
dest_is_file();
dest_part_is_file();
attr_dir_is_invalid();
dest_is_symlink_to_unexisting();
dest_is_symlink_to_dir();
dest_is_symlink_to_file();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory_symlink/create_directory_symlink.pass.cpp

Show All 12 Lines
// void create_directory_symlink(const path& existing_symlink, const path& new_symlink); // void create_directory_symlink(const path& existing_symlink, const path& new_symlink);
// void create_directory_symlink(const path& existing_symlink, const path& new_symlink, // void create_directory_symlink(const path& existing_symlink, const path& new_symlink,
// error_code& ec) noexcept; // error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_create_directory_symlink_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(fs::create_directory_symlink(p, p)); ASSERT_NOT_NOEXCEPT(fs::create_directory_symlink(p, p));
ASSERT_NOEXCEPT(fs::create_directory_symlink(p, p, ec)); ASSERT_NOEXCEPT(fs::create_directory_symlink(p, p, ec));
} }
TEST_CASE(test_error_reporting) static void test_error_reporting()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file1", 42); const path file = env.create_file("file1", 42);
const path file2 = env.create_file("file2", 55); const path file2 = env.create_file("file2", 55);
const path sym = env.create_symlink(file, "sym"); const path sym = env.create_symlink(file, "sym");
{ // destination exists { // destination exists
std::error_code ec; std::error_code ec;
fs::create_directory_symlink(sym, file2, ec); fs::create_directory_symlink(sym, file2, ec);
TEST_REQUIRE(ec); assert(ec);
} }
} }
TEST_CASE(create_directory_symlink_basic) static void create_directory_symlink_basic()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path dir_sym = env.create_directory_symlink(dir, "dir_sym"); const path dir_sym = env.create_directory_symlink(dir, "dir_sym");
const path dest = env.make_env_path("dest1"); const path dest = env.make_env_path("dest1");
std::error_code ec; std::error_code ec;
fs::create_directory_symlink(dir_sym, dest, ec); fs::create_directory_symlink(dir_sym, dest, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(is_symlink(dest)); assert(is_symlink(dest));
TEST_CHECK(equivalent(dest, dir)); assert(equivalent(dest, dir));
} }
int main(int, char**) {
test_signatures();
test_error_reporting();
create_directory_symlink_basic();
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_hard_link/create_hard_link.pass.cpp

Show All 11 Lines
// void create_hard_link(const path& existing_symlink, const path& new_symlink); // void create_hard_link(const path& existing_symlink, const path& new_symlink);
// void create_hard_link(const path& existing_symlink, const path& new_symlink, // void create_hard_link(const path& existing_symlink, const path& new_symlink,
// error_code& ec) noexcept; // error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_create_hard_link_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(fs::create_hard_link(p, p)); ASSERT_NOT_NOEXCEPT(fs::create_hard_link(p, p));
ASSERT_NOEXCEPT(fs::create_hard_link(p, p, ec)); ASSERT_NOEXCEPT(fs::create_hard_link(p, p, ec));
} }
TEST_CASE(test_error_reporting) static void test_error_reporting()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file1", 42); const path file = env.create_file("file1", 42);
const path file2 = env.create_file("file2", 55); const path file2 = env.create_file("file2", 55);
const path sym = env.create_symlink(file, "sym"); const path sym = env.create_symlink(file, "sym");
{ // destination exists { // destination exists
std::error_code ec; std::error_code ec;
fs::create_hard_link(sym, file2, ec); fs::create_hard_link(sym, file2, ec);
TEST_REQUIRE(ec); assert(ec);
} }
} }
TEST_CASE(create_file_hard_link) static void create_file_hard_link()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file"); const path file = env.create_file("file");
const path dest = env.make_env_path("dest1"); const path dest = env.make_env_path("dest1");
std::error_code ec; std::error_code ec;
TEST_CHECK(hard_link_count(file) == 1); assert(hard_link_count(file) == 1);
fs::create_hard_link(file, dest, ec); fs::create_hard_link(file, dest, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(exists(dest)); assert(exists(dest));
TEST_CHECK(equivalent(dest, file)); assert(equivalent(dest, file));
TEST_CHECK(hard_link_count(file) == 2); assert(hard_link_count(file) == 2);
} }
TEST_CASE(create_directory_hard_link_fails) static void create_directory_hard_link_fails()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path dest = env.make_env_path("dest2"); const path dest = env.make_env_path("dest2");
std::error_code ec; std::error_code ec;
fs::create_hard_link(dir, dest, ec); fs::create_hard_link(dir, dest, ec);
TEST_REQUIRE(ec); assert(ec);
} }
TEST_SUITE_END() int main(int, char**) {
test_signatures();
test_error_reporting();
create_file_hard_link();
create_directory_hard_link_fails();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_symlink/create_symlink.pass.cpp

Show All 12 Lines
// void create_symlink(const path& existing_symlink, const path& new_symlink); // void create_symlink(const path& existing_symlink, const path& new_symlink);
// void create_symlink(const path& existing_symlink, const path& new_symlink, // void create_symlink(const path& existing_symlink, const path& new_symlink,
// error_code& ec) noexcept; // error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_create_symlink_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(fs::create_symlink(p, p)); ASSERT_NOT_NOEXCEPT(fs::create_symlink(p, p));
ASSERT_NOEXCEPT(fs::create_symlink(p, p, ec)); ASSERT_NOEXCEPT(fs::create_symlink(p, p, ec));
} }
TEST_CASE(test_error_reporting) static void test_error_reporting()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file1", 42); const path file = env.create_file("file1", 42);
const path file2 = env.create_file("file2", 55); const path file2 = env.create_file("file2", 55);
const path sym = env.create_symlink(file, "sym"); const path sym = env.create_symlink(file, "sym");
{ // destination exists { // destination exists
std::error_code ec; std::error_code ec;
fs::create_symlink(sym, file2, ec); fs::create_symlink(sym, file2, ec);
TEST_REQUIRE(ec); assert(ec);
} }
} }
TEST_CASE(create_symlink_basic) static void create_symlink_basic()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path file_sym = env.create_symlink(file, "file_sym"); const path file_sym = env.create_symlink(file, "file_sym");
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path dir_sym = env.create_directory_symlink(dir, "dir_sym"); const path dir_sym = env.create_directory_symlink(dir, "dir_sym");
{ {
const path dest = env.make_env_path("dest1"); const path dest = env.make_env_path("dest1");
std::error_code ec; std::error_code ec;
fs::create_symlink(file_sym, dest, ec); fs::create_symlink(file_sym, dest, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(is_symlink(dest)); assert(is_symlink(dest));
TEST_CHECK(equivalent(dest, file)); assert(equivalent(dest, file));
} }
{ {
const path dest = env.make_env_path("dest2"); const path dest = env.make_env_path("dest2");
std::error_code ec; std::error_code ec;
fs::create_directory_symlink(dir_sym, dest, ec); fs::create_directory_symlink(dir_sym, dest, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(is_symlink(dest)); assert(is_symlink(dest));
TEST_CHECK(equivalent(dest, dir)); assert(equivalent(dest, dir));
} }
} }
TEST_CASE(create_symlink_dest_cleanup) static void create_symlink_dest_cleanup()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path sym = dir / "link"; const path sym = dir / "link";
// The target path has to be normalized to backslashes before creating // The target path has to be normalized to backslashes before creating
// the link on windows, otherwise the link isn't dereferencable. // the link on windows, otherwise the link isn't dereferencable.
const path sym_target = "../file"; const path sym_target = "../file";
path sym_target_normalized = sym_target; path sym_target_normalized = sym_target;
sym_target_normalized.make_preferred(); sym_target_normalized.make_preferred();
std::error_code ec; std::error_code ec;
fs::create_symlink(sym_target, sym, ec); fs::create_symlink(sym_target, sym, ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(equivalent(sym, file, ec)); assert(equivalent(sym, file, ec));
const path ret = fs::read_symlink(sym, ec); const path ret = fs::read_symlink(sym, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(ret.native() == sym_target_normalized.native()); assert(ret.native() == sym_target_normalized.native());
} }
int main(int, char**) {
test_signatures();
test_error_reporting();
create_symlink_basic();
create_symlink_dest_cleanup();
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.current_path/current_path.pass.cpp

Show All 14 Lines
// void current_path(path const&); // void current_path(path const&);
// void current_path(path const&, std::error_code& ec) noexcept; // void current_path(path const&, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_current_path_path_test_suite) static void current_path_signature_test()
TEST_CASE(current_path_signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(current_path()); ASSERT_NOT_NOEXCEPT(current_path());
ASSERT_NOT_NOEXCEPT(current_path(ec)); ASSERT_NOT_NOEXCEPT(current_path(ec));
ASSERT_NOT_NOEXCEPT(current_path(p)); ASSERT_NOT_NOEXCEPT(current_path(p));
ASSERT_NOEXCEPT(current_path(p, ec)); ASSERT_NOEXCEPT(current_path(p, ec));
} }
TEST_CASE(current_path_test) static void current_path_test()
{ {
std::error_code ec; std::error_code ec;
const path p = current_path(ec); const path p = current_path(ec);
TEST_REQUIRE(!ec); assert(!ec);
TEST_CHECK(p.is_absolute()); assert(p.is_absolute());
TEST_CHECK(is_directory(p)); assert(is_directory(p));
const path p2 = current_path(); const path p2 = current_path();
TEST_CHECK(p2 == p); assert(p2 == p);
} }
TEST_CASE(current_path_after_change_test) static void current_path_after_change_test()
{ {
static_test_env static_env; static_test_env static_env;
CWDGuard guard; CWDGuard guard;
const path new_path = static_env.Dir; const path new_path = static_env.Dir;
current_path(new_path); current_path(new_path);
TEST_CHECK(current_path() == new_path); assert(current_path() == new_path);
} }
TEST_CASE(current_path_is_file_test) static void current_path_is_file_test()
{ {
static_test_env static_env; static_test_env static_env;
CWDGuard guard; CWDGuard guard;
const path p = static_env.File; const path p = static_env.File;
std::error_code ec; std::error_code ec;
const path old_p = current_path(); const path old_p = current_path();
current_path(p, ec); current_path(p, ec);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(old_p == current_path()); assert(old_p == current_path());
} }
TEST_CASE(set_to_non_absolute_path) static void set_to_non_absolute_path()
{ {
static_test_env static_env; static_test_env static_env;
CWDGuard guard; CWDGuard guard;
const path base = static_env.Dir; const path base = static_env.Dir;
current_path(base); current_path(base);
const path p = static_env.Dir2.filename(); const path p = static_env.Dir2.filename();
std::error_code ec; std::error_code ec;
current_path(p, ec); current_path(p, ec);
TEST_CHECK(!ec); assert(!ec);
const path new_cwd = current_path(); const path new_cwd = current_path();
TEST_CHECK(new_cwd == static_env.Dir2); assert(new_cwd == static_env.Dir2);
TEST_CHECK(new_cwd.is_absolute()); assert(new_cwd.is_absolute());
} }
TEST_CASE(set_to_empty) static void set_to_empty()
{ {
const path p = ""; const path p = "";
std::error_code ec; std::error_code ec;
const path old_p = current_path(); const path old_p = current_path();
current_path(p, ec); current_path(p, ec);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(old_p == current_path()); assert(old_p == current_path());
} }
TEST_SUITE_END() int main(int, char**) {
current_path_signature_test();
current_path_test();
current_path_after_change_test();
current_path_is_file_test();
set_to_non_absolute_path();
set_to_empty();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp

Show All 12 Lines
// bool equivalent(path const& lhs, path const& rhs); // bool equivalent(path const& lhs, path const& rhs);
// bool equivalent(path const& lhs, path const& rhs, std::error_code& ec) noexcept; // bool equivalent(path const& lhs, path const& rhs, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(equivalent_test_suite) static void signature_test() {
TEST_CASE(signature_test) {
const path p; const path p;
((void)p); ((void)p);
std::error_code ec; std::error_code ec;
((void)ec); ((void)ec);
ASSERT_NOEXCEPT(equivalent(p, p, ec)); ASSERT_NOEXCEPT(equivalent(p, p, ec));
ASSERT_NOT_NOEXCEPT(equivalent(p, p)); ASSERT_NOT_NOEXCEPT(equivalent(p, p));
} }
TEST_CASE(equivalent_test) { static void equivalent_test() {
static_test_env static_env; static_test_env static_env;
struct TestCase { struct TestCase {
path lhs; path lhs;
path rhs; path rhs;
bool expect; bool expect;
}; };
const TestCase testCases[] = { const TestCase testCases[] = {
{static_env.Dir, static_env.Dir, true}, {static_env.Dir, static_env.Dir, true},
{static_env.File, static_env.Dir, false}, {static_env.File, static_env.Dir, false},
{static_env.Dir, static_env.SymlinkToDir, true}, {static_env.Dir, static_env.SymlinkToDir, true},
{static_env.Dir, static_env.SymlinkToFile, false}, {static_env.Dir, static_env.SymlinkToFile, false},
{static_env.File, static_env.File, true}, {static_env.File, static_env.File, true},
{static_env.File, static_env.SymlinkToFile, true}, {static_env.File, static_env.SymlinkToFile, true},
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
std::error_code ec; std::error_code ec;
TEST_CHECK(equivalent(TC.lhs, TC.rhs, ec) == TC.expect); assert(equivalent(TC.lhs, TC.rhs, ec) == TC.expect);
TEST_CHECK(!ec); assert(!ec);
} }
} }
TEST_CASE(equivalent_reports_error_if_input_dne) { static void equivalent_reports_error_if_input_dne() {
static_test_env static_env; static_test_env static_env;
const path E = static_env.File; const path E = static_env.File;
const path DNE = static_env.DNE; const path DNE = static_env.DNE;
{ // Test that an error is reported when either of the paths don't exist { // Test that an error is reported when either of the paths don't exist
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(equivalent(E, DNE, ec) == false); assert(equivalent(E, DNE, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
} }
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(equivalent(DNE, E, ec) == false); assert(equivalent(DNE, E, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
} }
{ {
TEST_CHECK_THROW(filesystem_error, equivalent(DNE, E)); TEST_THROWS_TYPE(filesystem_error, equivalent(DNE, E));
TEST_CHECK_THROW(filesystem_error, equivalent(E, DNE)); TEST_THROWS_TYPE(filesystem_error, equivalent(E, DNE));
} }
{ // Test that an exception is thrown if both paths do not exist. { // Test that an exception is thrown if both paths do not exist.
TEST_CHECK_THROW(filesystem_error, equivalent(DNE, DNE)); TEST_THROWS_TYPE(filesystem_error, equivalent(DNE, DNE));
} }
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(equivalent(DNE, DNE, ec) == false); assert(equivalent(DNE, DNE, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
} }
} }
TEST_CASE(equivalent_hardlink_succeeds) { static void equivalent_hardlink_succeeds() {
scoped_test_env env; scoped_test_env env;
path const file = env.create_file("file", 42); path const file = env.create_file("file", 42);
const path hl1 = env.create_hardlink(file, "hl1"); const path hl1 = env.create_hardlink(file, "hl1");
const path hl2 = env.create_hardlink(file, "hl2"); const path hl2 = env.create_hardlink(file, "hl2");
TEST_CHECK(equivalent(file, hl1)); assert(equivalent(file, hl1));
TEST_CHECK(equivalent(file, hl2)); assert(equivalent(file, hl2));
TEST_CHECK(equivalent(hl1, hl2)); assert(equivalent(hl1, hl2));
} }
#ifndef _WIN32 #ifndef _WIN32
TEST_CASE(equivalent_is_other_succeeds) { static void equivalent_is_other_succeeds() {
scoped_test_env env; scoped_test_env env;
path const file = env.create_file("file", 42); path const file = env.create_file("file", 42);
const path fifo1 = env.create_fifo("fifo1"); const path fifo1 = env.create_fifo("fifo1");
const path fifo2 = env.create_fifo("fifo2"); const path fifo2 = env.create_fifo("fifo2");
// Required to test behavior for inputs where is_other(p) is true. // Required to test behavior for inputs where is_other(p) is true.
TEST_REQUIRE(is_other(fifo1)); assert(is_other(fifo1));
TEST_CHECK(!equivalent(file, fifo1)); assert(!equivalent(file, fifo1));
TEST_CHECK(!equivalent(fifo2, file)); assert(!equivalent(fifo2, file));
TEST_CHECK(!equivalent(fifo1, fifo2)); assert(!equivalent(fifo1, fifo2));
TEST_CHECK(equivalent(fifo1, fifo1)); assert(equivalent(fifo1, fifo1));
} }
#endif // _WIN32
int main(int, char**) {
signature_test();
equivalent_test();
equivalent_reports_error_if_input_dne();
equivalent_hardlink_succeeds();
#ifndef _WIN32
equivalent_is_other_succeeds();
#endif #endif
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.exists/exists.pass.cpp

Show All 13 Lines
// bool exists(path const& p); // bool exists(path const& p);
// bool exists(path const& p, std::error_code& ec) noexcept; // bool exists(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(exists_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOEXCEPT(exists(s)); ASSERT_NOEXCEPT(exists(s));
ASSERT_NOEXCEPT(exists(p, ec)); ASSERT_NOEXCEPT(exists(p, ec));
ASSERT_NOT_NOEXCEPT(exists(p)); ASSERT_NOT_NOEXCEPT(exists(p));
} }
TEST_CASE(exists_status_test) static void exists_status_test()
{ {
struct TestCase { struct TestCase {
file_type type; file_type type;
bool expect; bool expect;
}; };
const TestCase testCases[] = { const TestCase testCases[] = {
{file_type::none, false}, {file_type::none, false},
{file_type::not_found, false}, {file_type::not_found, false},
{file_type::regular, true}, {file_type::regular, true},
{file_type::directory, true}, {file_type::directory, true},
{file_type::symlink, true}, {file_type::symlink, true},
{file_type::block, true}, {file_type::block, true},
{file_type::character, true}, {file_type::character, true},
{file_type::fifo, true}, {file_type::fifo, true},
{file_type::socket, true}, {file_type::socket, true},
{file_type::unknown, true} {file_type::unknown, true}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
file_status s(TC.type); file_status s(TC.type);
TEST_CHECK(exists(s) == TC.expect); assert(exists(s) == TC.expect);
} }
} }
TEST_CASE(test_exist_not_found) static void test_exist_not_found()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.DNE; const path p = static_env.DNE;
TEST_CHECK(exists(p) == false); assert(exists(p) == false);
TEST_CHECK(exists(static_env.Dir) == true); assert(exists(static_env.Dir) == true);
TEST_CHECK(exists(static_env.Dir / "dne") == false); assert(exists(static_env.Dir / "dne") == false);
// Whether <dir>/dne/.. is considered to exist or not is not necessarily // Whether <dir>/dne/.. is considered to exist or not is not necessarily
// something we need to define, but the platform specific behaviour // something we need to define, but the platform specific behaviour
// does affect a few other tests, so clarify the root cause here. // does affect a few other tests, so clarify the root cause here.
#ifdef _WIN32 #ifdef _WIN32
TEST_CHECK(exists(static_env.Dir / "dne" / "..") == true); assert(exists(static_env.Dir / "dne" / "..") == true);
#else #else
TEST_CHECK(exists(static_env.Dir / "dne" / "..") == false); assert(exists(static_env.Dir / "dne" / "..") == false);
#endif #endif
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(exists(p, ec) == false); assert(exists(p, ec) == false);
TEST_CHECK(!ec); assert(!ec);
} }
TEST_CASE(test_exists_fails) static void test_exists_fails()
{ {
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path p = GetWindowsInaccessibleDir(); const path p = GetWindowsInaccessibleDir();
if (p.empty()) if (p.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path p = env.create_file("dir/file", 42); const path p = env.create_file("dir/file", 42);
permissions(dir, perms::none); permissions(dir, perms::none);
#endif #endif
std::error_code ec; std::error_code ec;
TEST_CHECK(exists(p, ec) == false); assert(exists(p, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK_THROW(filesystem_error, exists(p)); TEST_THROWS_TYPE(filesystem_error, exists(p));
} }
#ifndef _WIN32 #ifndef _WIN32
// Checking for the existence of an invalid long path name doesn't // Checking for the existence of an invalid long path name doesn't
// trigger errors on windows. // trigger errors on windows.
TEST_CASE(test_name_too_long) { static void test_name_too_long() {
std::string long_name(2500, 'a'); std::string long_name(2500, 'a');
const path file(long_name); const path file(long_name);
std::error_code ec; std::error_code ec;
TEST_CHECK(exists(file, ec) == false); assert(exists(file, ec) == false);
TEST_CHECK(ec); assert(ec);
} }
#endif // _WIN32
int main(int, char**) {
signature_test();
exists_status_test();
test_exist_not_found();
test_exists_fails();
#ifndef _WIN32
test_name_too_long();
#endif #endif
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.file_size/file_size.pass.cpp

Show All 16 Lines
// uintmax_t file_size(const path& p); // uintmax_t file_size(const path& p);
// uintmax_t file_size(const path& p, std::error_code& ec) noexcept; // uintmax_t file_size(const path& p, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(file_size_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(file_size(p)), uintmax_t); ASSERT_SAME_TYPE(decltype(file_size(p)), uintmax_t);
ASSERT_SAME_TYPE(decltype(file_size(p, ec)), uintmax_t); ASSERT_SAME_TYPE(decltype(file_size(p, ec)), uintmax_t);
ASSERT_NOT_NOEXCEPT(file_size(p)); ASSERT_NOT_NOEXCEPT(file_size(p));
ASSERT_NOEXCEPT(file_size(p, ec)); ASSERT_NOEXCEPT(file_size(p, ec));
} }
TEST_CASE(file_size_empty_test) static void file_size_empty_test()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.EmptyFile; const path p = static_env.EmptyFile;
TEST_CHECK(file_size(p) == 0); assert(file_size(p) == 0);
std::error_code ec; std::error_code ec;
TEST_CHECK(file_size(p, ec) == 0); assert(file_size(p, ec) == 0);
} }
TEST_CASE(file_size_non_empty) static void file_size_non_empty()
{ {
scoped_test_env env; scoped_test_env env;
const path p = env.create_file("file", 42); const path p = env.create_file("file", 42);
TEST_CHECK(file_size(p) == 42); assert(file_size(p) == 42);
std::error_code ec; std::error_code ec;
TEST_CHECK(file_size(p, ec) == 42); assert(file_size(p, ec) == 42);
} }
TEST_CASE(symlink_test_case) static void symlink_test_case()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.File; const path p = static_env.File;
const path p2 = static_env.SymlinkToFile; const path p2 = static_env.SymlinkToFile;
TEST_CHECK(file_size(p) == file_size(p2)); assert(file_size(p) == file_size(p2));
} }
TEST_CASE(file_size_error_cases) static void file_size_error_cases()
{ {
static_test_env static_env; static_test_env static_env;
struct { struct {
path p; path p;
std::errc expected_err; std::errc expected_err;
} TestCases[] = { } TestCases[] = {
{static_env.Dir, std::errc::is_a_directory}, {static_env.Dir, std::errc::is_a_directory},
{static_env.SymlinkToDir, std::errc::is_a_directory}, {static_env.SymlinkToDir, std::errc::is_a_directory},
{static_env.BadSymlink, std::errc::no_such_file_or_directory}, {static_env.BadSymlink, std::errc::no_such_file_or_directory},
{static_env.DNE, std::errc::no_such_file_or_directory}, {static_env.DNE, std::errc::no_such_file_or_directory},
{"", std::errc::no_such_file_or_directory}}; {"", std::errc::no_such_file_or_directory}};
const uintmax_t expect = static_cast<uintmax_t>(-1); const uintmax_t expect = static_cast<uintmax_t>(-1);
for (auto& TC : TestCases) { for (auto& TC : TestCases) {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(file_size(TC.p, ec) == expect); assert(file_size(TC.p, ec) == expect);
TEST_CHECK(ErrorIs(ec, TC.expected_err)); assert(ErrorIs(ec, TC.expected_err));
ExceptionChecker Checker(TC.p, TC.expected_err, "file_size"); ExceptionChecker Checker(TC.p, TC.expected_err, "file_size");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, file_size(TC.p)); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, file_size(TC.p));
} }
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
file_size_empty_test();
file_size_non_empty();
symlink_test_case();
file_size_error_cases();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_block_file/is_block_file.pass.cpp

Show All 13 Lines
// bool is_block_file(path const& p); // bool is_block_file(path const& p);
// bool is_block_file(path const& p, std::error_code& ec) noexcept; // bool is_block_file(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_block_file_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOEXCEPT(is_block_file(s)); ASSERT_NOEXCEPT(is_block_file(s));
ASSERT_NOEXCEPT(is_block_file(p, ec)); ASSERT_NOEXCEPT(is_block_file(p, ec));
ASSERT_NOT_NOEXCEPT(is_block_file(p)); ASSERT_NOT_NOEXCEPT(is_block_file(p));
} }
TEST_CASE(is_block_file_status_test) static void is_block_file_status_test()
{ {
struct TestCase { struct TestCase {
file_type type; file_type type;
bool expect; bool expect;
}; };
const TestCase testCases[] = { const TestCase testCases[] = {
{file_type::none, false}, {file_type::none, false},
{file_type::not_found, false}, {file_type::not_found, false},
{file_type::regular, false}, {file_type::regular, false},
{file_type::directory, false}, {file_type::directory, false},
{file_type::symlink, false}, {file_type::symlink, false},
{file_type::block, true}, {file_type::block, true},
{file_type::character, false}, {file_type::character, false},
{file_type::fifo, false}, {file_type::fifo, false},
{file_type::socket, false}, {file_type::socket, false},
{file_type::unknown, false} {file_type::unknown, false}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
file_status s(TC.type); file_status s(TC.type);
TEST_CHECK(is_block_file(s) == TC.expect); assert(is_block_file(s) == TC.expect);
} }
} }
TEST_CASE(test_exist_not_found) static void test_exist_not_found()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.DNE; const path p = static_env.DNE;
TEST_CHECK(is_block_file(p) == false); assert(is_block_file(p) == false);
} }
TEST_CASE(test_is_block_file_fails) static void test_is_block_file_fails()
{ {
scoped_test_env env; scoped_test_env env;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path p = GetWindowsInaccessibleDir(); const path p = GetWindowsInaccessibleDir();
if (p.empty()) if (p.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path p = env.create_file("dir/file", 42); const path p = env.create_file("dir/file", 42);
permissions(dir, perms::none); permissions(dir, perms::none);
#endif #endif
std::error_code ec; std::error_code ec;
TEST_CHECK(is_block_file(p, ec) == false); assert(is_block_file(p, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK_THROW(filesystem_error, is_block_file(p)); TEST_THROWS_TYPE(filesystem_error, is_block_file(p));
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
is_block_file_status_test();
test_exist_not_found();
test_is_block_file_fails();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_char_file/is_character_file.pass.cpp

Show All 13 Lines
// bool is_character_file(path const& p); // bool is_character_file(path const& p);
// bool is_character_file(path const& p, std::error_code& ec) noexcept; // bool is_character_file(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_character_file_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOEXCEPT(is_character_file(s)); ASSERT_NOEXCEPT(is_character_file(s));
ASSERT_NOEXCEPT(is_character_file(p, ec)); ASSERT_NOEXCEPT(is_character_file(p, ec));
ASSERT_NOT_NOEXCEPT(is_character_file(p)); ASSERT_NOT_NOEXCEPT(is_character_file(p));
} }
TEST_CASE(is_character_file_status_test) static void is_character_file_status_test()
{ {
struct TestCase { struct TestCase {
file_type type; file_type type;
bool expect; bool expect;
}; };
const TestCase testCases[] = { const TestCase testCases[] = {
{file_type::none, false}, {file_type::none, false},
{file_type::not_found, false}, {file_type::not_found, false},
{file_type::regular, false}, {file_type::regular, false},
{file_type::directory, false}, {file_type::directory, false},
{file_type::symlink, false}, {file_type::symlink, false},
{file_type::block, false}, {file_type::block, false},
{file_type::character, true}, {file_type::character, true},
{file_type::fifo, false}, {file_type::fifo, false},
{file_type::socket, false}, {file_type::socket, false},
{file_type::unknown, false} {file_type::unknown, false}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
file_status s(TC.type); file_status s(TC.type);
TEST_CHECK(is_character_file(s) == TC.expect); assert(is_character_file(s) == TC.expect);
} }
} }
TEST_CASE(test_exist_not_found) static void test_exist_not_found()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.DNE; const path p = static_env.DNE;
TEST_CHECK(is_character_file(p) == false); assert(is_character_file(p) == false);
} }
TEST_CASE(test_is_character_file_fails) static void test_is_character_file_fails()
{ {
scoped_test_env env; scoped_test_env env;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path p = GetWindowsInaccessibleDir(); const path p = GetWindowsInaccessibleDir();
if (p.empty()) if (p.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path p = env.create_file("dir/file", 42); const path p = env.create_file("dir/file", 42);
permissions(dir, perms::none); permissions(dir, perms::none);
#endif #endif
std::error_code ec; std::error_code ec;
TEST_CHECK(is_character_file(p, ec) == false); assert(is_character_file(p, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK_THROW(filesystem_error, is_character_file(p)); TEST_THROWS_TYPE(filesystem_error, is_character_file(p));
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
is_character_file_status_test();
test_exist_not_found();
test_is_character_file_fails();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_directory/is_directory.pass.cpp

Show All 13 Lines
// bool is_directory(path const& p); // bool is_directory(path const& p);
// bool is_directory(path const& p, std::error_code& ec) noexcept; // bool is_directory(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_directory_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOEXCEPT(is_directory(s)); ASSERT_NOEXCEPT(is_directory(s));
ASSERT_NOEXCEPT(is_directory(p, ec)); ASSERT_NOEXCEPT(is_directory(p, ec));
ASSERT_NOT_NOEXCEPT(is_directory(p)); ASSERT_NOT_NOEXCEPT(is_directory(p));
} }
TEST_CASE(is_directory_status_test) static void is_directory_status_test()
{ {
struct TestCase { struct TestCase {
file_type type; file_type type;
bool expect; bool expect;
}; };
const TestCase testCases[] = { const TestCase testCases[] = {
{file_type::none, false}, {file_type::none, false},
{file_type::not_found, false}, {file_type::not_found, false},
{file_type::regular, false}, {file_type::regular, false},
{file_type::directory, true}, {file_type::directory, true},
{file_type::symlink, false}, {file_type::symlink, false},
{file_type::block, false}, {file_type::block, false},
{file_type::character, false}, {file_type::character, false},
{file_type::fifo, false}, {file_type::fifo, false},
{file_type::socket, false}, {file_type::socket, false},
{file_type::unknown, false} {file_type::unknown, false}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
file_status s(TC.type); file_status s(TC.type);
TEST_CHECK(is_directory(s) == TC.expect); assert(is_directory(s) == TC.expect);
} }
} }
TEST_CASE(test_exist_not_found) static void test_exist_not_found()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.DNE; const path p = static_env.DNE;
TEST_CHECK(is_directory(p) == false); assert(is_directory(p) == false);
} }
TEST_CASE(static_env_test) static void static_env_test()
{ {
static_test_env static_env; static_test_env static_env;
TEST_CHECK(is_directory(static_env.Dir)); assert(is_directory(static_env.Dir));
TEST_CHECK(is_directory(static_env.SymlinkToDir)); assert(is_directory(static_env.SymlinkToDir));
TEST_CHECK(!is_directory(static_env.File)); assert(!is_directory(static_env.File));
} }
TEST_CASE(test_is_directory_fails) static void test_is_directory_fails()
{ {
scoped_test_env env; scoped_test_env env;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path p = GetWindowsInaccessibleDir(); const path p = GetWindowsInaccessibleDir();
if (p.empty()) if (p.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path p = env.create_dir("dir/dir2"); const path p = env.create_dir("dir/dir2");
permissions(dir, perms::none); permissions(dir, perms::none);
#endif #endif
std::error_code ec; std::error_code ec;
TEST_CHECK(is_directory(p, ec) == false); assert(is_directory(p, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK_THROW(filesystem_error, is_directory(p)); TEST_THROWS_TYPE(filesystem_error, is_directory(p));
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
is_directory_status_test();
test_exist_not_found();
static_env_test();
test_is_directory_fails();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp

Show All 12 Lines
// bool is_empty(path const& p); // bool is_empty(path const& p);
// bool is_empty(path const& p, std::error_code& ec); // bool is_empty(path const& p, std::error_code& ec);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_empty_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(is_empty(p, ec)); ASSERT_NOT_NOEXCEPT(is_empty(p, ec));
ASSERT_NOT_NOEXCEPT(is_empty(p)); ASSERT_NOT_NOEXCEPT(is_empty(p));
} }
TEST_CASE(test_exist_not_found) static void test_exist_not_found()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.DNE; const path p = static_env.DNE;
std::error_code ec; std::error_code ec;
TEST_CHECK(is_empty(p, ec) == false); assert(is_empty(p, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK_THROW(filesystem_error, is_empty(p)); TEST_THROWS_TYPE(filesystem_error, is_empty(p));
} }
TEST_CASE(test_is_empty_directory) static void test_is_empty_directory()
{ {
static_test_env static_env; static_test_env static_env;
TEST_CHECK(!is_empty(static_env.Dir)); assert(!is_empty(static_env.Dir));
TEST_CHECK(!is_empty(static_env.SymlinkToDir)); assert(!is_empty(static_env.SymlinkToDir));
} }
TEST_CASE(test_is_empty_directory_dynamic) static void test_is_empty_directory_dynamic()
{ {
scoped_test_env env; scoped_test_env env;
TEST_CHECK(is_empty(env.test_root)); assert(is_empty(env.test_root));
env.create_file("foo", 42); env.create_file("foo", 42);
TEST_CHECK(!is_empty(env.test_root)); assert(!is_empty(env.test_root));
} }
TEST_CASE(test_is_empty_file) static void test_is_empty_file()
{ {
static_test_env static_env; static_test_env static_env;
TEST_CHECK(is_empty(static_env.EmptyFile)); assert(is_empty(static_env.EmptyFile));
TEST_CHECK(!is_empty(static_env.NonEmptyFile)); assert(!is_empty(static_env.NonEmptyFile));
} }
TEST_CASE(test_is_empty_fails) static void test_is_empty_fails()
{ {
scoped_test_env env; scoped_test_env env;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path p = GetWindowsInaccessibleDir(); const path p = GetWindowsInaccessibleDir();
if (p.empty()) if (p.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path p = env.create_dir("dir/dir2"); const path p = env.create_dir("dir/dir2");
permissions(dir, perms::none); permissions(dir, perms::none);
#endif #endif
std::error_code ec; std::error_code ec;
TEST_CHECK(is_empty(p, ec) == false); assert(is_empty(p, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK_THROW(filesystem_error, is_empty(p)); TEST_THROWS_TYPE(filesystem_error, is_empty(p));
} }
TEST_CASE(test_directory_access_denied) static void test_directory_access_denied()
{ {
scoped_test_env env; scoped_test_env env;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path dir = GetWindowsInaccessibleDir(); const path dir = GetWindowsInaccessibleDir();
if (dir.empty()) if (dir.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file1 = env.create_file("dir/file", 42); const path file1 = env.create_file("dir/file", 42);
permissions(dir, perms::none); permissions(dir, perms::none);
#endif #endif
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(is_empty(dir, ec) == false); assert(is_empty(dir, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
TEST_CHECK_THROW(filesystem_error, is_empty(dir)); TEST_THROWS_TYPE(filesystem_error, is_empty(dir));
} }
#ifndef _WIN32 #ifndef _WIN32
TEST_CASE(test_fifo_fails) static void test_fifo_fails()
{ {
scoped_test_env env; scoped_test_env env;
const path fifo = env.create_fifo("fifo"); const path fifo = env.create_fifo("fifo");
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(is_empty(fifo, ec) == false); assert(is_empty(fifo, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
TEST_CHECK_THROW(filesystem_error, is_empty(fifo)); TEST_THROWS_TYPE(filesystem_error, is_empty(fifo));
} }
#endif // _WIN32
int main(int, char**) {
signature_test();
test_exist_not_found();
test_is_empty_directory();
test_is_empty_directory_dynamic();
test_is_empty_file();
test_is_empty_fails();
test_directory_access_denied();
#ifndef _WIN32
test_fifo_fails();
#endif #endif
TEST_SUITE_END() return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_fifo/is_fifo.pass.cpp

Show All 13 Lines
// bool is_fifo(path const& p); // bool is_fifo(path const& p);
// bool is_fifo(path const& p, std::error_code& ec) noexcept; // bool is_fifo(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_fifo_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOEXCEPT(is_fifo(s)); ASSERT_NOEXCEPT(is_fifo(s));
ASSERT_NOEXCEPT(is_fifo(p, ec)); ASSERT_NOEXCEPT(is_fifo(p, ec));
ASSERT_NOT_NOEXCEPT(is_fifo(p)); ASSERT_NOT_NOEXCEPT(is_fifo(p));
} }
TEST_CASE(is_fifo_status_test) static void is_fifo_status_test()
{ {
struct TestCase { struct TestCase {
file_type type; file_type type;
bool expect; bool expect;
}; };
const TestCase testCases[] = { const TestCase testCases[] = {
{file_type::none, false}, {file_type::none, false},
{file_type::not_found, false}, {file_type::not_found, false},
{file_type::regular, false}, {file_type::regular, false},
{file_type::directory, false}, {file_type::directory, false},
{file_type::symlink, false}, {file_type::symlink, false},
{file_type::block, false}, {file_type::block, false},
{file_type::character, false}, {file_type::character, false},
{file_type::fifo, true}, {file_type::fifo, true},
{file_type::socket, false}, {file_type::socket, false},
{file_type::unknown, false} {file_type::unknown, false}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
file_status s(TC.type); file_status s(TC.type);
TEST_CHECK(is_fifo(s) == TC.expect); assert(is_fifo(s) == TC.expect);
} }
} }
TEST_CASE(test_exist_not_found) static void test_exist_not_found()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.DNE; const path p = static_env.DNE;
TEST_CHECK(is_fifo(p) == false); assert(is_fifo(p) == false);
} }
TEST_CASE(test_is_fifo_fails) static void test_is_fifo_fails()
{ {
scoped_test_env env; scoped_test_env env;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path p = GetWindowsInaccessibleDir(); const path p = GetWindowsInaccessibleDir();
if (p.empty()) if (p.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path p = env.create_file("dir/file", 42); const path p = env.create_file("dir/file", 42);
permissions(dir, perms::none); permissions(dir, perms::none);
#endif #endif
std::error_code ec; std::error_code ec;
TEST_CHECK(is_fifo(p, ec) == false); assert(is_fifo(p, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK_THROW(filesystem_error, is_fifo(p)); TEST_THROWS_TYPE(filesystem_error, is_fifo(p));
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
is_fifo_status_test();
test_exist_not_found();
test_is_fifo_fails();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_other/is_other.pass.cpp

Show All 13 Lines
// bool is_other(path const& p); // bool is_other(path const& p);
// bool is_other(path const& p, std::error_code& ec) noexcept; // bool is_other(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_other_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOEXCEPT(is_other(s)); ASSERT_NOEXCEPT(is_other(s));
ASSERT_NOEXCEPT(is_other(p, ec)); ASSERT_NOEXCEPT(is_other(p, ec));
ASSERT_NOT_NOEXCEPT(is_other(p)); ASSERT_NOT_NOEXCEPT(is_other(p));
} }
TEST_CASE(is_other_status_test) static void is_other_status_test()
{ {
struct TestCase { struct TestCase {
file_type type; file_type type;
bool expect; bool expect;
}; };
const TestCase testCases[] = { const TestCase testCases[] = {
{file_type::none, false}, {file_type::none, false},
{file_type::not_found, false}, {file_type::not_found, false},
{file_type::regular, false}, {file_type::regular, false},
{file_type::directory, false}, {file_type::directory, false},
{file_type::symlink, false}, {file_type::symlink, false},
{file_type::block, true}, {file_type::block, true},
{file_type::character, true}, {file_type::character, true},
{file_type::fifo, true}, {file_type::fifo, true},
{file_type::socket, true}, {file_type::socket, true},
{file_type::unknown, true} {file_type::unknown, true}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
file_status s(TC.type); file_status s(TC.type);
TEST_CHECK(is_other(s) == TC.expect); assert(is_other(s) == TC.expect);
} }
} }
TEST_CASE(test_exist_not_found) static void test_exist_not_found()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.DNE; const path p = static_env.DNE;
TEST_CHECK(is_other(p) == false); assert(is_other(p) == false);
} }
TEST_CASE(test_is_other_fails) static void test_is_other_fails()
{ {
scoped_test_env env; scoped_test_env env;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path p = GetWindowsInaccessibleDir(); const path p = GetWindowsInaccessibleDir();
if (p.empty()) if (p.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path p = env.create_file("dir/file", 42); const path p = env.create_file("dir/file", 42);
permissions(dir, perms::none); permissions(dir, perms::none);
#endif #endif
std::error_code ec; std::error_code ec;
TEST_CHECK(is_other(p, ec) == false); assert(is_other(p, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK_THROW(filesystem_error, is_other(p)); TEST_THROWS_TYPE(filesystem_error, is_other(p));
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
is_other_status_test();
test_exist_not_found();
test_is_other_fails();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_regular_file/is_regular_file.pass.cpp

Show All 13 Lines
// bool is_regular_file(path const& p); // bool is_regular_file(path const& p);
// bool is_regular_file(path const& p, std::error_code& ec) noexcept; // bool is_regular_file(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_regular_file_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOEXCEPT(is_regular_file(s)); ASSERT_NOEXCEPT(is_regular_file(s));
ASSERT_NOEXCEPT(is_regular_file(p, ec)); ASSERT_NOEXCEPT(is_regular_file(p, ec));
ASSERT_NOT_NOEXCEPT(is_regular_file(p)); ASSERT_NOT_NOEXCEPT(is_regular_file(p));
} }
TEST_CASE(is_regular_file_status_test) static void is_regular_file_status_test()
{ {
struct TestCase { struct TestCase {
file_type type; file_type type;
bool expect; bool expect;
}; };
const TestCase testCases[] = { const TestCase testCases[] = {
{file_type::none, false}, {file_type::none, false},
{file_type::not_found, false}, {file_type::not_found, false},
{file_type::regular, true}, {file_type::regular, true},
{file_type::directory, false}, {file_type::directory, false},
{file_type::symlink, false}, {file_type::symlink, false},
{file_type::block, false}, {file_type::block, false},
{file_type::character, false}, {file_type::character, false},
{file_type::fifo, false}, {file_type::fifo, false},
{file_type::socket, false}, {file_type::socket, false},
{file_type::unknown, false} {file_type::unknown, false}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
file_status s(TC.type); file_status s(TC.type);
TEST_CHECK(is_regular_file(s) == TC.expect); assert(is_regular_file(s) == TC.expect);
} }
} }
TEST_CASE(test_exist_not_found) static void test_exist_not_found()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.DNE; const path p = static_env.DNE;
TEST_CHECK(is_regular_file(p) == false); assert(is_regular_file(p) == false);
std::error_code ec; std::error_code ec;
TEST_CHECK(is_regular_file(p, ec) == false); assert(is_regular_file(p, ec) == false);
TEST_CHECK(ec); assert(ec);
} }
TEST_CASE(test_is_regular_file_fails) static void test_is_regular_file_fails()
{ {
scoped_test_env env; scoped_test_env env;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path p = GetWindowsInaccessibleDir(); const path p = GetWindowsInaccessibleDir();
if (p.empty()) if (p.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path p = env.create_file("dir/file", 42); const path p = env.create_file("dir/file", 42);
permissions(dir, perms::none); permissions(dir, perms::none);
#endif #endif
std::error_code ec; std::error_code ec;
TEST_CHECK(is_regular_file(p, ec) == false); assert(is_regular_file(p, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK_THROW(filesystem_error, is_regular_file(p)); TEST_THROWS_TYPE(filesystem_error, is_regular_file(p));
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
is_regular_file_status_test();
test_exist_not_found();
test_is_regular_file_fails();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_socket/is_socket.pass.cpp

Show All 13 Lines
// bool is_socket(path const& p); // bool is_socket(path const& p);
// bool is_socket(path const& p, std::error_code& ec) noexcept; // bool is_socket(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_socket_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOEXCEPT(is_socket(s)); ASSERT_NOEXCEPT(is_socket(s));
ASSERT_NOEXCEPT(is_socket(p, ec)); ASSERT_NOEXCEPT(is_socket(p, ec));
ASSERT_NOT_NOEXCEPT(is_socket(p)); ASSERT_NOT_NOEXCEPT(is_socket(p));
} }
TEST_CASE(is_socket_status_test) static void is_socket_status_test()
{ {
struct TestCase { struct TestCase {
file_type type; file_type type;
bool expect; bool expect;
}; };
const TestCase testCases[] = { const TestCase testCases[] = {
{file_type::none, false}, {file_type::none, false},
{file_type::not_found, false}, {file_type::not_found, false},
{file_type::regular, false}, {file_type::regular, false},
{file_type::directory, false}, {file_type::directory, false},
{file_type::symlink, false}, {file_type::symlink, false},
{file_type::block, false}, {file_type::block, false},
{file_type::character, false}, {file_type::character, false},
{file_type::fifo, false}, {file_type::fifo, false},
{file_type::socket, true}, {file_type::socket, true},
{file_type::unknown, false} {file_type::unknown, false}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
file_status s(TC.type); file_status s(TC.type);
TEST_CHECK(is_socket(s) == TC.expect); assert(is_socket(s) == TC.expect);
} }
} }
TEST_CASE(test_exist_not_found) static void test_exist_not_found()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.DNE; const path p = static_env.DNE;
TEST_CHECK(is_socket(p) == false); assert(is_socket(p) == false);
} }
TEST_CASE(test_is_socket_fails) static void test_is_socket_fails()
{ {
scoped_test_env env; scoped_test_env env;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path p = GetWindowsInaccessibleDir(); const path p = GetWindowsInaccessibleDir();
if (p.empty()) if (p.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path p = env.create_file("dir/file", 42); const path p = env.create_file("dir/file", 42);
permissions(dir, perms::none); permissions(dir, perms::none);
#endif #endif
std::error_code ec; std::error_code ec;
TEST_CHECK(is_socket(p, ec) == false); assert(is_socket(p, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK_THROW(filesystem_error, is_socket(p)); TEST_THROWS_TYPE(filesystem_error, is_socket(p));
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
is_socket_status_test();
test_exist_not_found();
test_is_socket_fails();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_symlink/is_symlink.pass.cpp

Show All 13 Lines
// bool is_symlink(path const& p); // bool is_symlink(path const& p);
// bool is_symlink(path const& p, std::error_code& ec) noexcept; // bool is_symlink(path const& p, std::error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(is_symlink_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOEXCEPT(is_symlink(s)); ASSERT_NOEXCEPT(is_symlink(s));
ASSERT_NOEXCEPT(is_symlink(p, ec)); ASSERT_NOEXCEPT(is_symlink(p, ec));
ASSERT_NOT_NOEXCEPT(is_symlink(p)); ASSERT_NOT_NOEXCEPT(is_symlink(p));
} }
TEST_CASE(is_symlink_status_test) static void is_symlink_status_test()
{ {
struct TestCase { struct TestCase {
file_type type; file_type type;
bool expect; bool expect;
}; };
const TestCase testCases[] = { const TestCase testCases[] = {
{file_type::none, false}, {file_type::none, false},
{file_type::not_found, false}, {file_type::not_found, false},
{file_type::regular, false}, {file_type::regular, false},
{file_type::directory, false}, {file_type::directory, false},
{file_type::symlink, true}, {file_type::symlink, true},
{file_type::block, false}, {file_type::block, false},
{file_type::character, false}, {file_type::character, false},
{file_type::fifo, false}, {file_type::fifo, false},
{file_type::socket, false}, {file_type::socket, false},
{file_type::unknown, false} {file_type::unknown, false}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
file_status s(TC.type); file_status s(TC.type);
TEST_CHECK(is_symlink(s) == TC.expect); assert(is_symlink(s) == TC.expect);
} }
} }
TEST_CASE(static_env_test) static void static_env_test()
{ {
static_test_env static_env; static_test_env static_env;
struct TestCase { struct TestCase {
path p; path p;
bool expect; bool expect;
}; };
const TestCase testCases[] = { const TestCase testCases[] = {
{static_env.File, false}, {static_env.File, false},
{static_env.Dir, false}, {static_env.Dir, false},
{static_env.SymlinkToFile, true}, {static_env.SymlinkToFile, true},
{static_env.SymlinkToDir, true}, {static_env.SymlinkToDir, true},
{static_env.BadSymlink, true} {static_env.BadSymlink, true}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
TEST_CHECK(is_symlink(TC.p) == TC.expect); assert(is_symlink(TC.p) == TC.expect);
} }
} }
TEST_CASE(test_exist_not_found) static void test_exist_not_found()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.DNE; const path p = static_env.DNE;
TEST_CHECK(is_symlink(p) == false); assert(is_symlink(p) == false);
std::error_code ec; std::error_code ec;
TEST_CHECK(is_symlink(p, ec) == false); assert(is_symlink(p, ec) == false);
TEST_CHECK(ec); assert(ec);
} }
TEST_CASE(test_is_symlink_fails) static void test_is_symlink_fails()
{ {
scoped_test_env env; scoped_test_env env;
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
const path p = GetWindowsInaccessibleDir(); const path p = GetWindowsInaccessibleDir();
if (p.empty()) if (p.empty())
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
#else #else
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path p = env.create_file("dir/file", 42); const path p = env.create_file("dir/file", 42);
permissions(dir, perms::none); permissions(dir, perms::none);
#endif #endif
std::error_code ec; std::error_code ec;
TEST_CHECK(is_symlink(p, ec) == false); assert(is_symlink(p, ec) == false);
TEST_CHECK(ec); assert(ec);
TEST_CHECK_THROW(filesystem_error, is_symlink(p)); TEST_THROWS_TYPE(filesystem_error, is_symlink(p));
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
is_symlink_status_test();
static_env_test();
test_exist_not_found();
test_is_symlink_fails();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp

Show All 23 Lines
#include <chrono> #include <chrono>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <ctime> #include <ctime>
#include <ratio> #include <ratio>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
#include <fcntl.h> #include <fcntl.h>
#ifdef _WIN32 #ifdef _WIN32
#include <windows.h> #include <windows.h>
#else #else
#include <sys/time.h> #include <sys/time.h>
#include <sys/stat.h> #include <sys/stat.h>
▲ Show 20 Lines • Show All 330 Lines • ▼ Show 20 Linesfile_time_type::duration SubSec(long long val) {
using SubSecT = file_time_type::duration; using SubSecT = file_time_type::duration;
if (SupportsNanosecondRoundTrip) { if (SupportsNanosecondRoundTrip) {
return duration_cast<SubSecT>(NanoSec(val)); return duration_cast<SubSecT>(NanoSec(val));
} else { } else {
return duration_cast<SubSecT>(MicroSec(val)); return duration_cast<SubSecT>(MicroSec(val));
} }
} }
TEST_SUITE(last_write_time_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
const file_time_type t; const file_time_type t;
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(last_write_time(p)), file_time_type); ASSERT_SAME_TYPE(decltype(last_write_time(p)), file_time_type);
ASSERT_SAME_TYPE(decltype(last_write_time(p, ec)), file_time_type); ASSERT_SAME_TYPE(decltype(last_write_time(p, ec)), file_time_type);
ASSERT_SAME_TYPE(decltype(last_write_time(p, t)), void); ASSERT_SAME_TYPE(decltype(last_write_time(p, t)), void);
ASSERT_SAME_TYPE(decltype(last_write_time(p, t, ec)), void); ASSERT_SAME_TYPE(decltype(last_write_time(p, t, ec)), void);
ASSERT_NOT_NOEXCEPT(last_write_time(p)); ASSERT_NOT_NOEXCEPT(last_write_time(p));
ASSERT_NOT_NOEXCEPT(last_write_time(p, t)); ASSERT_NOT_NOEXCEPT(last_write_time(p, t));
ASSERT_NOEXCEPT(last_write_time(p, ec)); ASSERT_NOEXCEPT(last_write_time(p, ec));
ASSERT_NOEXCEPT(last_write_time(p, t, ec)); ASSERT_NOEXCEPT(last_write_time(p, t, ec));
} }
TEST_CASE(read_last_write_time_static_env_test) static void read_last_write_time_static_env_test()
{ {
static_test_env static_env; static_test_env static_env;
using C = file_time_type::clock; using C = file_time_type::clock;
file_time_type min = file_time_type::min(); file_time_type min = file_time_type::min();
// Sleep a little to make sure that static_env.File created above is // Sleep a little to make sure that static_env.File created above is
// strictly older than C::now() even with a coarser clock granularity // strictly older than C::now() even with a coarser clock granularity
// in C::now(). (GetSystemTimeAsFileTime on windows has a fairly coarse // in C::now(). (GetSystemTimeAsFileTime on windows has a fairly coarse
// granularity.) // granularity.)
SleepFor(MilliSec(30)); SleepFor(MilliSec(30));
{ {
file_time_type ret = last_write_time(static_env.File); file_time_type ret = last_write_time(static_env.File);
TEST_CHECK(ret != min); assert(ret != min);
TEST_CHECK(ret < C::now()); assert(ret < C::now());
TEST_CHECK(CompareTime(ret, LastWriteTime(static_env.File))); assert(CompareTime(ret, LastWriteTime(static_env.File)));
file_time_type ret2 = last_write_time(static_env.SymlinkToFile); file_time_type ret2 = last_write_time(static_env.SymlinkToFile);
TEST_CHECK(CompareTime(ret, ret2)); assert(CompareTime(ret, ret2));
TEST_CHECK(CompareTime(ret2, LastWriteTime(static_env.SymlinkToFile))); assert(CompareTime(ret2, LastWriteTime(static_env.SymlinkToFile)));
} }
{ {
file_time_type ret = last_write_time(static_env.Dir); file_time_type ret = last_write_time(static_env.Dir);
TEST_CHECK(ret != min); assert(ret != min);
TEST_CHECK(ret < C::now()); assert(ret < C::now());
TEST_CHECK(CompareTime(ret, LastWriteTime(static_env.Dir))); assert(CompareTime(ret, LastWriteTime(static_env.Dir)));
file_time_type ret2 = last_write_time(static_env.SymlinkToDir); file_time_type ret2 = last_write_time(static_env.SymlinkToDir);
TEST_CHECK(CompareTime(ret, ret2)); assert(CompareTime(ret, ret2));
TEST_CHECK(CompareTime(ret2, LastWriteTime(static_env.SymlinkToDir))); assert(CompareTime(ret2, LastWriteTime(static_env.SymlinkToDir)));
} }
} }
TEST_CASE(get_last_write_time_dynamic_env_test) static void get_last_write_time_dynamic_env_test()
{ {
using Sec = std::chrono::seconds;
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const auto file_times = GetTimes(file); const auto file_times = GetTimes(file);
const TimeSpec file_write_time = file_times.write; const TimeSpec file_write_time = file_times.write;
const auto dir_times = GetTimes(dir); const auto dir_times = GetTimes(dir);
const TimeSpec dir_write_time = dir_times.write; const TimeSpec dir_write_time = dir_times.write;
file_time_type ftime = last_write_time(file); file_time_type ftime = last_write_time(file);
TEST_CHECK(CompareTime(ftime, file_write_time)); assert(CompareTime(ftime, file_write_time));
file_time_type dtime = last_write_time(dir); file_time_type dtime = last_write_time(dir);
TEST_CHECK(CompareTime(dtime, dir_write_time)); assert(CompareTime(dtime, dir_write_time));
SleepFor(Sec(2)); SleepFor(std::chrono::seconds(2));
// update file and add a file to the directory. Make sure the times increase. // update file and add a file to the directory. Make sure the times increase.
std::FILE* of = std::fopen(file.string().c_str(), "a"); std::FILE* of = std::fopen(file.string().c_str(), "a");
std::fwrite("hello", 1, sizeof("hello"), of); std::fwrite("hello", 1, sizeof("hello"), of);
std::fclose(of); std::fclose(of);
env.create_file("dir/file1", 1); env.create_file("dir/file1", 1);
file_time_type ftime2 = last_write_time(file); file_time_type ftime2 = last_write_time(file);
file_time_type dtime2 = last_write_time(dir); file_time_type dtime2 = last_write_time(dir);
TEST_CHECK(ftime2 > ftime); assert(ftime2 > ftime);
TEST_CHECK(dtime2 > dtime); assert(dtime2 > dtime);
TEST_CHECK(CompareTime(LastWriteTime(file), ftime2)); assert(CompareTime(LastWriteTime(file), ftime2));
TEST_CHECK(CompareTime(LastWriteTime(dir), dtime2)); assert(CompareTime(LastWriteTime(dir), dtime2));
} }
TEST_CASE(set_last_write_time_dynamic_env_test) static void set_last_write_time_dynamic_env_test()
{ {
using Clock = file_time_type::clock; using Clock = file_time_type::clock;
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const auto now = Clock::now(); const auto now = Clock::now();
const file_time_type epoch_time = now - now.time_since_epoch(); const file_time_type epoch_time = now - now.time_since_epoch();
Show All 34 Lines#if !defined(_AIX)
{"file, just_before_epoch_time", file, just_before_epoch_time}, {"file, just_before_epoch_time", file, just_before_epoch_time},
{"dir, just_before_epoch_time", dir, just_before_epoch_time} {"dir, just_before_epoch_time", dir, just_before_epoch_time}
#endif #endif
}; };
for (const auto& TC : cases) { for (const auto& TC : cases) {
const auto old_times = GetTimes(TC.p); const auto old_times = GetTimes(TC.p);
file_time_type old_time; file_time_type old_time;
TEST_REQUIRE(ConvertFromTimeSpec(old_time, old_times.write)); assert(ConvertFromTimeSpec(old_time, old_times.write));
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
last_write_time(TC.p, TC.new_time, ec); last_write_time(TC.p, TC.new_time, ec);
TEST_CHECK(!ec); assert(!ec);
ec = GetTestEC(); ec = GetTestEC();
file_time_type got_time = last_write_time(TC.p, ec); file_time_type got_time = last_write_time(TC.p, ec);
TEST_REQUIRE(!ec); assert(!ec);
if (TimeIsRepresentableByFilesystem(TC.new_time)) { if (TimeIsRepresentableByFilesystem(TC.new_time)) {
TEST_CHECK(got_time != old_time); assert(got_time != old_time);
TEST_CHECK(CompareTime(got_time, TC.new_time)); assert(CompareTime(got_time, TC.new_time));
TEST_CHECK(CompareTime(LastAccessTime(TC.p), old_times.access)); assert(CompareTime(LastAccessTime(TC.p), old_times.access));
} }
} }
} }
TEST_CASE(last_write_time_symlink_test) static void last_write_time_symlink_test()
{ {
using Clock = file_time_type::clock; using Clock = file_time_type::clock;
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path sym = env.create_symlink("file", "sym"); const path sym = env.create_symlink("file", "sym");
const file_time_type new_time = Clock::now() + Hours(3); const file_time_type new_time = Clock::now() + Hours(3);
const auto old_times = GetTimes(sym); const auto old_times = GetTimes(sym);
const auto old_sym_times = GetSymlinkTimes(sym); const auto old_sym_times = GetSymlinkTimes(sym);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
last_write_time(sym, new_time, ec); last_write_time(sym, new_time, ec);
TEST_CHECK(!ec); assert(!ec);
file_time_type got_time = last_write_time(sym); file_time_type got_time = last_write_time(sym);
TEST_CHECK(!CompareTime(got_time, old_times.write)); assert(!CompareTime(got_time, old_times.write));
if (!WorkaroundStatTruncatesToSeconds) { if (!WorkaroundStatTruncatesToSeconds) {
TEST_CHECK(got_time == new_time); assert(got_time == new_time);
} else { } else {
TEST_CHECK(CompareTime(got_time, new_time)); assert(CompareTime(got_time, new_time));
} }
TEST_CHECK(CompareTime(LastWriteTime(file), new_time)); assert(CompareTime(LastWriteTime(file), new_time));
TEST_CHECK(CompareTime(LastAccessTime(sym), old_times.access)); assert(CompareTime(LastAccessTime(sym), old_times.access));
Times sym_times = GetSymlinkTimes(sym); Times sym_times = GetSymlinkTimes(sym);
TEST_CHECK(CompareTime(sym_times.write, old_sym_times.write)); assert(CompareTime(sym_times.write, old_sym_times.write));
} }
TEST_CASE(test_write_min_time) static void test_write_min_time()
{ {
scoped_test_env env; scoped_test_env env;
const path p = env.create_file("file", 42); const path p = env.create_file("file", 42);
const file_time_type old_time = last_write_time(p); const file_time_type old_time = last_write_time(p);
file_time_type new_time = file_time_type::min(); file_time_type new_time = file_time_type::min();
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
last_write_time(p, new_time, ec); last_write_time(p, new_time, ec);
file_time_type tt = last_write_time(p); file_time_type tt = last_write_time(p);
if (TimeIsRepresentableByFilesystem(new_time)) { if (TimeIsRepresentableByFilesystem(new_time)) {
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(CompareTime(tt, new_time)); assert(CompareTime(tt, new_time));
last_write_time(p, old_time); last_write_time(p, old_time);
new_time = file_time_type::min() + SubSec(1); new_time = file_time_type::min() + SubSec(1);
ec = GetTestEC(); ec = GetTestEC();
last_write_time(p, new_time, ec); last_write_time(p, new_time, ec);
tt = last_write_time(p); tt = last_write_time(p);
if (TimeIsRepresentableByFilesystem(new_time)) { if (TimeIsRepresentableByFilesystem(new_time)) {
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(CompareTime(tt, new_time)); assert(CompareTime(tt, new_time));
} else { } else {
TEST_CHECK(ErrorIs(ec, std::errc::value_too_large)); assert(ErrorIs(ec, std::errc::value_too_large));
TEST_CHECK(tt == old_time); assert(tt == old_time);
} }
} else { } else {
TEST_CHECK(ErrorIs(ec, std::errc::value_too_large)); assert(ErrorIs(ec, std::errc::value_too_large));
TEST_CHECK(tt == old_time); assert(tt == old_time);
} }
} }
TEST_CASE(test_write_max_time) { static void test_write_max_time() {
scoped_test_env env; scoped_test_env env;
const path p = env.create_file("file", 42); const path p = env.create_file("file", 42);
const file_time_type old_time = last_write_time(p); const file_time_type old_time = last_write_time(p);
file_time_type new_time = file_time_type::max(); file_time_type new_time = file_time_type::max();
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
last_write_time(p, new_time, ec); last_write_time(p, new_time, ec);
file_time_type tt = last_write_time(p); file_time_type tt = last_write_time(p);
if (TimeIsRepresentableByFilesystem(new_time)) { if (TimeIsRepresentableByFilesystem(new_time)) {
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(CompareTime(tt, new_time)); assert(CompareTime(tt, new_time));
} else { } else {
TEST_CHECK(ErrorIs(ec, std::errc::value_too_large)); assert(ErrorIs(ec, std::errc::value_too_large));
TEST_CHECK(tt == old_time); assert(tt == old_time);
} }
} }
TEST_CASE(test_value_on_failure) static void test_value_on_failure()
{ {
static_test_env static_env; static_test_env static_env;
const path p = static_env.DNE; const path p = static_env.DNE;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(last_write_time(p, ec) == file_time_type::min()); assert(last_write_time(p, ec) == file_time_type::min());
TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory)); assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
} }
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. // reading directories.
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_CASE(test_exists_fails) static void test_exists_fails()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
permissions(dir, perms::none); permissions(dir, perms::none);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
TEST_CHECK(last_write_time(file, ec) == file_time_type::min()); assert(last_write_time(file, ec) == file_time_type::min());
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
ExceptionChecker Checker(file, std::errc::permission_denied, ExceptionChecker Checker(file, std::errc::permission_denied,
"last_write_time"); "last_write_time");
TEST_CHECK_THROW_RESULT(filesystem_error, Checker, last_write_time(file)); TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, last_write_time(file));
} }
#endif #endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_SUITE_END() int main(int, char**) {
signature_test();
read_last_write_time_static_env_test();
get_last_write_time_dynamic_env_test();
set_last_write_time_dynamic_env_test();
last_write_time_symlink_test();
test_write_min_time();
test_write_max_time();
test_value_on_failure();
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
test_exists_fails();
#endif
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.permissions/permissions.pass.cpp

Show All 14 Lines
// void permissions(const path& p, perms prms, std::error_code& ec) noexcept; // void permissions(const path& p, perms prms, std::error_code& ec) noexcept;
// void permissions(const path& p, perms prms, perm_options opts, std::error_code); // void permissions(const path& p, perms prms, perm_options opts, std::error_code);
#include "filesystem_include.h" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
using PR = fs::perms; using PR = fs::perms;
TEST_SUITE(filesystem_permissions_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
const perms pr{}; ((void)pr); const perms pr{}; ((void)pr);
const perm_options opts{}; ((void)opts); const perm_options opts{}; ((void)opts);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(fs::permissions(p, pr)); ASSERT_NOT_NOEXCEPT(fs::permissions(p, pr));
ASSERT_NOT_NOEXCEPT(fs::permissions(p, pr, opts)); ASSERT_NOT_NOEXCEPT(fs::permissions(p, pr, opts));
ASSERT_NOEXCEPT(fs::permissions(p, pr, ec)); ASSERT_NOEXCEPT(fs::permissions(p, pr, ec));
LIBCPP_ONLY(ASSERT_NOT_NOEXCEPT(fs::permissions(p, pr, opts, ec))); LIBCPP_ONLY(ASSERT_NOT_NOEXCEPT(fs::permissions(p, pr, opts, ec)));
} }
TEST_CASE(test_error_reporting) static void test_error_reporting()
{ {
auto checkThrow = [](path const& f, fs::perms opts, auto checkThrow = [](path const& f, fs::perms opts,
const std::error_code& ec) const std::error_code& ec)
{ {
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try { try {
fs::permissions(f, opts); fs::permissions(f, opts);
return false; return false;
Show All 9 Lines#endif
}; };
scoped_test_env env; scoped_test_env env;
const path dne = env.make_env_path("dne"); const path dne = env.make_env_path("dne");
const path dne_sym = env.create_symlink(dne, "dne_sym"); const path dne_sym = env.create_symlink(dne, "dne_sym");
{ // !exists { // !exists
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::permissions(dne, fs::perms{}, ec); fs::permissions(dne, fs::perms{}, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
TEST_CHECK(checkThrow(dne, fs::perms{}, ec)); assert(checkThrow(dne, fs::perms{}, ec));
} }
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::permissions(dne_sym, fs::perms{}, ec); fs::permissions(dne_sym, fs::perms{}, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
TEST_CHECK(checkThrow(dne_sym, fs::perms{}, ec)); assert(checkThrow(dne_sym, fs::perms{}, ec));
} }
} }
TEST_CASE(basic_permissions_test) static void basic_permissions_test()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file1", 42); const path file = env.create_file("file1", 42);
const path dir = env.create_dir("dir1"); const path dir = env.create_dir("dir1");
const path file_for_sym = env.create_file("file2", 42); const path file_for_sym = env.create_file("file2", 42);
const path sym = env.create_symlink(file_for_sym, "sym"); const path sym = env.create_symlink(file_for_sym, "sym");
const perm_options AP = perm_options::add; const perm_options AP = perm_options::add;
const perm_options RP = perm_options::remove; const perm_options RP = perm_options::remove;
Show All 23 Lines struct TestCase {
{sym, perms::group_all, perms::owner_all | perms::group_all, AP}, {sym, perms::group_all, perms::owner_all | perms::group_all, AP},
{sym, perms::group_all, perms::owner_all, RP}, {sym, perms::group_all, perms::owner_all, RP},
// test non-symlink with symlink_nofollow. The last test on file/dir // test non-symlink with symlink_nofollow. The last test on file/dir
// will have set their permissions to perms::owner_all // will have set their permissions to perms::owner_all
{file, perms::group_all, perms::owner_all | perms::group_all, AP | NF}, {file, perms::group_all, perms::owner_all | perms::group_all, AP | NF},
{dir, perms::group_all, perms::owner_all | perms::group_all, AP | NF} {dir, perms::group_all, perms::owner_all | perms::group_all, AP | NF}
}; };
for (auto const& TC : cases) { for (auto const& TC : cases) {
TEST_CHECK(status(TC.p).permissions() != TC.expected); assert(status(TC.p).permissions() != TC.expected);
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
permissions(TC.p, TC.set_perms, TC.opts, ec); permissions(TC.p, TC.set_perms, TC.opts, ec);
TEST_CHECK(!ec); assert(!ec);
auto pp = status(TC.p).permissions(); auto pp = status(TC.p).permissions();
TEST_CHECK(pp == NormalizeExpectedPerms(TC.expected)); assert(pp == NormalizeExpectedPerms(TC.expected));
} }
if (TC.opts == perm_options::replace) { if (TC.opts == perm_options::replace) {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
permissions(TC.p, TC.set_perms, ec); permissions(TC.p, TC.set_perms, ec);
TEST_CHECK(!ec); assert(!ec);
auto pp = status(TC.p).permissions(); auto pp = status(TC.p).permissions();
TEST_CHECK(pp == NormalizeExpectedPerms(TC.expected)); assert(pp == NormalizeExpectedPerms(TC.expected));
} }
} }
} }
#ifndef _WIN32 #ifndef _WIN32
// This test isn't currently meaningful on Windows; the Windows file // This test isn't currently meaningful on Windows; the Windows file
// permissions visible via std::filesystem doesn't show any difference // permissions visible via std::filesystem doesn't show any difference
// between owner/group/others. // between owner/group/others.
TEST_CASE(test_no_resolve_symlink_on_symlink) static void test_no_resolve_symlink_on_symlink()
{ {
scoped_test_env env; scoped_test_env env;
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path sym = env.create_symlink(file, "sym"); const path sym = env.create_symlink(file, "sym");
const auto file_perms = status(file).permissions(); const auto file_perms = status(file).permissions();
struct TestCase { struct TestCase {
perms set_perms; perms set_perms;
Show All 18 Lines#else
// be 'operation_not_supported' and the symlink permissions should be // be 'operation_not_supported' and the symlink permissions should be
// unchanged. // unchanged.
const auto expected_link_perms = symlink_status(sym).permissions(); const auto expected_link_perms = symlink_status(sym).permissions();
std::error_code expected_ec = std::make_error_code(std::errc::operation_not_supported); std::error_code expected_ec = std::make_error_code(std::errc::operation_not_supported);
#endif #endif
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
permissions(sym, TC.set_perms, TC.opts | perm_options::nofollow, ec); permissions(sym, TC.set_perms, TC.opts | perm_options::nofollow, ec);
if (expected_ec) if (expected_ec)
TEST_CHECK(ErrorIs(ec, static_cast<std::errc>(expected_ec.value()))); assert(ErrorIs(ec, static_cast<std::errc>(expected_ec.value())));
else else
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(status(file).permissions() == file_perms); assert(status(file).permissions() == file_perms);
TEST_CHECK(symlink_status(sym).permissions() == expected_link_perms); assert(symlink_status(sym).permissions() == expected_link_perms);
} }
} }
#endif #endif // _WIN32
TEST_SUITE_END() int main(int, char**) {
test_signatures();
test_error_reporting();
basic_permissions_test();
#ifndef _WIN32
test_no_resolve_symlink_on_symlink();
#endif
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.pass.cpp

Show All 14 Lines
// path proximate(const path& p, const path& base, error_code& ec); // path proximate(const path& p, const path& base, error_code& ec);
#include "filesystem_include.h" #include "filesystem_include.h"
#include <cassert> #include <cassert>
#include <cstdio> #include <cstdio>
#include "test_macros.h" #include "test_macros.h"
#include "count_new.h" #include "count_new.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
static int count_path_elems(const fs::path& p) { static int count_path_elems(const fs::path& p) {
int count = 0; int count = 0;
for (auto&& elem : p) { for (auto&& elem : p) {
if (elem != p.root_name() && elem != "/" && elem != "") if (elem != p.root_name() && elem != "/" && elem != "")
++count; ++count;
} }
return count; return count;
} }
TEST_SUITE(filesystem_proximate_path_test_suite)
static void signature_test()
TEST_CASE(signature_test)
{ {
using fs::path; using fs::path;
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(proximate(p)); ASSERT_NOT_NOEXCEPT(proximate(p));
ASSERT_NOT_NOEXCEPT(proximate(p, p)); ASSERT_NOT_NOEXCEPT(proximate(p, p));
ASSERT_NOT_NOEXCEPT(proximate(p, ec)); ASSERT_NOT_NOEXCEPT(proximate(p, ec));
ASSERT_NOT_NOEXCEPT(proximate(p, p, ec)); ASSERT_NOT_NOEXCEPT(proximate(p, p, ec));
} }
TEST_CASE(basic_test) { static void basic_test() {
using fs::path; using fs::path;
const path cwd = fs::current_path(); const path cwd = fs::current_path();
const path parent_cwd = cwd.parent_path(); const path parent_cwd = cwd.parent_path();
const path curdir = cwd.filename(); const path curdir = cwd.filename();
TEST_REQUIRE(!cwd.native().empty()); assert(!cwd.native().empty());
int cwd_depth = count_path_elems(cwd); int cwd_depth = count_path_elems(cwd);
path dot_dot_to_root; path dot_dot_to_root;
for (int i=0; i < cwd_depth; ++i) for (int i=0; i < cwd_depth; ++i)
dot_dot_to_root /= ".."; dot_dot_to_root /= "..";
path relative_cwd = cwd.native().substr(cwd.root_path().native().size()); path relative_cwd = cwd.native().substr(cwd.root_path().native().size());
// clang-format off // clang-format off
struct { struct {
fs::path input; fs::path input;
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines#endif
for (auto& TC : TestCases) { for (auto& TC : TestCases) {
++ID; ++ID;
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
fs::path p = TC.input; fs::path p = TC.input;
const fs::path output = fs::proximate(p, TC.base, ec); const fs::path output = fs::proximate(p, TC.base, ec);
fs::path expect = TC.expect; fs::path expect = TC.expect;
expect.make_preferred(); expect.make_preferred();
if (ec) { if (ec) {
TEST_CHECK(!ec); assert(!ec);
std::fprintf(stderr, "TEST CASE #%d FAILED:\n" std::fprintf(stderr, "TEST CASE #%d FAILED:\n"
" Input: '%s'\n" " Input: '%s'\n"
" Base: '%s'\n" " Base: '%s'\n"
" Expected: '%s'\n", " Expected: '%s'\n",
ID, TC.input.string().c_str(), TC.base.string().c_str(), ID, TC.input.string().c_str(), TC.base.string().c_str(),
expect.string().c_str()); expect.string().c_str());
} else if (!PathEq(output, expect)) { } else if (!PathEq(output, expect)) {
TEST_CHECK(PathEq(output, expect)); assert(PathEq(output, expect));
const path canon_input = fs::weakly_canonical(TC.input); const path canon_input = fs::weakly_canonical(TC.input);
const path canon_base = fs::weakly_canonical(TC.base); const path canon_base = fs::weakly_canonical(TC.base);
const path lexically_p = canon_input.lexically_proximate(canon_base); const path lexically_p = canon_input.lexically_proximate(canon_base);
std::fprintf(stderr, "TEST CASE #%d FAILED:\n" std::fprintf(stderr, "TEST CASE #%d FAILED:\n"
" Input: '%s'\n" " Input: '%s'\n"
" Base: '%s'\n" " Base: '%s'\n"
" Expected: '%s'\n" " Expected: '%s'\n"
" Output: '%s'\n" " Output: '%s'\n"
" Lex Prox: '%s'\n" " Lex Prox: '%s'\n"
" Canon Input: '%s'\n" " Canon Input: '%s'\n"
" Canon Base: '%s'\n", " Canon Base: '%s'\n",
ID, TC.input.string().c_str(), TC.base.string().c_str(), ID, TC.input.string().c_str(), TC.base.string().c_str(),
expect.string().c_str(), output.string().c_str(), expect.string().c_str(), output.string().c_str(),
lexically_p.string().c_str(), canon_input.string().c_str(), lexically_p.string().c_str(), canon_input.string().c_str(),
canon_base.string().c_str()); canon_base.string().c_str());
} }
} }
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
basic_test();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.read_symlink/read_symlink.pass.cpp

Show All 10 Lines
// <filesystem> // <filesystem>
// path read_symlink(const path& p); // path read_symlink(const path& p);
// path read_symlink(const path& p, error_code& ec); // path read_symlink(const path& p, error_code& ec);
#include "filesystem_include.h" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_read_symlink_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(fs::read_symlink(p)), fs::path); ASSERT_SAME_TYPE(decltype(fs::read_symlink(p)), fs::path);
ASSERT_SAME_TYPE(decltype(fs::read_symlink(p, ec)), fs::path); ASSERT_SAME_TYPE(decltype(fs::read_symlink(p, ec)), fs::path);
ASSERT_NOT_NOEXCEPT(fs::read_symlink(p)); ASSERT_NOT_NOEXCEPT(fs::read_symlink(p));
// Not noexcept because of narrow contract // Not noexcept because of narrow contract
ASSERT_NOT_NOEXCEPT(fs::read_symlink(p, ec)); ASSERT_NOT_NOEXCEPT(fs::read_symlink(p, ec));
} }
TEST_CASE(test_error_reporting) static void test_error_reporting()
{ {
auto checkThrow = [](path const& f, const std::error_code& ec) auto checkThrow = [](path const& f, const std::error_code& ec)
{ {
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try { try {
(void)fs::read_symlink(f); (void)fs::read_symlink(f);
return false; return false;
} catch (filesystem_error const& err) { } catch (filesystem_error const& err) {
Show All 11 Lines#endif
const path cases[] = { const path cases[] = {
env.make_env_path("dne"), env.make_env_path("dne"),
env.create_file("file", 42), env.create_file("file", 42),
env.create_dir("dir") env.create_dir("dir")
}; };
for (path const& p : cases) { for (path const& p : cases) {
std::error_code ec; std::error_code ec;
const path ret = fs::read_symlink(p, ec); const path ret = fs::read_symlink(p, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(ret == path{}); assert(ret == path{});
TEST_CHECK(checkThrow(p, ec)); assert(checkThrow(p, ec));
} }
} }
TEST_CASE(basic_symlink_test) static void basic_symlink_test()
{ {
scoped_test_env env; scoped_test_env env;
const path dne = env.make_env_path("dne"); const path dne = env.make_env_path("dne");
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path link = env.create_symlink(dne, "link"); const path link = env.create_symlink(dne, "link");
const path nested_link = env.make_env_path("nested_link"); const path nested_link = env.make_env_path("nested_link");
create_symlink(link, nested_link); create_symlink(link, nested_link);
struct TestCase { struct TestCase {
path symlink; path symlink;
path expected; path expected;
} testCases[] = { } testCases[] = {
{env.create_symlink(dne, "dne_link"), dne}, {env.create_symlink(dne, "dne_link"), dne},
{env.create_symlink(file, "file_link"), file}, {env.create_symlink(file, "file_link"), file},
{env.create_directory_symlink(dir, "dir_link"), dir}, {env.create_directory_symlink(dir, "dir_link"), dir},
{nested_link, link} {nested_link, link}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
std::error_code ec = std::make_error_code(std::errc::address_in_use); std::error_code ec = std::make_error_code(std::errc::address_in_use);
const path ret = read_symlink(TC.symlink, ec); const path ret = read_symlink(TC.symlink, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(ret == TC.expected); assert(ret == TC.expected);
} }
} }
TEST_SUITE_END() int main(int, char**) {
test_signatures();
test_error_reporting();
basic_symlink_test();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.pass.cpp

Show All 16 Lines
#include "filesystem_include.h" #include "filesystem_include.h"
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "count_new.h" #include "count_new.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
TEST_SUITE(filesystem_proximate_path_test_suite) static void test_signature_0() {
TEST_CASE(test_signature_0) {
fs::path p(""); fs::path p("");
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(fs::current_path())); assert(output == fs::path::string_type(fs::current_path()));
} }
TEST_CASE(test_signature_1) { static void test_signature_1() {
fs::path p("."); fs::path p(".");
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(fs::current_path())); assert(output == fs::path::string_type(fs::current_path()));
} }
TEST_CASE(test_signature_2) { static void test_signature_2() {
static_test_env static_env; static_test_env static_env;
fs::path p(static_env.File); fs::path p(static_env.File);
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(static_env.File)); assert(output == fs::path::string_type(static_env.File));
} }
TEST_CASE(test_signature_3) { static void test_signature_3() {
static_test_env static_env; static_test_env static_env;
fs::path p(static_env.Dir); fs::path p(static_env.Dir);
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(static_env.Dir)); assert(output == fs::path::string_type(static_env.Dir));
} }
TEST_CASE(test_signature_4) { static void test_signature_4() {
static_test_env static_env; static_test_env static_env;
fs::path p(static_env.SymlinkToDir); fs::path p(static_env.SymlinkToDir);
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(static_env.Dir)); assert(output == fs::path::string_type(static_env.Dir));
} }
TEST_CASE(test_signature_5) { static void test_signature_5() {
static_test_env static_env; static_test_env static_env;
fs::path p(static_env.SymlinkToDir / "dir2/."); fs::path p(static_env.SymlinkToDir / "dir2/.");
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(static_env.Dir / "dir2")); assert(output == fs::path::string_type(static_env.Dir / "dir2"));
} }
TEST_CASE(test_signature_6) { static void test_signature_6() {
static_test_env static_env; static_test_env static_env;
// FIXME? If the trailing separator occurs in a part of the path that exists, // FIXME? If the trailing separator occurs in a part of the path that exists,
// it is omitted. Otherwise it is added to the end of the result. // it is omitted. Otherwise it is added to the end of the result.
fs::path p(static_env.SymlinkToDir / "dir2/./"); fs::path p(static_env.SymlinkToDir / "dir2/./");
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(static_env.Dir / "dir2")); assert(output == fs::path::string_type(static_env.Dir / "dir2"));
} }
TEST_CASE(test_signature_7) { static void test_signature_7() {
static_test_env static_env; static_test_env static_env;
fs::path p(static_env.SymlinkToDir / "dir2/DNE/./"); fs::path p(static_env.SymlinkToDir / "dir2/DNE/./");
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(static_env.Dir / "dir2/DNE/")); assert(output == fs::path::string_type(static_env.Dir / "dir2/DNE/"));
} }
TEST_CASE(test_signature_8) { static void test_signature_8() {
static_test_env static_env; static_test_env static_env;
fs::path p(static_env.SymlinkToDir / "dir2"); fs::path p(static_env.SymlinkToDir / "dir2");
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(static_env.Dir2)); assert(output == fs::path::string_type(static_env.Dir2));
} }
TEST_CASE(test_signature_9) { static void test_signature_9() {
static_test_env static_env; static_test_env static_env;
fs::path p(static_env.SymlinkToDir / "dir2/../dir2/DNE/.."); fs::path p(static_env.SymlinkToDir / "dir2/../dir2/DNE/..");
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
// weakly_canonical has a quirk - if the path is considered to exist, // weakly_canonical has a quirk - if the path is considered to exist,
// it's returned without a trailing slash, otherwise it's returned with // it's returned without a trailing slash, otherwise it's returned with
// one (see a note in fs.op.weakly_canonical/weakly_canonical.pass.cpp). // one (see a note in fs.op.weakly_canonical/weakly_canonical.pass.cpp).
// On Windows, a path like existent/nonexistentsubdir/.. is considered // On Windows, a path like existent/nonexistentsubdir/.. is considered
// to exist, on posix it's considered to not exist. Therefore, the // to exist, on posix it's considered to not exist. Therefore, the
// result here differs in the trailing slash. // result here differs in the trailing slash.
#ifdef _WIN32 #ifdef _WIN32
TEST_CHECK(output == fs::path::string_type(static_env.Dir2)); assert(output == fs::path::string_type(static_env.Dir2));
#else #else
TEST_CHECK(output == fs::path::string_type(static_env.Dir2 / "")); assert(output == fs::path::string_type(static_env.Dir2 / ""));
#endif #endif
} }
TEST_CASE(test_signature_10) { static void test_signature_10() {
static_test_env static_env; static_test_env static_env;
fs::path p(static_env.SymlinkToDir / "dir2/dir3/../DNE/DNE2"); fs::path p(static_env.SymlinkToDir / "dir2/dir3/../DNE/DNE2");
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(static_env.Dir2 / "DNE/DNE2")); assert(output == fs::path::string_type(static_env.Dir2 / "DNE/DNE2"));
} }
TEST_CASE(test_signature_11) { static void test_signature_11() {
static_test_env static_env; static_test_env static_env;
fs::path p(static_env.Dir / "../dir1"); fs::path p(static_env.Dir / "../dir1");
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(static_env.Dir)); assert(output == fs::path::string_type(static_env.Dir));
} }
TEST_CASE(test_signature_12) { static void test_signature_12() {
static_test_env static_env; static_test_env static_env;
fs::path p(static_env.Dir / "./."); fs::path p(static_env.Dir / "./.");
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(static_env.Dir)); assert(output == fs::path::string_type(static_env.Dir));
} }
TEST_CASE(test_signature_13) { static void test_signature_13() {
static_test_env static_env; static_test_env static_env;
fs::path p(static_env.Dir / "DNE/../foo"); fs::path p(static_env.Dir / "DNE/../foo");
const fs::path output = fs::weakly_canonical(p); const fs::path output = fs::weakly_canonical(p);
TEST_CHECK(output == fs::path::string_type(static_env.Dir / "foo")); assert(output == fs::path::string_type(static_env.Dir / "foo"));
} }
TEST_SUITE_END() int main(int, char**) {
test_signature_0();
test_signature_1();
test_signature_2();
test_signature_3();
test_signature_4();
test_signature_5();
test_signature_6();
test_signature_7();
test_signature_8();
test_signature_9();
test_signature_10();
test_signature_11();
test_signature_12();
test_signature_13();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove/remove.pass.cpp

Show All 10 Lines
// <filesystem> // <filesystem>
// bool remove(const path& p); // bool remove(const path& p);
// bool remove(const path& p, error_code& ec) noexcept; // bool remove(const path& p, error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_remove_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(fs::remove(p)), bool); ASSERT_SAME_TYPE(decltype(fs::remove(p)), bool);
ASSERT_SAME_TYPE(decltype(fs::remove(p, ec)), bool); ASSERT_SAME_TYPE(decltype(fs::remove(p, ec)), bool);
ASSERT_NOT_NOEXCEPT(fs::remove(p)); ASSERT_NOT_NOEXCEPT(fs::remove(p));
ASSERT_NOEXCEPT(fs::remove(p, ec)); ASSERT_NOEXCEPT(fs::remove(p, ec));
} }
TEST_CASE(test_error_reporting) static void test_error_reporting()
{ {
auto checkThrow = [](path const& f, const std::error_code& ec) auto checkThrow = [](path const& f, const std::error_code& ec)
{ {
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try { try {
fs::remove(f); fs::remove(f);
return false; return false;
} catch (filesystem_error const& err) { } catch (filesystem_error const& err) {
Show All 20 Lines#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
// GetWindowsInaccessibleDir() doesn't cause fs::remove() to report // GetWindowsInaccessibleDir() doesn't cause fs::remove() to report
// errors, it just returns false cleanly. // errors, it just returns false cleanly.
file_in_bad_dir, file_in_bad_dir,
#endif #endif
}; };
for (auto& p : testCases) { for (auto& p : testCases) {
std::error_code ec; std::error_code ec;
TEST_CHECK(!fs::remove(p, ec)); assert(!fs::remove(p, ec));
TEST_CHECK(ec); assert(ec);
TEST_CHECK(checkThrow(p, ec)); assert(checkThrow(p, ec));
} }
// PR#35780 // PR#35780
const path testCasesNonexistant[] = { const path testCasesNonexistant[] = {
"", "",
env.make_env_path("dne") env.make_env_path("dne")
}; };
for (auto& p : testCasesNonexistant) { for (auto& p : testCasesNonexistant) {
std::error_code ec; std::error_code ec;
TEST_CHECK(!fs::remove(p, ec)); assert(!fs::remove(p, ec));
TEST_CHECK(!ec); assert(!ec);
} }
} }
TEST_CASE(basic_remove_test) static void basic_remove_test()
{ {
scoped_test_env env; scoped_test_env env;
const path dne = env.make_env_path("dne"); const path dne = env.make_env_path("dne");
const path link = env.create_symlink(dne, "link"); const path link = env.create_symlink(dne, "link");
const path nested_link = env.make_env_path("nested_link"); const path nested_link = env.make_env_path("nested_link");
create_symlink(link, nested_link); create_symlink(link, nested_link);
const path testCases[] = { const path testCases[] = {
env.create_file("file", 42), env.create_file("file", 42),
env.create_dir("empty_dir"), env.create_dir("empty_dir"),
nested_link, nested_link,
link link
}; };
for (auto& p : testCases) { for (auto& p : testCases) {
std::error_code ec = std::make_error_code(std::errc::address_in_use); std::error_code ec = std::make_error_code(std::errc::address_in_use);
TEST_CHECK(remove(p, ec)); assert(remove(p, ec));
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(!exists(symlink_status(p))); assert(!exists(symlink_status(p)));
} }
} }
TEST_SUITE_END() int main(int, char**) {
test_signatures();
test_error_reporting();
basic_remove_test();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove_all/remove_all.pass.cpp

Show All 12 Lines
// <filesystem> // <filesystem>
// uintmax_t remove_all(const path& p); // uintmax_t remove_all(const path& p);
// uintmax_t remove_all(const path& p, error_code& ec) noexcept; // uintmax_t remove_all(const path& p, error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_remove_all_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(fs::remove_all(p)), std::uintmax_t); ASSERT_SAME_TYPE(decltype(fs::remove_all(p)), std::uintmax_t);
ASSERT_SAME_TYPE(decltype(fs::remove_all(p, ec)), std::uintmax_t); ASSERT_SAME_TYPE(decltype(fs::remove_all(p, ec)), std::uintmax_t);
ASSERT_NOT_NOEXCEPT(fs::remove_all(p)); ASSERT_NOT_NOEXCEPT(fs::remove_all(p));
ASSERT_NOT_NOEXCEPT(fs::remove_all(p, ec)); ASSERT_NOT_NOEXCEPT(fs::remove_all(p, ec));
} }
TEST_CASE(test_error_reporting) static void test_error_reporting()
{ {
scoped_test_env env; scoped_test_env env;
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. // reading directories.
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
auto checkThrow = [](path const& f, const std::error_code& ec) auto checkThrow = [](path const& f, const std::error_code& ec)
{ {
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
Show All 20 Lines#endif
const path testCases[] = { const path testCases[] = {
file_in_bad_dir file_in_bad_dir
}; };
const auto BadRet = static_cast<std::uintmax_t>(-1); const auto BadRet = static_cast<std::uintmax_t>(-1);
for (auto& p : testCases) { for (auto& p : testCases) {
std::error_code ec; std::error_code ec;
TEST_CHECK(fs::remove_all(p, ec) == BadRet); assert(fs::remove_all(p, ec) == BadRet);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(checkThrow(p, ec)); assert(checkThrow(p, ec));
} }
#endif #endif
// PR#35780 // PR#35780
const path testCasesNonexistant[] = { const path testCasesNonexistant[] = {
"", "",
env.make_env_path("dne") env.make_env_path("dne")
}; };
for (auto &p : testCasesNonexistant) { for (auto &p : testCasesNonexistant) {
std::error_code ec; std::error_code ec;
TEST_CHECK(fs::remove_all(p, ec) == 0); assert(fs::remove_all(p, ec) == 0);
TEST_CHECK(!ec); assert(!ec);
} }
} }
TEST_CASE(basic_remove_all_test) static void basic_remove_all_test()
{ {
scoped_test_env env; scoped_test_env env;
const path dne = env.make_env_path("dne"); const path dne = env.make_env_path("dne");
const path link = env.create_symlink(dne, "link"); const path link = env.create_symlink(dne, "link");
const path nested_link = env.make_env_path("nested_link"); const path nested_link = env.make_env_path("nested_link");
create_symlink(link, nested_link); create_symlink(link, nested_link);
const path testCases[] = { const path testCases[] = {
env.create_file("file", 42), env.create_file("file", 42),
env.create_dir("empty_dir"), env.create_dir("empty_dir"),
nested_link, nested_link,
link link
}; };
for (auto& p : testCases) { for (auto& p : testCases) {
std::error_code ec = std::make_error_code(std::errc::address_in_use); std::error_code ec = std::make_error_code(std::errc::address_in_use);
TEST_CHECK(remove(p, ec)); assert(remove(p, ec));
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(!exists(symlink_status(p))); assert(!exists(symlink_status(p)));
} }
} }
TEST_CASE(symlink_to_dir) static void symlink_to_dir()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file(dir / "file", 42); const path file = env.create_file(dir / "file", 42);
const path link = env.create_directory_symlink(dir, "sym"); const path link = env.create_directory_symlink(dir, "sym");
{ {
std::error_code ec = std::make_error_code(std::errc::address_in_use); std::error_code ec = std::make_error_code(std::errc::address_in_use);
TEST_CHECK(remove_all(link, ec) == 1); assert(remove_all(link, ec) == 1);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(!exists(symlink_status(link))); assert(!exists(symlink_status(link)));
TEST_CHECK(exists(dir)); assert(exists(dir));
TEST_CHECK(exists(file)); assert(exists(file));
} }
} }
TEST_CASE(nested_dir) static void nested_dir()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path dir1 = env.create_dir(dir / "dir1"); const path dir1 = env.create_dir(dir / "dir1");
const path out_of_dir_file = env.create_file("file1", 42); const path out_of_dir_file = env.create_file("file1", 42);
const path all_files[] = { const path all_files[] = {
dir, dir1, dir, dir1,
env.create_file(dir / "file1", 42), env.create_file(dir / "file1", 42),
env.create_symlink(out_of_dir_file, dir / "sym1"), env.create_symlink(out_of_dir_file, dir / "sym1"),
env.create_file(dir1 / "file2", 42), env.create_file(dir1 / "file2", 42),
env.create_directory_symlink(dir, dir1 / "sym2") env.create_directory_symlink(dir, dir1 / "sym2")
}; };
const std::size_t expected_count = sizeof(all_files) / sizeof(all_files[0]); const std::size_t expected_count = sizeof(all_files) / sizeof(all_files[0]);
std::error_code ec = std::make_error_code(std::errc::address_in_use); std::error_code ec = std::make_error_code(std::errc::address_in_use);
TEST_CHECK(remove_all(dir, ec) == expected_count); assert(remove_all(dir, ec) == expected_count);
TEST_CHECK(!ec); assert(!ec);
for (auto const& p : all_files) { for (auto const& p : all_files) {
TEST_CHECK(!exists(symlink_status(p))); assert(!exists(symlink_status(p)));
} }
TEST_CHECK(exists(out_of_dir_file)); assert(exists(out_of_dir_file));
} }
TEST_SUITE_END() int main(int, char**) {
test_signatures();
test_error_reporting();
basic_remove_all_test();
symlink_to_dir();
nested_dir();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.rename/rename.pass.cpp

Show All 10 Lines
// <filesystem> // <filesystem>
// void rename(const path& old_p, const path& new_p); // void rename(const path& old_p, const path& new_p);
// void rename(const path& old_p, const path& new_p, error_code& ec) noexcept; // void rename(const path& old_p, const path& new_p, error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_rename_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(fs::rename(p, p)), void); ASSERT_SAME_TYPE(decltype(fs::rename(p, p)), void);
ASSERT_SAME_TYPE(decltype(fs::rename(p, p, ec)), void); ASSERT_SAME_TYPE(decltype(fs::rename(p, p, ec)), void);
ASSERT_NOT_NOEXCEPT(fs::rename(p, p)); ASSERT_NOT_NOEXCEPT(fs::rename(p, p));
ASSERT_NOEXCEPT(fs::rename(p, p, ec)); ASSERT_NOEXCEPT(fs::rename(p, p, ec));
} }
TEST_CASE(test_error_reporting) static void test_error_reporting()
{ {
auto checkThrow = [](path const& f, path const& t, const std::error_code& ec) auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
{ {
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try { try {
fs::rename(f, t); fs::rename(f, t);
return false; return false;
} catch (filesystem_error const& err) { } catch (filesystem_error const& err) {
Show All 24 Lines#ifndef _WIN32
{dir, file}, {dir, file},
#endif #endif
}; };
for (auto& TC : cases) { for (auto& TC : cases) {
auto from_before = status(TC.from); auto from_before = status(TC.from);
auto to_before = status(TC.to); auto to_before = status(TC.to);
std::error_code ec; std::error_code ec;
rename(TC.from, TC.to, ec); rename(TC.from, TC.to, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(from_before.type() == status(TC.from).type()); assert(from_before.type() == status(TC.from).type());
TEST_CHECK(to_before.type() == status(TC.to).type()); assert(to_before.type() == status(TC.to).type());
TEST_CHECK(checkThrow(TC.from, TC.to, ec)); assert(checkThrow(TC.from, TC.to, ec));
} }
} }
TEST_CASE(basic_rename_test) static void basic_rename_test()
{ {
scoped_test_env env; scoped_test_env env;
const std::error_code set_ec = std::make_error_code(std::errc::address_in_use); const std::error_code set_ec = std::make_error_code(std::errc::address_in_use);
const path file = env.create_file("file1", 42); const path file = env.create_file("file1", 42);
{ // same file { // same file
std::error_code ec = set_ec; std::error_code ec = set_ec;
rename(file, file, ec); rename(file, file, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(is_regular_file(file)); assert(is_regular_file(file));
TEST_CHECK(file_size(file) == 42); assert(file_size(file) == 42);
} }
const path sym = env.create_symlink(file, "sym"); const path sym = env.create_symlink(file, "sym");
{ // file -> symlink { // file -> symlink
std::error_code ec = set_ec; std::error_code ec = set_ec;
rename(file, sym, ec); rename(file, sym, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(!exists(file)); assert(!exists(file));
TEST_CHECK(is_regular_file(symlink_status(sym))); assert(is_regular_file(symlink_status(sym)));
TEST_CHECK(file_size(sym) == 42); assert(file_size(sym) == 42);
} }
const path file2 = env.create_file("file2", 42); const path file2 = env.create_file("file2", 42);
const path file3 = env.create_file("file3", 100); const path file3 = env.create_file("file3", 100);
{ // file -> file { // file -> file
std::error_code ec = set_ec; std::error_code ec = set_ec;
rename(file2, file3, ec); rename(file2, file3, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(!exists(file2)); assert(!exists(file2));
TEST_CHECK(is_regular_file(file3)); assert(is_regular_file(file3));
TEST_CHECK(file_size(file3) == 42); assert(file_size(file3) == 42);
} }
const path dne = env.make_env_path("dne"); const path dne = env.make_env_path("dne");
const path bad_sym = env.create_symlink(dne, "bad_sym"); const path bad_sym = env.create_symlink(dne, "bad_sym");
const path bad_sym_dest = env.make_env_path("bad_sym2"); const path bad_sym_dest = env.make_env_path("bad_sym2");
{ // bad-symlink { // bad-symlink
std::error_code ec = set_ec; std::error_code ec = set_ec;
rename(bad_sym, bad_sym_dest, ec); rename(bad_sym, bad_sym_dest, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(!exists(symlink_status(bad_sym))); assert(!exists(symlink_status(bad_sym)));
TEST_CHECK(is_symlink(bad_sym_dest)); assert(is_symlink(bad_sym_dest));
TEST_CHECK(read_symlink(bad_sym_dest) == dne); assert(read_symlink(bad_sym_dest) == dne);
} }
} }
TEST_CASE(basic_rename_dir_test) static void basic_rename_dir_test()
{ {
static_test_env env; static_test_env env;
const std::error_code set_ec = std::make_error_code(std::errc::address_in_use); const std::error_code set_ec = std::make_error_code(std::errc::address_in_use);
const path new_dir = env.makePath("new_dir"); const path new_dir = env.makePath("new_dir");
{ // dir -> dir (with contents) { // dir -> dir (with contents)
std::error_code ec = set_ec; std::error_code ec = set_ec;
rename(env.Dir, new_dir, ec); rename(env.Dir, new_dir, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(!exists(env.Dir)); assert(!exists(env.Dir));
TEST_CHECK(is_directory(new_dir)); assert(is_directory(new_dir));
TEST_CHECK(exists(new_dir / "file1")); assert(exists(new_dir / "file1"));
} }
#ifdef _WIN32 #ifdef _WIN32
// On Windows, renaming a directory over a file isn't an error (this // On Windows, renaming a directory over a file isn't an error (this
// case is skipped in test_error_reporting above). // case is skipped in test_error_reporting above).
{ // dir -> file { // dir -> file
std::error_code ec = set_ec; std::error_code ec = set_ec;
rename(new_dir, env.NonEmptyFile, ec); rename(new_dir, env.NonEmptyFile, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(!exists(new_dir)); assert(!exists(new_dir));
TEST_CHECK(is_directory(env.NonEmptyFile)); assert(is_directory(env.NonEmptyFile));
TEST_CHECK(exists(env.NonEmptyFile / "file1")); assert(exists(env.NonEmptyFile / "file1"));
} }
#endif #endif
} }
TEST_SUITE_END() int main(int, char**) {
test_signatures();
test_error_reporting();
basic_rename_test();
basic_rename_dir_test();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.resize_file/resize_file.pass.cpp

Show All 10 Lines
// <filesystem> // <filesystem>
// void resize_file(const path& p, uintmax_t new_size); // void resize_file(const path& p, uintmax_t new_size);
// void resize_file(const path& p, uintmax_t new_size, error_code& ec) noexcept; // void resize_file(const path& p, uintmax_t new_size, error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_resize_file_test_suite) static void test_signatures()
TEST_CASE(test_signatures)
{ {
const path p; ((void)p); const path p; ((void)p);
std::uintmax_t i; ((void)i); std::uintmax_t i; ((void)i);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(fs::resize_file(p, i)), void); ASSERT_SAME_TYPE(decltype(fs::resize_file(p, i)), void);
ASSERT_SAME_TYPE(decltype(fs::resize_file(p, i, ec)), void); ASSERT_SAME_TYPE(decltype(fs::resize_file(p, i, ec)), void);
ASSERT_NOT_NOEXCEPT(fs::resize_file(p, i)); ASSERT_NOT_NOEXCEPT(fs::resize_file(p, i));
ASSERT_NOEXCEPT(fs::resize_file(p, i, ec)); ASSERT_NOEXCEPT(fs::resize_file(p, i, ec));
} }
TEST_CASE(test_error_reporting) static void test_error_reporting()
{ {
auto checkThrow = [](path const& f, std::uintmax_t s, const std::error_code& ec) auto checkThrow = [](path const& f, std::uintmax_t s, const std::error_code& ec)
{ {
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try { try {
fs::resize_file(f, s); fs::resize_file(f, s);
return false; return false;
} catch (filesystem_error const& err) { } catch (filesystem_error const& err) {
Show All 11 Lines#endif
const path bad_sym = env.create_symlink(dne, "sym"); const path bad_sym = env.create_symlink(dne, "sym");
const path dir = env.create_dir("dir1"); const path dir = env.create_dir("dir1");
const path cases[] = { const path cases[] = {
dne, bad_sym, dir dne, bad_sym, dir
}; };
for (auto& p : cases) { for (auto& p : cases) {
std::error_code ec; std::error_code ec;
resize_file(p, 42, ec); resize_file(p, 42, ec);
TEST_REQUIRE(ec); assert(ec);
TEST_CHECK(checkThrow(p, 42, ec)); assert(checkThrow(p, 42, ec));
} }
} }
TEST_CASE(basic_resize_file_test) static void basic_resize_file_test()
{ {
scoped_test_env env; scoped_test_env env;
const path file1 = env.create_file("file1", 42); const path file1 = env.create_file("file1", 42);
const auto set_ec = std::make_error_code(std::errc::address_in_use); const auto set_ec = std::make_error_code(std::errc::address_in_use);
{ // grow file { // grow file
const std::uintmax_t new_s = 100; const std::uintmax_t new_s = 100;
std::error_code ec = set_ec; std::error_code ec = set_ec;
resize_file(file1, new_s, ec); resize_file(file1, new_s, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(file_size(file1) == new_s); assert(file_size(file1) == new_s);
} }
{ // shrink file { // shrink file
const std::uintmax_t new_s = 1; const std::uintmax_t new_s = 1;
std::error_code ec = set_ec; std::error_code ec = set_ec;
resize_file(file1, new_s, ec); resize_file(file1, new_s, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(file_size(file1) == new_s); assert(file_size(file1) == new_s);
} }
{ // shrink file to zero { // shrink file to zero
const std::uintmax_t new_s = 0; const std::uintmax_t new_s = 0;
std::error_code ec = set_ec; std::error_code ec = set_ec;
resize_file(file1, new_s, ec); resize_file(file1, new_s, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(file_size(file1) == new_s); assert(file_size(file1) == new_s);
} }
const path sym = env.create_symlink(file1, "sym"); const path sym = env.create_symlink(file1, "sym");
{ // grow file via symlink { // grow file via symlink
const std::uintmax_t new_s = 1024; const std::uintmax_t new_s = 1024;
std::error_code ec = set_ec; std::error_code ec = set_ec;
resize_file(sym, new_s, ec); resize_file(sym, new_s, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(file_size(file1) == new_s); assert(file_size(file1) == new_s);
} }
} }
TEST_SUITE_END() int main(int, char**) {
test_signatures();
test_error_reporting();
basic_resize_file_test();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.space/space.pass.cpp

Show All 10 Lines
// <filesystem> // <filesystem>
// space_info space(const path& p); // space_info space(const path& p);
// space_info space(const path& p, error_code& ec) noexcept; // space_info space(const path& p, error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
bool EqualDelta(std::uintmax_t x, std::uintmax_t y, std::uintmax_t delta) { bool EqualDelta(std::uintmax_t x, std::uintmax_t y, std::uintmax_t delta) {
if (x >= y) { if (x >= y) {
return (x - y) <= delta; return (x - y) <= delta;
} else { } else {
return (y - x) <= delta; return (y - x) <= delta;
} }
} }
TEST_SUITE(filesystem_space_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_SAME_TYPE(decltype(space(p)), space_info); ASSERT_SAME_TYPE(decltype(space(p)), space_info);
ASSERT_SAME_TYPE(decltype(space(p, ec)), space_info); ASSERT_SAME_TYPE(decltype(space(p, ec)), space_info);
ASSERT_NOT_NOEXCEPT(space(p)); ASSERT_NOT_NOEXCEPT(space(p));
ASSERT_NOEXCEPT(space(p, ec)); ASSERT_NOEXCEPT(space(p, ec));
} }
TEST_CASE(test_error_reporting) static void test_error_reporting()
{ {
static_test_env static_env; static_test_env static_env;
auto checkThrow = [](path const& f, const std::error_code& ec) auto checkThrow = [](path const& f, const std::error_code& ec)
{ {
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
try { try {
(void)space(f); (void)space(f);
return false; return false;
Show All 11 Lines const path cases[] = {
"", "",
static_env.DNE, static_env.DNE,
static_env.BadSymlink static_env.BadSymlink
}; };
for (auto& p : cases) { for (auto& p : cases) {
const auto expect = static_cast<std::uintmax_t>(-1); const auto expect = static_cast<std::uintmax_t>(-1);
std::error_code ec; std::error_code ec;
space_info info = space(p, ec); space_info info = space(p, ec);
TEST_CHECK(ec); assert(ec);
TEST_CHECK(info.capacity == expect); assert(info.capacity == expect);
TEST_CHECK(info.free == expect); assert(info.free == expect);
TEST_CHECK(info.available == expect); assert(info.available == expect);
TEST_CHECK(checkThrow(p, ec)); assert(checkThrow(p, ec));
} }
} }
TEST_CASE(basic_space_test) static void basic_space_test()
{ {
static_test_env static_env; static_test_env static_env;
// All the test cases should reside on the same filesystem and therefore // All the test cases should reside on the same filesystem and therefore
// should have the same expected result. Compute this expected result // should have the same expected result. Compute this expected result
// one and check that it looks semi-sane. // one and check that it looks semi-sane.
const std::uintmax_t bad_value = static_cast<std::uintmax_t>(-1); const std::uintmax_t bad_value = static_cast<std::uintmax_t>(-1);
std::uintmax_t expect_capacity; std::uintmax_t expect_capacity;
std::uintmax_t expect_free; std::uintmax_t expect_free;
std::uintmax_t expect_avail; std::uintmax_t expect_avail;
TEST_REQUIRE(utils::space(static_env.Dir.string(), expect_capacity, assert(utils::space(static_env.Dir.string(), expect_capacity,
expect_free, expect_avail)); expect_free, expect_avail));
// Other processes running on the operating system may have changed // Other processes running on the operating system may have changed
// the amount of space available. Check that these are within tolerances. // the amount of space available. Check that these are within tolerances.
// Currently 5% of capacity // Currently 5% of capacity
const std::uintmax_t delta = expect_capacity / 20; const std::uintmax_t delta = expect_capacity / 20;
const path cases[] = { const path cases[] = {
static_env.File, static_env.File,
static_env.Dir, static_env.Dir,
static_env.Dir2, static_env.Dir2,
static_env.SymlinkToFile, static_env.SymlinkToFile,
static_env.SymlinkToDir static_env.SymlinkToDir
}; };
for (auto& p : cases) { for (auto& p : cases) {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
space_info info = space(p, ec); space_info info = space(p, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(info.capacity != bad_value); assert(info.capacity != bad_value);
TEST_CHECK(expect_capacity == info.capacity); assert(expect_capacity == info.capacity);
TEST_CHECK(info.free != bad_value); assert(info.free != bad_value);
TEST_CHECK(EqualDelta(expect_free, info.free, delta)); assert(EqualDelta(expect_free, info.free, delta));
TEST_CHECK(info.available != bad_value); assert(info.available != bad_value);
TEST_CHECK(EqualDelta(expect_avail, info.available, delta)); assert(EqualDelta(expect_avail, info.available, delta));
} }
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
test_error_reporting();
basic_space_test();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.status/status.pass.cpp

Show All 10 Lines
// <filesystem> // <filesystem>
// file_status status(const path& p); // file_status status(const path& p);
// file_status status(const path& p, error_code& ec) noexcept; // file_status status(const path& p, error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_status_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(status(p)); ASSERT_NOT_NOEXCEPT(status(p));
ASSERT_NOEXCEPT(status(p, ec)); ASSERT_NOEXCEPT(status(p, ec));
} }
TEST_CASE(test_status_not_found) static void test_status_not_found()
{ {
static_test_env static_env; static_test_env static_env;
const std::errc expect_errc = std::errc::no_such_file_or_directory; const std::errc expect_errc = std::errc::no_such_file_or_directory;
const path cases[] { const path cases[] {
static_env.DNE, static_env.DNE,
static_env.BadSymlink static_env.BadSymlink
}; };
for (auto& p : cases) { for (auto& p : cases) {
std::error_code ec = std::make_error_code(std::errc::address_in_use); std::error_code ec = std::make_error_code(std::errc::address_in_use);
// test non-throwing overload. // test non-throwing overload.
file_status st = status(p, ec); file_status st = status(p, ec);
TEST_CHECK(ErrorIs(ec, expect_errc)); assert(ErrorIs(ec, expect_errc));
TEST_CHECK(st.type() == file_type::not_found); assert(st.type() == file_type::not_found);
TEST_CHECK(st.permissions() == perms::unknown); assert(st.permissions() == perms::unknown);
// test throwing overload. It should not throw even though it reports // test throwing overload. It should not throw even though it reports
// that the file was not found. // that the file was not found.
TEST_CHECK_NO_THROW(st = status(p)); TEST_DOES_NOT_THROW(st = status(p));
TEST_CHECK(st.type() == file_type::not_found); assert(st.type() == file_type::not_found);
TEST_CHECK(st.permissions() == perms::unknown); assert(st.permissions() == perms::unknown);
} }
} }
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. Imaginary files under GetWindowsInaccessibleDir() // reading directories. Imaginary files under GetWindowsInaccessibleDir()
// produce no_such_file_or_directory, not the error codes this test checks // produce no_such_file_or_directory, not the error codes this test checks
// for. Finally, status() for a too long file name doesn't return errors // for. Finally, status() for a too long file name doesn't return errors
// on windows. // on windows.
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_CASE(test_status_cannot_resolve) static void test_status_cannot_resolve()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file = env.create_file("dir/file", 42); const path file = env.create_file("dir/file", 42);
const path sym = env.create_symlink("dir/file", "sym"); const path sym = env.create_symlink("dir/file", "sym");
permissions(dir, perms::none); permissions(dir, perms::none);
const std::errc set_errc = std::errc::address_in_use; const std::errc set_errc = std::errc::address_in_use;
const std::errc perm_errc = std::errc::permission_denied; const std::errc perm_errc = std::errc::permission_denied;
const std::errc name_too_long_errc = std::errc::filename_too_long; const std::errc name_too_long_errc = std::errc::filename_too_long;
struct TestCase { struct TestCase {
path p; path p;
std::errc expect_errc; std::errc expect_errc;
} const TestCases[] = { } const TestCases[] = {
{file, perm_errc}, {file, perm_errc},
{sym, perm_errc}, {sym, perm_errc},
{path(std::string(2500, 'a')), name_too_long_errc} {path(std::string(2500, 'a')), name_too_long_errc}
}; };
for (auto& TC : TestCases) for (auto& TC : TestCases)
{ {
{ // test non-throwing case { // test non-throwing case
std::error_code ec = std::make_error_code(set_errc); std::error_code ec = std::make_error_code(set_errc);
file_status st = status(TC.p, ec); file_status st = status(TC.p, ec);
TEST_CHECK(ErrorIs(ec, TC.expect_errc)); assert(ErrorIs(ec, TC.expect_errc));
TEST_CHECK(st.type() == file_type::none); assert(st.type() == file_type::none);
TEST_CHECK(st.permissions() == perms::unknown); assert(st.permissions() == perms::unknown);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
{ // test throwing case { // test throwing case
try { try {
status(TC.p); status(TC.p);
} catch (filesystem_error const& err) { } catch (filesystem_error const& err) {
TEST_CHECK(err.path1() == TC.p); assert(err.path1() == TC.p);
TEST_CHECK(err.path2() == ""); assert(err.path2() == "");
TEST_CHECK(ErrorIs(err.code(), TC.expect_errc)); assert(ErrorIs(err.code(), TC.expect_errc));
} }
} }
#endif #endif
} }
} }
#endif #endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_CASE(status_file_types_test) static void status_file_types_test()
{ {
static_test_env static_env; static_test_env static_env;
scoped_test_env env; scoped_test_env env;
struct TestCase { struct TestCase {
path p; path p;
file_type expect_type; file_type expect_type;
} cases[] = { } cases[] = {
{static_env.File, file_type::regular}, {static_env.File, file_type::regular},
Show All 10 Lines
#ifndef _WIN32 #ifndef _WIN32
{env.create_fifo("fifo"), file_type::fifo} {env.create_fifo("fifo"), file_type::fifo}
#endif #endif
}; };
for (const auto& TC : cases) { for (const auto& TC : cases) {
// test non-throwing case // test non-throwing case
std::error_code ec = std::make_error_code(std::errc::address_in_use); std::error_code ec = std::make_error_code(std::errc::address_in_use);
file_status st = status(TC.p, ec); file_status st = status(TC.p, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(st.type() == TC.expect_type); assert(st.type() == TC.expect_type);
TEST_CHECK(st.permissions() != perms::unknown); assert(st.permissions() != perms::unknown);
// test throwing case // test throwing case
TEST_REQUIRE_NO_THROW(st = status(TC.p)); TEST_DOES_NOT_THROW(st = status(TC.p));
TEST_CHECK(st.type() == TC.expect_type); assert(st.type() == TC.expect_type);
TEST_CHECK(st.permissions() != perms::unknown); assert(st.permissions() != perms::unknown);
} }
} }
TEST_CASE(test_block_file) static void test_block_file()
{ {
const path possible_paths[] = { const path possible_paths[] = {
"/dev/drive0", // Apple "/dev/drive0", // Apple
"/dev/sda", "/dev/sda",
"/dev/loop0" "/dev/loop0"
}; };
path p; path p;
for (const path& possible_p : possible_paths) { for (const path& possible_p : possible_paths) {
std::error_code ec; std::error_code ec;
if (exists(possible_p, ec)) { if (exists(possible_p, ec)) {
p = possible_p; p = possible_p;
break; break;
} }
} }
if (p == path{}) { if (p == path{}) {
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
} }
// test non-throwing case // test non-throwing case
std::error_code ec = std::make_error_code(std::errc::address_in_use); std::error_code ec = std::make_error_code(std::errc::address_in_use);
file_status st = status(p, ec); file_status st = status(p, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(st.type() == file_type::block); assert(st.type() == file_type::block);
TEST_CHECK(st.permissions() != perms::unknown); assert(st.permissions() != perms::unknown);
// test throwing case // test throwing case
TEST_REQUIRE_NO_THROW(st = status(p)); TEST_DOES_NOT_THROW(st = status(p));
TEST_CHECK(st.type() == file_type::block); assert(st.type() == file_type::block);
TEST_CHECK(st.permissions() != perms::unknown); assert(st.permissions() != perms::unknown);
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
test_status_not_found();
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
test_status_cannot_resolve();
#endif
status_file_types_test();
test_block_file();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.status_known/status_known.pass.cpp

Show All 11 Lines
// bool status_known(file_status s) noexcept; // bool status_known(file_status s) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(status_known_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
file_status s; ((void)s); file_status s; ((void)s);
ASSERT_SAME_TYPE(decltype(status_known(s)), bool); ASSERT_SAME_TYPE(decltype(status_known(s)), bool);
ASSERT_NOEXCEPT(status_known(s)); ASSERT_NOEXCEPT(status_known(s));
} }
TEST_CASE(status_known_test) static void status_known_test()
{ {
struct TestCase { struct TestCase {
file_type type; file_type type;
bool expect; bool expect;
}; };
const TestCase testCases[] = { const TestCase testCases[] = {
{file_type::none, false}, {file_type::none, false},
{file_type::not_found, true}, {file_type::not_found, true},
{file_type::regular, true}, {file_type::regular, true},
{file_type::directory, true}, {file_type::directory, true},
{file_type::symlink, true}, {file_type::symlink, true},
{file_type::block, true}, {file_type::block, true},
{file_type::character, true}, {file_type::character, true},
{file_type::fifo, true}, {file_type::fifo, true},
{file_type::socket, true}, {file_type::socket, true},
{file_type::unknown, true} {file_type::unknown, true}
}; };
for (auto& TC : testCases) { for (auto& TC : testCases) {
file_status s(TC.type); file_status s(TC.type);
TEST_CHECK(status_known(s) == TC.expect); assert(status_known(s) == TC.expect);
} }
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
status_known_test();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.symlink_status/symlink_status.pass.cpp

Show All 10 Lines
// <filesystem> // <filesystem>
// file_status symlink_status(const path& p); // file_status symlink_status(const path& p);
// file_status symlink_status(const path& p, error_code& ec) noexcept; // file_status symlink_status(const path& p, error_code& ec) noexcept;
#include "filesystem_include.h" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
TEST_SUITE(filesystem_symlink_status_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
const path p; ((void)p); const path p; ((void)p);
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(symlink_status(p)); ASSERT_NOT_NOEXCEPT(symlink_status(p));
ASSERT_NOEXCEPT(symlink_status(p, ec)); ASSERT_NOEXCEPT(symlink_status(p, ec));
} }
TEST_CASE(test_symlink_status_not_found) static void test_symlink_status_not_found()
{ {
static_test_env static_env; static_test_env static_env;
const std::errc expect_errc = std::errc::no_such_file_or_directory; const std::errc expect_errc = std::errc::no_such_file_or_directory;
const path cases[] { const path cases[] {
static_env.DNE static_env.DNE
}; };
for (auto& p : cases) { for (auto& p : cases) {
std::error_code ec = std::make_error_code(std::errc::address_in_use); std::error_code ec = std::make_error_code(std::errc::address_in_use);
// test non-throwing overload. // test non-throwing overload.
file_status st = symlink_status(p, ec); file_status st = symlink_status(p, ec);
TEST_CHECK(ErrorIs(ec, expect_errc)); assert(ErrorIs(ec, expect_errc));
TEST_CHECK(st.type() == file_type::not_found); assert(st.type() == file_type::not_found);
TEST_CHECK(st.permissions() == perms::unknown); assert(st.permissions() == perms::unknown);
// test throwing overload. It should not throw even though it reports // test throwing overload. It should not throw even though it reports
// that the file was not found. // that the file was not found.
TEST_CHECK_NO_THROW(st = status(p)); TEST_DOES_NOT_THROW(st = status(p));
TEST_CHECK(st.type() == file_type::not_found); assert(st.type() == file_type::not_found);
TEST_CHECK(st.permissions() == perms::unknown); assert(st.permissions() == perms::unknown);
} }
} }
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories. Imaginary files under GetWindowsInaccessibleDir() // reading directories. Imaginary files under GetWindowsInaccessibleDir()
// produce no_such_file_or_directory, not the error codes this test checks // produce no_such_file_or_directory, not the error codes this test checks
// for. Finally, status() for a too long file name doesn't return errors // for. Finally, status() for a too long file name doesn't return errors
// on windows. // on windows.
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_CASE(test_symlink_status_cannot_resolve) static void test_symlink_status_cannot_resolve()
{ {
scoped_test_env env; scoped_test_env env;
const path dir = env.create_dir("dir"); const path dir = env.create_dir("dir");
const path file_in_dir = env.create_file("dir/file", 42); const path file_in_dir = env.create_file("dir/file", 42);
const path sym_in_dir = env.create_symlink("dir/file", "dir/bad_sym"); const path sym_in_dir = env.create_symlink("dir/file", "dir/bad_sym");
const path sym_points_in_dir = env.create_symlink("dir/file", "sym"); const path sym_points_in_dir = env.create_symlink("dir/file", "sym");
permissions(dir, perms::none); permissions(dir, perms::none);
const std::errc set_errc = std::errc::address_in_use; const std::errc set_errc = std::errc::address_in_use;
const std::errc expect_errc = std::errc::permission_denied; const std::errc expect_errc = std::errc::permission_denied;
const path fail_cases[] = { const path fail_cases[] = {
file_in_dir, sym_in_dir file_in_dir, sym_in_dir
}; };
for (auto& p : fail_cases) for (auto& p : fail_cases)
{ {
{ // test non-throwing case { // test non-throwing case
std::error_code ec = std::make_error_code(set_errc); std::error_code ec = std::make_error_code(set_errc);
file_status st = symlink_status(p, ec); file_status st = symlink_status(p, ec);
TEST_CHECK(ErrorIs(ec, expect_errc)); assert(ErrorIs(ec, expect_errc));
TEST_CHECK(st.type() == file_type::none); assert(st.type() == file_type::none);
TEST_CHECK(st.permissions() == perms::unknown); assert(st.permissions() == perms::unknown);
} }
#ifndef TEST_HAS_NO_EXCEPTIONS #ifndef TEST_HAS_NO_EXCEPTIONS
{ // test throwing case { // test throwing case
try { try {
(void)symlink_status(p); (void)symlink_status(p);
} catch (filesystem_error const& err) { } catch (filesystem_error const& err) {
TEST_CHECK(err.path1() == p); assert(err.path1() == p);
TEST_CHECK(err.path2() == ""); assert(err.path2() == "");
TEST_CHECK(ErrorIs(err.code(), expect_errc)); assert(ErrorIs(err.code(), expect_errc));
} }
} }
#endif #endif
} }
// Test that a symlink that points into a directory without read perms // Test that a symlink that points into a directory without read perms
// can be stat-ed using symlink_status // can be stat-ed using symlink_status
{ {
std::error_code ec = std::make_error_code(set_errc); std::error_code ec = std::make_error_code(set_errc);
file_status st = symlink_status(sym_points_in_dir, ec); file_status st = symlink_status(sym_points_in_dir, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(st.type() == file_type::symlink); assert(st.type() == file_type::symlink);
TEST_CHECK(st.permissions() != perms::unknown); assert(st.permissions() != perms::unknown);
// test non-throwing version // test non-throwing version
TEST_REQUIRE_NO_THROW(st = symlink_status(sym_points_in_dir)); TEST_DOES_NOT_THROW(st = symlink_status(sym_points_in_dir));
TEST_CHECK(st.type() == file_type::symlink); assert(st.type() == file_type::symlink);
TEST_CHECK(st.permissions() != perms::unknown); assert(st.permissions() != perms::unknown);
} }
} }
#endif #endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
TEST_CASE(symlink_status_file_types_test) static void symlink_status_file_types_test()
{ {
static_test_env static_env; static_test_env static_env;
scoped_test_env env; scoped_test_env env;
struct TestCase { struct TestCase {
path p; path p;
file_type expect_type; file_type expect_type;
} cases[] = { } cases[] = {
{static_env.BadSymlink, file_type::symlink}, {static_env.BadSymlink, file_type::symlink},
Show All 11 Lines
#ifndef _WIN32 #ifndef _WIN32
{env.create_fifo("fifo"), file_type::fifo} {env.create_fifo("fifo"), file_type::fifo}
#endif #endif
}; };
for (const auto& TC : cases) { for (const auto& TC : cases) {
// test non-throwing case // test non-throwing case
std::error_code ec = std::make_error_code(std::errc::address_in_use); std::error_code ec = std::make_error_code(std::errc::address_in_use);
file_status st = symlink_status(TC.p, ec); file_status st = symlink_status(TC.p, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(st.type() == TC.expect_type); assert(st.type() == TC.expect_type);
TEST_CHECK(st.permissions() != perms::unknown); assert(st.permissions() != perms::unknown);
// test throwing case // test throwing case
TEST_REQUIRE_NO_THROW(st = symlink_status(TC.p)); TEST_DOES_NOT_THROW(st = symlink_status(TC.p));
TEST_CHECK(st.type() == TC.expect_type); assert(st.type() == TC.expect_type);
TEST_CHECK(st.permissions() != perms::unknown); assert(st.permissions() != perms::unknown);
} }
} }
TEST_CASE(test_block_file) static void test_block_file()
{ {
const path possible_paths[] = { const path possible_paths[] = {
"/dev/drive0", // Apple "/dev/drive0", // Apple
"/dev/sda", // Linux "/dev/sda", // Linux
"/dev/loop0" // Linux "/dev/loop0" // Linux
// No FreeBSD files known // No FreeBSD files known
}; };
path p; path p;
for (const path& possible_p : possible_paths) { for (const path& possible_p : possible_paths) {
std::error_code ec; std::error_code ec;
if (exists(possible_p, ec)) { if (exists(possible_p, ec)) {
p = possible_p; p = possible_p;
break; break;
} }
} }
if (p == path{}) { if (p == path{}) {
TEST_UNSUPPORTED(); TEST_IS_UNSUPPORTED();
} }
scoped_test_env env; scoped_test_env env;
{ // test block file { // test block file
// test non-throwing case // test non-throwing case
std::error_code ec = std::make_error_code(std::errc::address_in_use); std::error_code ec = std::make_error_code(std::errc::address_in_use);
file_status st = symlink_status(p, ec); file_status st = symlink_status(p, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(st.type() == file_type::block); assert(st.type() == file_type::block);
TEST_CHECK(st.permissions() != perms::unknown); assert(st.permissions() != perms::unknown);
// test throwing case // test throwing case
TEST_REQUIRE_NO_THROW(st = symlink_status(p)); TEST_DOES_NOT_THROW(st = symlink_status(p));
TEST_CHECK(st.type() == file_type::block); assert(st.type() == file_type::block);
TEST_CHECK(st.permissions() != perms::unknown); assert(st.permissions() != perms::unknown);
} }
const path sym = env.make_env_path("sym"); const path sym = env.make_env_path("sym");
create_symlink(p, sym); create_symlink(p, sym);
{ // test symlink to block file { // test symlink to block file
// test non-throwing case // test non-throwing case
std::error_code ec = std::make_error_code(std::errc::address_in_use); std::error_code ec = std::make_error_code(std::errc::address_in_use);
file_status st = symlink_status(sym, ec); file_status st = symlink_status(sym, ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(st.type() == file_type::symlink); assert(st.type() == file_type::symlink);
TEST_CHECK(st.permissions() != perms::unknown); assert(st.permissions() != perms::unknown);
// test throwing case // test throwing case
TEST_REQUIRE_NO_THROW(st = symlink_status(sym)); TEST_DOES_NOT_THROW(st = symlink_status(sym));
TEST_CHECK(st.type() == file_type::symlink); assert(st.type() == file_type::symlink);
TEST_CHECK(st.permissions() != perms::unknown); assert(st.permissions() != perms::unknown);
} }
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
test_symlink_status_not_found();
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
test_symlink_status_cannot_resolve();
#endif
symlink_status_file_types_test();
test_block_file();
return 0;
}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.pass.cpp

Show All 14 Lines
#include "filesystem_include.h" #include "filesystem_include.h"
#include <memory> #include <memory>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
using namespace fs; using namespace fs;
void PutEnv(std::string var, fs::path value) { void PutEnv(std::string var, fs::path value) {
assert(utils::setenv(var.c_str(), value.string().c_str(), /* overwrite */ 1) == 0); assert(utils::setenv(var.c_str(), value.string().c_str(), /* overwrite */ 1) == 0);
} }
void UnsetEnv(std::string var) { void UnsetEnv(std::string var) {
assert(utils::unsetenv(var.c_str()) == 0); assert(utils::unsetenv(var.c_str()) == 0);
} }
TEST_SUITE(filesystem_temp_directory_path_test_suite) static void signature_test()
TEST_CASE(signature_test)
{ {
std::error_code ec; ((void)ec); std::error_code ec; ((void)ec);
ASSERT_NOT_NOEXCEPT(temp_directory_path()); ASSERT_NOT_NOEXCEPT(temp_directory_path());
ASSERT_NOT_NOEXCEPT(temp_directory_path(ec)); ASSERT_NOT_NOEXCEPT(temp_directory_path(ec));
} }
TEST_CASE(basic_tests) static void basic_tests()
{ {
scoped_test_env env; scoped_test_env env;
const path dne = env.make_env_path("dne"); const path dne = env.make_env_path("dne");
const path file = env.create_file("file", 42); const path file = env.create_file("file", 42);
#ifdef _WIN32 #ifdef _WIN32
// Windows doesn't support setting perms::none to trigger failures // Windows doesn't support setting perms::none to trigger failures
// reading directories; test using a special inaccessible directory // reading directories; test using a special inaccessible directory
// instead. // instead.
Show All 28 Lines
#endif #endif
}; };
for (auto& TC : cases) { for (auto& TC : cases) {
PutEnv(TC.name, TC.p); PutEnv(TC.name, TC.p);
} }
for (auto& TC : cases) { for (auto& TC : cases) {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
path ret = temp_directory_path(ec); path ret = temp_directory_path(ec);
TEST_CHECK(!ec); assert(!ec);
TEST_CHECK(ret == TC.p); assert(ret == TC.p);
TEST_CHECK(is_directory(ret)); assert(is_directory(ret));
// Set the env variable to a path that does not exist and check // Set the env variable to a path that does not exist and check
// that it fails. // that it fails.
PutEnv(TC.name, dne); PutEnv(TC.name, dne);
ec = GetTestEC(); ec = GetTestEC();
ret = temp_directory_path(ec); ret = temp_directory_path(ec);
LIBCPP_ONLY(TEST_CHECK(ErrorIs(ec, expect_errc))); LIBCPP_ONLY(assert(ErrorIs(ec, expect_errc)));
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ret == ""); assert(ret == "");
// Set the env variable to point to a file and check that it fails. // Set the env variable to point to a file and check that it fails.
PutEnv(TC.name, file); PutEnv(TC.name, file);
ec = GetTestEC(); ec = GetTestEC();
ret = temp_directory_path(ec); ret = temp_directory_path(ec);
LIBCPP_ONLY(TEST_CHECK(ErrorIs(ec, expect_errc))); LIBCPP_ONLY(assert(ErrorIs(ec, expect_errc)));
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ret == ""); assert(ret == "");
if (!inaccessible_dir.empty()) { if (!inaccessible_dir.empty()) {
// Set the env variable to point to a dir we can't access // Set the env variable to point to a dir we can't access
PutEnv(TC.name, inaccessible_dir); PutEnv(TC.name, inaccessible_dir);
ec = GetTestEC(); ec = GetTestEC();
ret = temp_directory_path(ec); ret = temp_directory_path(ec);
TEST_CHECK(ErrorIs(ec, std::errc::permission_denied)); assert(ErrorIs(ec, std::errc::permission_denied));
TEST_CHECK(ret == ""); assert(ret == "");
} }
// Set the env variable to point to a non-existent dir // Set the env variable to point to a non-existent dir
PutEnv(TC.name, TC.p / "does_not_exist"); PutEnv(TC.name, TC.p / "does_not_exist");
ec = GetTestEC(); ec = GetTestEC();
ret = temp_directory_path(ec); ret = temp_directory_path(ec);
TEST_CHECK(ec != GetTestEC()); assert(ec != GetTestEC());
TEST_CHECK(ec); assert(ec);
TEST_CHECK(ret == ""); assert(ret == "");
// Finally erase this env variable // Finally erase this env variable
UnsetEnv(TC.name); UnsetEnv(TC.name);
} }
// No env variables are defined // No env variables are defined
path fallback; path fallback;
{ {
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
path ret = temp_directory_path(ec); path ret = temp_directory_path(ec);
TEST_CHECK(!ec); assert(!ec);
#ifndef _WIN32 #ifndef _WIN32
// On Windows, the function falls back to the Windows folder. // On Windows, the function falls back to the Windows folder.
TEST_CHECK(ret == "/tmp"); assert(ret == "/tmp");
#endif #endif
TEST_CHECK(is_directory(ret)); assert(is_directory(ret));
fallback = ret; fallback = ret;
} }
for (auto& TC : ignored_cases) { for (auto& TC : ignored_cases) {
// Check that certain variables are ignored // Check that certain variables are ignored
PutEnv(TC.name, TC.p); PutEnv(TC.name, TC.p);
std::error_code ec = GetTestEC(); std::error_code ec = GetTestEC();
path ret = temp_directory_path(ec); path ret = temp_directory_path(ec);
TEST_CHECK(!ec); assert(!ec);
// Check that we return the same as above when no vars were defined. // Check that we return the same as above when no vars were defined.
TEST_CHECK(ret == fallback); assert(ret == fallback);
// Finally erase this env variable // Finally erase this env variable
UnsetEnv(TC.name); UnsetEnv(TC.name);
} }
} }
TEST_SUITE_END() int main(int, char**) {
signature_test();
basic_tests();
return 0;
}

libcxx/test/support/filesystem_test_helper.h

Show All 15 Lines
#include <cassert> #include <cassert>
#include <chrono> #include <chrono>
#include <cstdint> #include <cstdint>
#include <cstdio> // for printf #include <cstdio> // for printf
#include <string> #include <string>
#include <system_error> #include <system_error>
#include <vector> #include <vector>
#include "assert_macros.h"
#include "make_string.h" #include "make_string.h"
#include "test_macros.h" #include "test_macros.h"
#include "rapid-cxx-test.h"
#include "format_string.h" #include "format_string.h"
// For creating socket files // For creating socket files
#if !defined(__FreeBSD__) && !defined(__APPLE__) && !defined(_WIN32) #if !defined(__FreeBSD__) && !defined(__APPLE__) && !defined(_WIN32)
# include <sys/socket.h> # include <sys/socket.h>
# include <sys/un.h> # include <sys/un.h>
#endif #endif
▲ Show 20 Lines • Show All 632 Lines • ▼ Show 20 Lines explicit ExceptionChecker(fs::path p, std::errc first_err,
func_name(fun_name), opt_message(opt_msg) {} func_name(fun_name), opt_message(opt_msg) {}
explicit ExceptionChecker(fs::path p1, fs::path p2, std::errc first_err, explicit ExceptionChecker(fs::path p1, fs::path p2, std::errc first_err,
const char* fun_name, std::string opt_msg = {}) const char* fun_name, std::string opt_msg = {})
: expected_err(first_err), expected_path1(p1), expected_path2(p2), : expected_err(first_err), expected_path1(p1), expected_path2(p2),
num_paths(2), func_name(fun_name), opt_message(opt_msg) {} num_paths(2), func_name(fun_name), opt_message(opt_msg) {}
void operator()(fs::filesystem_error const& Err) { void operator()(fs::filesystem_error const& Err) {
TEST_CHECK(ErrorIsImp(Err.code(), {expected_err})); assert(ErrorIsImp(Err.code(), {expected_err}));
TEST_CHECK(Err.path1() == expected_path1); assert(Err.path1() == expected_path1);
TEST_CHECK(Err.path2() == expected_path2); assert(Err.path2() == expected_path2);
LIBCPP_ONLY(check_libcxx_string(Err)); LIBCPP_ONLY(check_libcxx_string(Err));
} }
void check_libcxx_string(fs::filesystem_error const& Err) { void check_libcxx_string(fs::filesystem_error const& Err) {
std::string message = std::make_error_code(expected_err).message(); std::string message = std::make_error_code(expected_err).message();
std::string additional_msg = ""; std::string additional_msg = "";
if (!opt_message.empty()) { if (!opt_message.empty()) {
Show All 12 Lines std::string format = [&]() -> std::string {
additional_msg, message, additional_msg, message,
transform_path(expected_path1).c_str()); transform_path(expected_path1).c_str());
case 2: case 2:
return format_string("filesystem error: in %s: %s%s [%s] [%s]", return format_string("filesystem error: in %s: %s%s [%s] [%s]",
func_name, additional_msg, message, func_name, additional_msg, message,
transform_path(expected_path1).c_str(), transform_path(expected_path1).c_str(),
transform_path(expected_path2).c_str()); transform_path(expected_path2).c_str());
default: default:
TEST_CHECK(false && "unexpected case"); TEST_FAIL("unexpected case");
return ""; return "";
} }
}(); }();
TEST_CHECK(format == Err.what()); assert(format == Err.what());
if (format != Err.what()) { if (format != Err.what()) {
fprintf(stderr, fprintf(stderr,
"filesystem_error::what() does not match expected output:\n"); "filesystem_error::what() does not match expected output:\n");
fprintf(stderr, " expected: \"%s\"\n", format.c_str()); fprintf(stderr, " expected: \"%s\"\n", format.c_str());
fprintf(stderr, " actual: \"%s\"\n\n", Err.what()); fprintf(stderr, " actual: \"%s\"\n\n", Err.what());
} }
} }
Show All 37 Lines

libcxx/test/support/rapid-cxx-test.h

  • This file was deleted.
#ifndef RAPID_CXX_TEST_H
#define RAPID_CXX_TEST_H
# include <cstddef>
# include <cstdlib>
# include <cstdio>
# include <cstring>
# include <cassert>
#include "test_macros.h"
#if !defined(RAPID_CXX_TEST_NO_SYSTEM_HEADER) || !defined(__GNUC__)
#pragma GCC system_header
#endif
# define RAPID_CXX_TEST_PP_CAT(x, y) RAPID_CXX_TEST_PP_CAT_2(x, y)
# define RAPID_CXX_TEST_PP_CAT_2(x, y) x##y
# define RAPID_CXX_TEST_PP_STR(...) RAPID_CXX_TEST_PP_STR_2(__VA_ARGS__)
# define RAPID_CXX_TEST_PP_STR_2(...) #__VA_ARGS__
# if defined(__GNUC__)
# define TEST_FUNC_NAME() __PRETTY_FUNCTION__
# define RAPID_CXX_TEST_UNUSED __attribute__((unused))
# else
# define TEST_FUNC_NAME() __func__
# define RAPID_CXX_TEST_UNUSED
# endif
////////////////////////////////////////////////////////////////////////////////
// TEST_SUITE
////////////////////////////////////////////////////////////////////////////////
# define TEST_SUITE(Name) \
namespace Name \
{ \
inline ::rapid_cxx_test::test_suite & get_test_suite() \
{ \
static ::rapid_cxx_test::test_suite m_suite(#Name); \
return m_suite; \
} \
\
inline int unit_test_main(int, char**) \
{ \
::rapid_cxx_test::test_runner runner(get_test_suite()); \
return runner.run(); \
} \
} \
int main(int argc, char **argv) \
{ \
return Name::unit_test_main(argc, argv); \
} \
namespace Name \
{ /* namespace closed in TEST_SUITE_END */
#
////////////////////////////////////////////////////////////////////////////////
// TEST_SUITE_END
////////////////////////////////////////////////////////////////////////////////
# define TEST_SUITE_END() \
} /* namespace opened in TEST_SUITE(...) */
#
////////////////////////////////////////////////////////////////////////////////
// TEST_CASE
////////////////////////////////////////////////////////////////////////////////
# if !defined(__clang__)
#
# define TEST_CASE(Name) \
void Name(); \
static void RAPID_CXX_TEST_PP_CAT(Name, _invoker)() \
{ \
Name(); \
} \
static ::rapid_cxx_test::registrar \
RAPID_CXX_TEST_PP_CAT(rapid_cxx_test_registrar_, Name)( \
get_test_suite() \
, ::rapid_cxx_test::test_case(__FILE__, #Name, __LINE__, & RAPID_CXX_TEST_PP_CAT(Name, _invoker)) \
); \
void Name()
#
# else /* __clang__ */
#
# define TEST_CASE(Name) \
void Name(); \
static void RAPID_CXX_TEST_PP_CAT(Name, _invoker)() \
{ \
Name(); \
} \
_Pragma("clang diagnostic push") \
_Pragma("clang diagnostic ignored \"-Wglobal-constructors\"") \
static ::rapid_cxx_test::registrar \
RAPID_CXX_TEST_PP_CAT(rapid_cxx_test_registrar_, Name)( \
get_test_suite() \
, ::rapid_cxx_test::test_case(__FILE__, #Name, __LINE__, & RAPID_CXX_TEST_PP_CAT(Name, _invoker)) \
); \
_Pragma("clang diagnostic pop") \
void Name()
#
# endif /* !defined(__clang__) */
# define TEST_SET_CHECKPOINT() ::rapid_cxx_test::set_checkpoint(__FILE__, TEST_FUNC_NAME(), __LINE__)
#define RAPID_CXX_TEST_OUTCOME()
////////////////////////////////////////////////////////////////////////////////
// TEST_UNSUPPORTED
////////////////////////////////////////////////////////////////////////////////
# define TEST_UNSUPPORTED() \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::unsupported, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "", "" \
); \
::rapid_cxx_test::get_reporter().report(m_f); \
return; \
} while (false)
#
////////////////////////////////////////////////////////////////////////////////
// BASIC ASSERTIONS
////////////////////////////////////////////////////////////////////////////////
# define TEST_WARN(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_WARN(" #__VA_ARGS__ ")", "" \
); \
if (not (__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::warn; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_CHECK(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK(" #__VA_ARGS__ ")", "" \
); \
if (not (__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_REQUIRE(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE(" #__VA_ARGS__ ")", "" \
); \
if (not (__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::require; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
return; \
} \
} while (false)
#
# define TEST_ASSERT(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT(" #__VA_ARGS__ ")", "" \
); \
if (not (__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::assert; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
std::abort(); \
} \
} while (false)
#
////////////////////////////////////////////////////////////////////////////////
// TEST_CHECK_NO_THROW / TEST_CHECK_THROW
////////////////////////////////////////////////////////////////////////////////
#ifndef TEST_HAS_NO_EXCEPTIONS
# define TEST_CHECK_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
} catch (...) { \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_CHECK_THROW(Except, ...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK_THROW(" #Except "," #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} catch (Except const &) {} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#define TEST_CHECK_THROW_RESULT(Except, Checker, ...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f(::rapid_cxx_test::failure_type::none, \
__FILE__, TEST_FUNC_NAME(), __LINE__, \
"TEST_CHECK_THROW_RESULT(" #Except \
"," #Checker "," #__VA_ARGS__ ")", \
""); \
try { \
(static_cast<void>(__VA_ARGS__)); \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} catch (Except const& Caught) { \
Checker(Caught); \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#else // TEST_HAS_NO_EXCEPTIONS
# define TEST_CHECK_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
(static_cast<void>(__VA_ARGS__)); \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#define TEST_CHECK_THROW(Except, ...) ((void)0)
#define TEST_CHECK_THROW_RESULT(Except, Checker, ...) ((void)0)
#endif // TEST_HAS_NO_EXCEPTIONS
////////////////////////////////////////////////////////////////////////////////
// TEST_REQUIRE_NO_THROW / TEST_REQUIRE_THROWs
////////////////////////////////////////////////////////////////////////////////
#ifndef TEST_HAS_NO_EXCEPTIONS
# define TEST_REQUIRE_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
} catch (...) { \
m_f.type = ::rapid_cxx_test::failure_type::require; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
return; \
} \
} while (false)
#
# define TEST_REQUIRE_THROW(Except, ...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE_THROW(" #Except "," #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
m_f.type = ::rapid_cxx_test::failure_type::require; \
} catch (Except const &) {} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
return; \
} \
} while (false)
#
#else // TEST_HAS_NO_EXCEPTIONS
# define TEST_REQUIRE_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
(static_cast<void>(__VA_ARGS__)); \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#define TEST_REQUIRE_THROW(Except, ...) ((void)0)
#endif // TEST_HAS_NO_EXCEPTIONS
////////////////////////////////////////////////////////////////////////////////
// TEST_ASSERT_NO_THROW / TEST_ASSERT_THROW
////////////////////////////////////////////////////////////////////////////////
#ifndef TEST_HAS_NO_EXCEPTIONS
# define TEST_ASSERT_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
} catch (...) { \
m_f.type = ::rapid_cxx_test::failure_type::assert; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
std::abort(); \
} \
} while (false)
#
# define TEST_ASSERT_THROW(Except, ...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT_THROW(" #Except "," #__VA_ARGS__ ")", "" \
); \
try { \
(static_cast<void>(__VA_ARGS__)); \
m_f.type = ::rapid_cxx_test::failure_type::assert; \
} catch (Except const &) {} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
std::abort(); \
} \
} while (false)
#
#else // TEST_HAS_NO_EXCEPTIONS
# define TEST_ASSERT_NO_THROW(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT_NO_THROW(" #__VA_ARGS__ ")", "" \
); \
(static_cast<void>(__VA_ARGS__)); \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
#define TEST_ASSERT_THROW(Except, ...) ((void)0)
#endif // TEST_HAS_NO_EXCEPTIONS
////////////////////////////////////////////////////////////////////////////////
//
////////////////////////////////////////////////////////////////////////////////
# define TEST_WARN_EQUAL_COLLECTIONS(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_WARN_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", "" \
); \
if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::warn; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_CHECK_EQUAL_COLLECTIONS(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_CHECK_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", "" \
); \
if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::check; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
} while (false)
#
# define TEST_REQUIRE_EQUAL_COLLECTIONS(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_REQUIRE_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", "" \
); \
if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::require; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
return; \
} \
} while (false)
#
# define TEST_ASSERT_EQUAL_COLLECTIONS(...) \
do { \
TEST_SET_CHECKPOINT(); \
::rapid_cxx_test::test_outcome m_f( \
::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
, "TEST_ASSERT_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", "" \
); \
if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
m_f.type = ::rapid_cxx_test::failure_type::assert; \
} \
::rapid_cxx_test::get_reporter().report(m_f); \
if (m_f.type != ::rapid_cxx_test::failure_type::none) { \
::std::abort(); \
} \
} while (false)
#
namespace rapid_cxx_test
{
typedef void (*invoker_t)();
////////////////////////////////////////////////////////////////////////////
struct test_case
{
test_case()
: file(""), func(""), line(0), invoke(NULL)
{}
test_case(const char* file1, const char* func1, std::size_t line1,
invoker_t invoke1)
: file(file1), func(func1), line(line1), invoke(invoke1)
{}
const char *file;
const char *func;
std::size_t line;
invoker_t invoke;
};
////////////////////////////////////////////////////////////////////////////
struct failure_type
{
enum enum_type {
none,
unsupported,
warn,
check,
require,
assert,
uncaught_exception
};
};
typedef failure_type::enum_type failure_type_t;
////////////////////////////////////////////////////////////////////////////
struct test_outcome
{
test_outcome()
: type(failure_type::none),
file(""), func(""), line(0),
expression(""), message("")
{}
test_outcome(failure_type_t type1, const char* file1, const char* func1,
std::size_t line1, const char* expression1,
const char* message1)
: type(type1), file(file1), func(func1), line(line1),
expression(expression1), message(message1)
{
trim_func_string();
}
failure_type_t type;
const char *file;
const char *func;
std::size_t line;
const char *expression;
const char *message;
private:
void trim_file_string() {
const char* f_start = file;
const char* prev_start = f_start;
const char* last_start = f_start;
char last;
while ((last = *f_start) != '\0') {
++f_start;
if (last == '/' && *f_start) {
prev_start = last_start;
last_start = f_start;
}
}
file = prev_start;
}
void trim_func_string() {
const char* void_loc = ::strstr(func, "void ");
if (void_loc == func) {
func += strlen("void ");
}
const char* namespace_loc = ::strstr(func, "::");
if (namespace_loc) {
func = namespace_loc + 2;
}
}
};
////////////////////////////////////////////////////////////////////////////
struct checkpoint
{
const char *file;
const char *func;
std::size_t line;
};
namespace detail
{
inline checkpoint & global_checkpoint()
{
static checkpoint cp = {"", "", 0};
return cp;
}
}
////////////////////////////////////////////////////////////////////////////
inline void set_checkpoint(const char* file, const char* func, std::size_t line)
{
checkpoint& cp = detail::global_checkpoint();
cp.file = file;
cp.func = func;
cp.line = line;
}
////////////////////////////////////////////////////////////////////////////
inline checkpoint const & get_checkpoint()
{
return detail::global_checkpoint();
}
////////////////////////////////////////////////////////////////////////////
class test_suite
{
public:
typedef test_case const* iterator;
typedef iterator const_iterator;
public:
test_suite(const char *xname)
: m_name(xname), m_tests(), m_size(0)
{
assert(xname);
}
public:
const char *name() const { return m_name; }
std::size_t size() const { return m_size; }
test_case const & operator[](std::size_t i) const
{
assert(i < m_size);
return m_tests[i];
}
const_iterator begin() const
{ return m_tests; }
const_iterator end() const
{
return m_tests + m_size;
}
public:
std::size_t register_test(test_case tc)
{
static std::size_t test_case_max = sizeof(m_tests) / sizeof(test_case);
assert(m_size < test_case_max);
m_tests[m_size] = tc;
return m_size++;
}
private:
test_suite(test_suite const &);
test_suite & operator=(test_suite const &);
private:
const char* m_name;
// Since fast compile times in a priority, we use simple containers
// with hard limits.
test_case m_tests[256];
std::size_t m_size;
};
////////////////////////////////////////////////////////////////////////////
class registrar
{
public:
registrar(test_suite & st, test_case tc)
{
st.register_test(tc);
}
};
////////////////////////////////////////////////////////////////////////////
class test_reporter
{
public:
test_reporter()
: m_testcases(0), m_testcase_failures(0), m_unsupported(0),
m_assertions(0), m_warning_failures(0), m_check_failures(0),
m_require_failures(0), m_uncaught_exceptions(0), m_failure()
{
}
void test_case_begin()
{
++m_testcases;
clear_failure();
}
void test_case_end()
{
if (m_failure.type != failure_type::none
&& m_failure.type != failure_type::unsupported) {
++m_testcase_failures;
}
}
# if defined(__GNUC__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wswitch-default"
# endif
// Each assertion and failure is reported through this function.
void report(test_outcome o)
{
++m_assertions;
switch (o.type)
{
case failure_type::none:
break;
case failure_type::unsupported:
++m_unsupported;
m_failure = o;
break;
case failure_type::warn:
++m_warning_failures;
report_error(o);
break;
case failure_type::check:
++m_check_failures;
report_error(o);
m_failure = o;
break;
case failure_type::require:
++m_require_failures;
report_error(o);
m_failure = o;
break;
case failure_type::assert:
report_error(o);
break;
case failure_type::uncaught_exception:
++m_uncaught_exceptions;
std::fprintf(stderr
, "Test case FAILED with uncaught exception:\n"
" last checkpoint near %s::%lu %s\n\n"
, o.file, o.line, o.func
);
m_failure = o;
break;
}
}
# if defined(__GNUC__)
# pragma GCC diagnostic pop
# endif
test_outcome current_failure() const
{
return m_failure;
}
void clear_failure()
{
m_failure.type = failure_type::none;
m_failure.file = "";
m_failure.func = "";
m_failure.line = 0;
m_failure.expression = "";
m_failure.message = "";
}
std::size_t test_case_count() const
{ return m_testcases; }
std::size_t test_case_failure_count() const
{ return m_testcase_failures; }
std::size_t unsupported_count() const
{ return m_unsupported; }
std::size_t assertion_count() const
{ return m_assertions; }
std::size_t warning_failure_count() const
{ return m_warning_failures; }
std::size_t check_failure_count() const
{ return m_check_failures; }
std::size_t require_failure_count() const
{ return m_require_failures; }
std::size_t failure_count() const
{ return m_check_failures + m_require_failures + m_uncaught_exceptions; }
// Print a summary of what was run and the outcome.
void print_summary(const char* suitename) const
{
FILE* out = failure_count() ? stderr : stdout;
std::size_t testcases_run = m_testcases - m_unsupported;
std::fprintf(out, "Summary for testsuite %s:\n", suitename);
std::fprintf(out, " %lu of %lu test cases passed.\n", testcases_run - m_testcase_failures, testcases_run);
std::fprintf(out, " %lu of %lu assertions passed.\n", m_assertions - (m_warning_failures + m_check_failures + m_require_failures), m_assertions);
std::fprintf(out, " %lu unsupported test case%s.\n", m_unsupported, (m_unsupported != 1 ? "s" : ""));
}
private:
test_reporter(test_reporter const &);
test_reporter const & operator=(test_reporter const &);
void report_error(test_outcome o) const
{
std::fprintf(stderr, "In %s:%lu Assertion %s failed.\n in file: %s\n %s\n"
, o.func, o.line, o.expression, o.file, o.message ? o.message : ""
);
}
private:
// counts of testcases, failed testcases, and unsupported testcases.
std::size_t m_testcases;
std::size_t m_testcase_failures;
std::size_t m_unsupported;
// counts of assertions and assertion failures.
std::size_t m_assertions;
std::size_t m_warning_failures;
std::size_t m_check_failures;
std::size_t m_require_failures;
std::size_t m_uncaught_exceptions;
// The last failure. This is cleared between testcases.
test_outcome m_failure;
};
////////////////////////////////////////////////////////////////////////////
inline test_reporter & get_reporter()
{
static test_reporter o;
return o;
}
////////////////////////////////////////////////////////////////////////////
class test_runner
{
public:
test_runner(test_suite & ts)
: m_ts(ts)
{}
public:
int run()
{
// for each testcase
for (test_suite::const_iterator b = m_ts.begin(), e = m_ts.end();
b != e; ++b)
{
test_case const& tc = *b;
set_checkpoint(tc.file, tc.func, tc.line);
get_reporter().test_case_begin();
#ifndef TEST_HAS_NO_EXCEPTIONS
try {
#endif
tc.invoke();
#ifndef TEST_HAS_NO_EXCEPTIONS
} catch (...) {
test_outcome o;
o.type = failure_type::uncaught_exception;
o.file = get_checkpoint().file;
o.func = get_checkpoint().func;
o.line = get_checkpoint().line;
o.expression = "";
o.message = "";
get_reporter().report(o);
}
#endif
get_reporter().test_case_end();
}
auto exit_code = get_reporter().failure_count() ? EXIT_FAILURE : EXIT_SUCCESS;
if (exit_code == EXIT_FAILURE || get_reporter().unsupported_count())
get_reporter().print_summary(m_ts.name());
return exit_code;
}
private:
test_runner(test_runner const &);
test_runner operator=(test_runner const &);
test_suite & m_ts;
};
namespace detail
{
template <class Iter1, class Iter2>
bool check_equal_collections_impl(
Iter1 start1, Iter1 const end1
, Iter2 start2, Iter2 const end2
)
{
while (start1 != end1 && start2 != end2) {
if (*start1 != *start2) {
return false;
}
++start1; ++start2;
}
return (start1 == end1 && start2 == end2);
}
} // namespace detail
} // namespace rapid_cxx_test
# if defined(__GNUC__)
# pragma GCC diagnostic pop
# endif
#endif /* RAPID_CXX_TEST_H */
libcxx/test/support/filesystem_test_helper.h