Debian Codegraph @

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

raw
1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // REQUIRES: can-create-symlinks
10 // UNSUPPORTED: c++03, c++11, c++14
11 // UNSUPPORTED: no-filesystem
12
13 // <filesystem>
14
15 // class recursive_directory_iterator
16
17 // recursive_directory_iterator& operator=(recursive_directory_iterator const&);
18
19 #include <filesystem>
20 #include <type_traits>
21 #include <set>
22 #include <cassert>
23
24 #include "test_macros.h"
25 #include "filesystem_test_helper.h"
26 namespace fs = std::filesystem;
27 using namespace fs;
28
29 recursive_directory_iterator createInterestingIterator(const static_test_env &static_env)
30 // Create an "interesting" iterator where all fields are
31 // in a non-default state. The returned 'it' is in a
32 // state such that:
33 // it.options() == directory_options::skip_permission_denied
34 // it.depth() == 1
35 // it.recursion_pending() == true
36 {
37 const path testDir = static_env.Dir;
38 const recursive_directory_iterator endIt;
39 recursive_directory_iterator it(testDir,
40 directory_options::skip_permission_denied);
41 assert(it != endIt);
42 while (it.depth() != 1) {
43 ++it;
44 assert(it != endIt);
45 }
46 assert(it.depth() == 1);
47 it.disable_recursion_pending();
48 return it;
49 }
50
51
52 recursive_directory_iterator createDifferentInterestingIterator(const static_test_env &static_env)
53 // Create an "interesting" iterator where all fields are
54 // in a non-default state. The returned 'it' is in a
55 // state such that:
56 // it.options() == directory_options::follow_directory_symlink
57 // it.depth() == 2
58 // it.recursion_pending() == false
59 {
60 const path testDir = static_env.Dir;
61 const recursive_directory_iterator endIt;
62 recursive_directory_iterator it(testDir,
63 directory_options::follow_directory_symlink);
64 assert(it != endIt);
65 while (it.depth() != 2) {
66 ++it;
67 assert(it != endIt);
68 }
69 assert(it.depth() == 2);
70 return it;
71 }
72
73 static void test_assignment_signature() {
74 using D = recursive_directory_iterator;
75 static_assert(std::is_copy_assignable<D>::value, "");
76 }
77
78 static void test_copy_to_end_iterator()
79 {
80 static_test_env static_env;
81 const recursive_directory_iterator endIt;
82
83 const recursive_directory_iterator from = createInterestingIterator(static_env);
84 const path entry = *from;
85
86 recursive_directory_iterator to;
87 to = from;
88 assert(to == from);
89 assert(*to == entry);
90 assert(to.options() == from.options());
91 assert(to.depth() == from.depth());
92 assert(to.recursion_pending() == from.recursion_pending());
93 }
94
95
96 static void test_copy_from_end_iterator()
97 {
98 static_test_env static_env;
99 const recursive_directory_iterator from;
100 recursive_directory_iterator to = createInterestingIterator(static_env);
101
102 to = from;
103 assert(to == from);
104 assert(to == recursive_directory_iterator{});
105 }
106
107 static void test_copy_valid_iterator()
108 {
109 static_test_env static_env;
110 const recursive_directory_iterator endIt;
111
112 const recursive_directory_iterator it = createInterestingIterator(static_env);
113 const path entry = *it;
114
115 recursive_directory_iterator it2 = createDifferentInterestingIterator(static_env);
116 assert(it2 != it);
117 assert(it2.options() != it.options());
118 assert(it2.depth() != it.depth());
119 assert(it2.recursion_pending() != it.recursion_pending());
120 assert(*it2 != entry);
121
122 it2 = it;
123 assert(it2 == it);
124 assert(it2.options() == it.options());
125 assert(it2.depth() == it.depth());
126 assert(it2.recursion_pending() == it.recursion_pending());
127 assert(*it2 == entry);
128 }
129
130 static void test_returns_reference_to_self()
131 {
132 const recursive_directory_iterator it;
133 recursive_directory_iterator it2;
134 recursive_directory_iterator& ref = (it2 = it);
135 assert(&ref == &it2);
136 }
137
138 static void test_self_copy()
139 {
140 static_test_env static_env;
141 // Create two non-equal iterators that have exactly the same state.
142 recursive_directory_iterator it = createInterestingIterator(static_env);
143 recursive_directory_iterator it2 = createInterestingIterator(static_env);
144 assert(it != it2);
145 assert(it2.options() == it.options());
146 assert(it2.depth() == it.depth());
147 assert(it2.recursion_pending() == it.recursion_pending());
148 assert(*it2 == *it);
149
150 // perform a self-copy and check that the state still matches the
151 // other unmodified iterator.
152 recursive_directory_iterator const& cit = it;
153 it = cit;
154 assert(it2.options() == it.options());
155 assert(it2.depth() == it.depth());
156 assert(it2.recursion_pending() == it.recursion_pending());
157 assert(*it2 == *it);
158 }
159
160 int main(int, char**) {
161 test_assignment_signature();
162 test_copy_to_end_iterator();
163 test_copy_from_end_iterator();
164 test_copy_valid_iterator();
165 test_returns_reference_to_self();
166 test_self_copy();
167
168 return 0;
169 }