Debian Codegraph @

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.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 // bool recursion_pending() 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 static void initial_value_test()
30 {
31 static_test_env static_env;
32 recursive_directory_iterator it(static_env.Dir);
33 assert(it.recursion_pending() == true);
34 }
35
36 static void value_after_copy_construction_and_assignment_test()
37 {
38 static_test_env static_env;
39 recursive_directory_iterator rec_pending_it(static_env.Dir);
40 recursive_directory_iterator no_rec_pending_it(static_env.Dir);
41 no_rec_pending_it.disable_recursion_pending();
42
43 { // copy construction
44 recursive_directory_iterator it(rec_pending_it);
45 assert(it.recursion_pending() == true);
46 it.disable_recursion_pending();
47 assert(rec_pending_it.recursion_pending() == true);
48
49 recursive_directory_iterator it2(no_rec_pending_it);
50 assert(it2.recursion_pending() == false);
51 }
52 { // copy assignment
53 recursive_directory_iterator it(static_env.Dir);
54 it.disable_recursion_pending();
55 it = rec_pending_it;
56 assert(it.recursion_pending() == true);
57 it.disable_recursion_pending();
58 assert(rec_pending_it.recursion_pending() == true);
59
60 recursive_directory_iterator it2(static_env.Dir);
61 it2 = no_rec_pending_it;
62 assert(it2.recursion_pending() == false);
63 }
64 assert(rec_pending_it.recursion_pending() == true);
65 assert(no_rec_pending_it.recursion_pending() == false);
66 }
67
68
69 static void value_after_move_construction_and_assignment_test()
70 {
71 static_test_env static_env;
72 recursive_directory_iterator rec_pending_it(static_env.Dir);
73 recursive_directory_iterator no_rec_pending_it(static_env.Dir);
74 no_rec_pending_it.disable_recursion_pending();
75
76 { // move construction
77 recursive_directory_iterator it_cp(rec_pending_it);
78 recursive_directory_iterator it(std::move(it_cp));
79 assert(it.recursion_pending() == true);
80
81 recursive_directory_iterator it_cp2(no_rec_pending_it);
82 recursive_directory_iterator it2(std::move(it_cp2));
83 assert(it2.recursion_pending() == false);
84 }
85 { // copy assignment
86 recursive_directory_iterator it(static_env.Dir);
87 it.disable_recursion_pending();
88 recursive_directory_iterator it_cp(rec_pending_it);
89 it = std::move(it_cp);
90 assert(it.recursion_pending() == true);
91
92 recursive_directory_iterator it2(static_env.Dir);
93 recursive_directory_iterator it_cp2(no_rec_pending_it);
94 it2 = std::move(it_cp2);
95 assert(it2.recursion_pending() == false);
96 }
97 assert(rec_pending_it.recursion_pending() == true);
98 assert(no_rec_pending_it.recursion_pending() == false);
99 }
100
101 static void increment_resets_value()
102 {
103 static_test_env static_env;
104 const recursive_directory_iterator endIt;
105 {
106 recursive_directory_iterator it(static_env.Dir);
107 it.disable_recursion_pending();
108 assert(it.recursion_pending() == false);
109 ++it;
110 assert(it.recursion_pending() == true);
111 assert(it.depth() == 0);
112 }
113 {
114 recursive_directory_iterator it(static_env.Dir);
115 it.disable_recursion_pending();
116 assert(it.recursion_pending() == false);
117 it++;
118 assert(it.recursion_pending() == true);
119 assert(it.depth() == 0);
120 }
121 {
122 recursive_directory_iterator it(static_env.Dir);
123 it.disable_recursion_pending();
124 assert(it.recursion_pending() == false);
125 std::error_code ec;
126 it.increment(ec);
127 assert(it.recursion_pending() == true);
128 assert(it.depth() == 0);
129 }
130 }
131
132 static void pop_does_not_reset_value()
133 {
134 static_test_env static_env;
135 const recursive_directory_iterator endIt;
136
137 auto& DE0 = static_env.DirIterationList;
138 std::set<path> notSeenDepth0(DE0.begin(), DE0.end());
139
140 recursive_directory_iterator it(static_env.Dir);
141 assert(it != endIt);
142
143 while (it.depth() == 0) {
144 notSeenDepth0.erase(it->path());
145 ++it;
146 assert(it != endIt);
147 }
148 assert(it.depth() == 1);
149 it.disable_recursion_pending();
150 it.pop();
151 // Since the order of iteration is unspecified the pop() could result
152 // in the end iterator. When this is the case it is undefined behavior
153 // to call recursion_pending().
154 if (it == endIt) {
155 assert(notSeenDepth0.empty());
156 #if defined(_LIBCPP_VERSION)
157 assert(it.recursion_pending() == false);
158 #endif
159 } else {
160 assert(! notSeenDepth0.empty());
161 assert(it.recursion_pending() == false);
162 }
163 }
164
165 int main(int, char**) {
166 initial_value_test();
167 value_after_copy_construction_and_assignment_test();
168 value_after_move_construction_and_assignment_test();
169 increment_resets_value();
170 pop_does_not_reset_value();
171
172 return 0;
173 }