14 def testVisitdir(self): |
14 def testVisitdir(self): |
15 m = matchmod.basematcher('', '') |
15 m = matchmod.basematcher('', '') |
16 self.assertTrue(m.visitdir('.')) |
16 self.assertTrue(m.visitdir('.')) |
17 self.assertTrue(m.visitdir('dir')) |
17 self.assertTrue(m.visitdir('dir')) |
18 |
18 |
|
19 def testVisitchildrenset(self): |
|
20 m = matchmod.basematcher('', '') |
|
21 self.assertEqual(m.visitchildrenset('.'), 'this') |
|
22 self.assertEqual(m.visitchildrenset('dir'), 'this') |
|
23 |
19 class AlwaysMatcherTests(unittest.TestCase): |
24 class AlwaysMatcherTests(unittest.TestCase): |
20 |
25 |
21 def testVisitdir(self): |
26 def testVisitdir(self): |
22 m = matchmod.alwaysmatcher('', '') |
27 m = matchmod.alwaysmatcher('', '') |
23 self.assertEqual(m.visitdir('.'), 'all') |
28 self.assertEqual(m.visitdir('.'), 'all') |
24 self.assertEqual(m.visitdir('dir'), 'all') |
29 self.assertEqual(m.visitdir('dir'), 'all') |
25 |
30 |
|
31 def testVisitchildrenset(self): |
|
32 m = matchmod.alwaysmatcher('', '') |
|
33 self.assertEqual(m.visitchildrenset('.'), 'all') |
|
34 self.assertEqual(m.visitchildrenset('dir'), 'all') |
|
35 |
26 class NeverMatcherTests(unittest.TestCase): |
36 class NeverMatcherTests(unittest.TestCase): |
27 |
37 |
28 def testVisitdir(self): |
38 def testVisitdir(self): |
29 m = matchmod.nevermatcher('', '') |
39 m = matchmod.nevermatcher('', '') |
30 self.assertFalse(m.visitdir('.')) |
40 self.assertFalse(m.visitdir('.')) |
31 self.assertFalse(m.visitdir('dir')) |
41 self.assertFalse(m.visitdir('dir')) |
32 |
42 |
|
43 def testVisitchildrenset(self): |
|
44 m = matchmod.nevermatcher('', '') |
|
45 self.assertEqual(m.visitchildrenset('.'), set()) |
|
46 self.assertEqual(m.visitchildrenset('dir'), set()) |
|
47 |
33 class PredicateMatcherTests(unittest.TestCase): |
48 class PredicateMatcherTests(unittest.TestCase): |
34 # predicatematcher does not currently define either of these methods, so |
49 # predicatematcher does not currently define either of these methods, so |
35 # this is equivalent to BaseMatcherTests. |
50 # this is equivalent to BaseMatcherTests. |
36 |
51 |
37 def testVisitdir(self): |
52 def testVisitdir(self): |
38 m = matchmod.predicatematcher('', '', lambda *a: False) |
53 m = matchmod.predicatematcher('', '', lambda *a: False) |
39 self.assertTrue(m.visitdir('.')) |
54 self.assertTrue(m.visitdir('.')) |
40 self.assertTrue(m.visitdir('dir')) |
55 self.assertTrue(m.visitdir('dir')) |
|
56 |
|
57 def testVisitchildrenset(self): |
|
58 m = matchmod.predicatematcher('', '', lambda *a: False) |
|
59 self.assertEqual(m.visitchildrenset('.'), 'this') |
|
60 self.assertEqual(m.visitchildrenset('dir'), 'this') |
41 |
61 |
42 class PatternMatcherTests(unittest.TestCase): |
62 class PatternMatcherTests(unittest.TestCase): |
43 |
63 |
44 def testVisitdirPrefix(self): |
64 def testVisitdirPrefix(self): |
45 m = matchmod.match('x', '', patterns=['path:dir/subdir']) |
65 m = matchmod.match('x', '', patterns=['path:dir/subdir']) |
49 self.assertEqual(m.visitdir('dir/subdir'), 'all') |
69 self.assertEqual(m.visitdir('dir/subdir'), 'all') |
50 # OPT: This should probably be 'all' if its parent is? |
70 # OPT: This should probably be 'all' if its parent is? |
51 self.assertTrue(m.visitdir('dir/subdir/x')) |
71 self.assertTrue(m.visitdir('dir/subdir/x')) |
52 self.assertFalse(m.visitdir('folder')) |
72 self.assertFalse(m.visitdir('folder')) |
53 |
73 |
|
74 def testVisitchildrensetPrefix(self): |
|
75 m = matchmod.match('x', '', patterns=['path:dir/subdir']) |
|
76 assert isinstance(m, matchmod.patternmatcher) |
|
77 self.assertEqual(m.visitchildrenset('.'), 'this') |
|
78 self.assertEqual(m.visitchildrenset('dir'), 'this') |
|
79 self.assertEqual(m.visitchildrenset('dir/subdir'), 'all') |
|
80 # OPT: This should probably be 'all' if its parent is? |
|
81 self.assertEqual(m.visitchildrenset('dir/subdir/x'), 'this') |
|
82 self.assertEqual(m.visitchildrenset('folder'), set()) |
|
83 |
54 def testVisitdirRootfilesin(self): |
84 def testVisitdirRootfilesin(self): |
55 m = matchmod.match('x', '', patterns=['rootfilesin:dir/subdir']) |
85 m = matchmod.match('x', '', patterns=['rootfilesin:dir/subdir']) |
56 assert isinstance(m, matchmod.patternmatcher) |
86 assert isinstance(m, matchmod.patternmatcher) |
57 self.assertTrue(m.visitdir('.')) |
87 self.assertTrue(m.visitdir('.')) |
58 self.assertFalse(m.visitdir('dir/subdir/x')) |
88 self.assertFalse(m.visitdir('dir/subdir/x')) |
59 self.assertFalse(m.visitdir('folder')) |
89 self.assertFalse(m.visitdir('folder')) |
60 # FIXME: These should probably be True. |
90 # FIXME: These should probably be True. |
61 self.assertFalse(m.visitdir('dir')) |
91 self.assertFalse(m.visitdir('dir')) |
62 self.assertFalse(m.visitdir('dir/subdir')) |
92 self.assertFalse(m.visitdir('dir/subdir')) |
63 |
93 |
|
94 def testVisitchildrensetRootfilesin(self): |
|
95 m = matchmod.match('x', '', patterns=['rootfilesin:dir/subdir']) |
|
96 assert isinstance(m, matchmod.patternmatcher) |
|
97 self.assertEqual(m.visitchildrenset('.'), 'this') |
|
98 self.assertEqual(m.visitchildrenset('dir/subdir/x'), set()) |
|
99 self.assertEqual(m.visitchildrenset('folder'), set()) |
|
100 self.assertEqual(m.visitchildrenset('dir'), set()) |
|
101 self.assertEqual(m.visitchildrenset('dir/subdir'), set()) |
|
102 |
64 def testVisitdirGlob(self): |
103 def testVisitdirGlob(self): |
65 m = matchmod.match('x', '', patterns=['glob:dir/z*']) |
104 m = matchmod.match('x', '', patterns=['glob:dir/z*']) |
66 assert isinstance(m, matchmod.patternmatcher) |
105 assert isinstance(m, matchmod.patternmatcher) |
67 self.assertTrue(m.visitdir('.')) |
106 self.assertTrue(m.visitdir('.')) |
68 self.assertTrue(m.visitdir('dir')) |
107 self.assertTrue(m.visitdir('dir')) |
69 self.assertFalse(m.visitdir('folder')) |
108 self.assertFalse(m.visitdir('folder')) |
70 # OPT: these should probably be False. |
109 # OPT: these should probably be False. |
71 self.assertTrue(m.visitdir('dir/subdir')) |
110 self.assertTrue(m.visitdir('dir/subdir')) |
72 self.assertTrue(m.visitdir('dir/subdir/x')) |
111 self.assertTrue(m.visitdir('dir/subdir/x')) |
73 |
112 |
|
113 def testVisitchildrensetGlob(self): |
|
114 m = matchmod.match('x', '', patterns=['glob:dir/z*']) |
|
115 assert isinstance(m, matchmod.patternmatcher) |
|
116 self.assertEqual(m.visitchildrenset('.'), 'this') |
|
117 self.assertEqual(m.visitchildrenset('folder'), set()) |
|
118 self.assertEqual(m.visitchildrenset('dir'), 'this') |
|
119 # OPT: these should probably be set(). |
|
120 self.assertEqual(m.visitchildrenset('dir/subdir'), 'this') |
|
121 self.assertEqual(m.visitchildrenset('dir/subdir/x'), 'this') |
|
122 |
74 class IncludeMatcherTests(unittest.TestCase): |
123 class IncludeMatcherTests(unittest.TestCase): |
75 |
124 |
76 def testVisitdirPrefix(self): |
125 def testVisitdirPrefix(self): |
77 m = matchmod.match('x', '', include=['path:dir/subdir']) |
126 m = matchmod.match('x', '', include=['path:dir/subdir']) |
78 assert isinstance(m, matchmod.includematcher) |
127 assert isinstance(m, matchmod.includematcher) |
81 self.assertEqual(m.visitdir('dir/subdir'), 'all') |
130 self.assertEqual(m.visitdir('dir/subdir'), 'all') |
82 # OPT: This should probably be 'all' if its parent is? |
131 # OPT: This should probably be 'all' if its parent is? |
83 self.assertTrue(m.visitdir('dir/subdir/x')) |
132 self.assertTrue(m.visitdir('dir/subdir/x')) |
84 self.assertFalse(m.visitdir('folder')) |
133 self.assertFalse(m.visitdir('folder')) |
85 |
134 |
|
135 def testVisitchildrensetPrefix(self): |
|
136 m = matchmod.match('x', '', include=['path:dir/subdir']) |
|
137 assert isinstance(m, matchmod.includematcher) |
|
138 self.assertEqual(m.visitchildrenset('.'), {'dir'}) |
|
139 self.assertEqual(m.visitchildrenset('dir'), {'subdir'}) |
|
140 self.assertEqual(m.visitchildrenset('dir/subdir'), 'all') |
|
141 # OPT: This should probably be 'all' if its parent is? |
|
142 self.assertEqual(m.visitchildrenset('dir/subdir/x'), 'this') |
|
143 self.assertEqual(m.visitchildrenset('folder'), set()) |
|
144 |
86 def testVisitdirRootfilesin(self): |
145 def testVisitdirRootfilesin(self): |
87 m = matchmod.match('x', '', include=['rootfilesin:dir/subdir']) |
146 m = matchmod.match('x', '', include=['rootfilesin:dir/subdir']) |
88 assert isinstance(m, matchmod.includematcher) |
147 assert isinstance(m, matchmod.includematcher) |
89 self.assertTrue(m.visitdir('.')) |
148 self.assertTrue(m.visitdir('.')) |
90 self.assertTrue(m.visitdir('dir')) |
149 self.assertTrue(m.visitdir('dir')) |
91 self.assertTrue(m.visitdir('dir/subdir')) |
150 self.assertTrue(m.visitdir('dir/subdir')) |
92 self.assertFalse(m.visitdir('dir/subdir/x')) |
151 self.assertFalse(m.visitdir('dir/subdir/x')) |
93 self.assertFalse(m.visitdir('folder')) |
152 self.assertFalse(m.visitdir('folder')) |
|
153 |
|
154 def testVisitchildrensetRootfilesin(self): |
|
155 m = matchmod.match('x', '', include=['rootfilesin:dir/subdir']) |
|
156 assert isinstance(m, matchmod.includematcher) |
|
157 self.assertEqual(m.visitchildrenset('.'), {'dir'}) |
|
158 self.assertEqual(m.visitchildrenset('dir'), {'subdir'}) |
|
159 self.assertEqual(m.visitchildrenset('dir/subdir'), 'this') |
|
160 self.assertEqual(m.visitchildrenset('dir/subdir/x'), set()) |
|
161 self.assertEqual(m.visitchildrenset('folder'), set()) |
94 |
162 |
95 def testVisitdirGlob(self): |
163 def testVisitdirGlob(self): |
96 m = matchmod.match('x', '', include=['glob:dir/z*']) |
164 m = matchmod.match('x', '', include=['glob:dir/z*']) |
97 assert isinstance(m, matchmod.includematcher) |
165 assert isinstance(m, matchmod.includematcher) |
98 self.assertTrue(m.visitdir('.')) |
166 self.assertTrue(m.visitdir('.')) |
99 self.assertTrue(m.visitdir('dir')) |
167 self.assertTrue(m.visitdir('dir')) |
100 self.assertFalse(m.visitdir('folder')) |
168 self.assertFalse(m.visitdir('folder')) |
101 # OPT: these should probably be False. |
169 # OPT: these should probably be False. |
102 self.assertTrue(m.visitdir('dir/subdir')) |
170 self.assertTrue(m.visitdir('dir/subdir')) |
103 self.assertTrue(m.visitdir('dir/subdir/x')) |
171 self.assertTrue(m.visitdir('dir/subdir/x')) |
|
172 |
|
173 def testVisitchildrensetGlob(self): |
|
174 m = matchmod.match('x', '', include=['glob:dir/z*']) |
|
175 assert isinstance(m, matchmod.includematcher) |
|
176 self.assertEqual(m.visitchildrenset('.'), {'dir'}) |
|
177 self.assertEqual(m.visitchildrenset('folder'), set()) |
|
178 self.assertEqual(m.visitchildrenset('dir'), 'this') |
|
179 # OPT: these should probably be set(). |
|
180 self.assertEqual(m.visitchildrenset('dir/subdir'), 'this') |
|
181 self.assertEqual(m.visitchildrenset('dir/subdir/x'), 'this') |
104 |
182 |
105 class ExactMatcherTests(unittest.TestCase): |
183 class ExactMatcherTests(unittest.TestCase): |
106 |
184 |
107 def testVisitdir(self): |
185 def testVisitdir(self): |
108 m = matchmod.match('x', '', patterns=['dir/subdir/foo.txt'], exact=True) |
186 m = matchmod.match('x', '', patterns=['dir/subdir/foo.txt'], exact=True) |
113 self.assertFalse(m.visitdir('dir/subdir/foo.txt')) |
191 self.assertFalse(m.visitdir('dir/subdir/foo.txt')) |
114 self.assertFalse(m.visitdir('dir/foo')) |
192 self.assertFalse(m.visitdir('dir/foo')) |
115 self.assertFalse(m.visitdir('dir/subdir/x')) |
193 self.assertFalse(m.visitdir('dir/subdir/x')) |
116 self.assertFalse(m.visitdir('folder')) |
194 self.assertFalse(m.visitdir('folder')) |
117 |
195 |
|
196 def testVisitchildrenset(self): |
|
197 m = matchmod.match('x', '', patterns=['dir/subdir/foo.txt'], exact=True) |
|
198 assert isinstance(m, matchmod.exactmatcher) |
|
199 self.assertEqual(m.visitchildrenset('.'), {'dir'}) |
|
200 self.assertEqual(m.visitchildrenset('dir'), {'subdir'}) |
|
201 self.assertEqual(m.visitchildrenset('dir/subdir'), 'this') |
|
202 self.assertEqual(m.visitchildrenset('dir/subdir/x'), set()) |
|
203 self.assertEqual(m.visitchildrenset('dir/subdir/foo.txt'), set()) |
|
204 self.assertEqual(m.visitchildrenset('folder'), set()) |
|
205 |
118 class DifferenceMatcherTests(unittest.TestCase): |
206 class DifferenceMatcherTests(unittest.TestCase): |
119 |
207 |
120 def testVisitdirM2always(self): |
208 def testVisitdirM2always(self): |
121 m1 = matchmod.alwaysmatcher('', '') |
209 m1 = matchmod.alwaysmatcher('', '') |
122 m2 = matchmod.alwaysmatcher('', '') |
210 m2 = matchmod.alwaysmatcher('', '') |
127 self.assertFalse(dm.visitdir('dir/subdir')) |
215 self.assertFalse(dm.visitdir('dir/subdir')) |
128 self.assertFalse(dm.visitdir('dir/subdir/z')) |
216 self.assertFalse(dm.visitdir('dir/subdir/z')) |
129 self.assertFalse(dm.visitdir('dir/foo')) |
217 self.assertFalse(dm.visitdir('dir/foo')) |
130 self.assertFalse(dm.visitdir('dir/subdir/x')) |
218 self.assertFalse(dm.visitdir('dir/subdir/x')) |
131 self.assertFalse(dm.visitdir('folder')) |
219 self.assertFalse(dm.visitdir('folder')) |
|
220 |
|
221 def testVisitchildrensetM2always(self): |
|
222 m1 = matchmod.alwaysmatcher('', '') |
|
223 m2 = matchmod.alwaysmatcher('', '') |
|
224 dm = matchmod.differencematcher(m1, m2) |
|
225 # dm should be equivalent to a nevermatcher. |
|
226 self.assertEqual(dm.visitchildrenset('.'), set()) |
|
227 self.assertEqual(dm.visitchildrenset('dir'), set()) |
|
228 self.assertEqual(dm.visitchildrenset('dir/subdir'), set()) |
|
229 self.assertEqual(dm.visitchildrenset('dir/subdir/z'), set()) |
|
230 self.assertEqual(dm.visitchildrenset('dir/foo'), set()) |
|
231 self.assertEqual(dm.visitchildrenset('dir/subdir/x'), set()) |
|
232 self.assertEqual(dm.visitchildrenset('folder'), set()) |
132 |
233 |
133 def testVisitdirM2never(self): |
234 def testVisitdirM2never(self): |
134 m1 = matchmod.alwaysmatcher('', '') |
235 m1 = matchmod.alwaysmatcher('', '') |
135 m2 = matchmod.nevermatcher('', '') |
236 m2 = matchmod.nevermatcher('', '') |
136 dm = matchmod.differencematcher(m1, m2) |
237 dm = matchmod.differencematcher(m1, m2) |
147 self.assertEqual(dm.visitdir('dir/subdir/z'), True) |
248 self.assertEqual(dm.visitdir('dir/subdir/z'), True) |
148 self.assertEqual(dm.visitdir('dir/foo'), True) |
249 self.assertEqual(dm.visitdir('dir/foo'), True) |
149 self.assertEqual(dm.visitdir('dir/subdir/x'), True) |
250 self.assertEqual(dm.visitdir('dir/subdir/x'), True) |
150 self.assertEqual(dm.visitdir('folder'), True) |
251 self.assertEqual(dm.visitdir('folder'), True) |
151 |
252 |
|
253 def testVisitchildrensetM2never(self): |
|
254 m1 = matchmod.alwaysmatcher('', '') |
|
255 m2 = matchmod.nevermatcher('', '') |
|
256 dm = matchmod.differencematcher(m1, m2) |
|
257 # dm should be equivalent to a alwaysmatcher. |
|
258 self.assertEqual(dm.visitchildrenset('.'), 'all') |
|
259 self.assertEqual(dm.visitchildrenset('dir'), 'all') |
|
260 self.assertEqual(dm.visitchildrenset('dir/subdir'), 'all') |
|
261 self.assertEqual(dm.visitchildrenset('dir/subdir/z'), 'all') |
|
262 self.assertEqual(dm.visitchildrenset('dir/foo'), 'all') |
|
263 self.assertEqual(dm.visitchildrenset('dir/subdir/x'), 'all') |
|
264 self.assertEqual(dm.visitchildrenset('folder'), 'all') |
|
265 |
152 def testVisitdirM2SubdirPrefix(self): |
266 def testVisitdirM2SubdirPrefix(self): |
153 m1 = matchmod.alwaysmatcher('', '') |
267 m1 = matchmod.alwaysmatcher('', '') |
154 m2 = matchmod.match('', '', patterns=['path:dir/subdir']) |
268 m2 = matchmod.match('', '', patterns=['path:dir/subdir']) |
155 dm = matchmod.differencematcher(m1, m2) |
269 dm = matchmod.differencematcher(m1, m2) |
156 self.assertEqual(dm.visitdir('.'), True) |
270 self.assertEqual(dm.visitdir('.'), True) |
163 self.assertEqual(dm.visitdir('dir/subdir/x'), True) |
277 self.assertEqual(dm.visitdir('dir/subdir/x'), True) |
164 # OPT: We could return 'all' for these. |
278 # OPT: We could return 'all' for these. |
165 self.assertEqual(dm.visitdir('dir/foo'), True) |
279 self.assertEqual(dm.visitdir('dir/foo'), True) |
166 self.assertEqual(dm.visitdir('folder'), True) |
280 self.assertEqual(dm.visitdir('folder'), True) |
167 |
281 |
|
282 def testVisitchildrensetM2SubdirPrefix(self): |
|
283 m1 = matchmod.alwaysmatcher('', '') |
|
284 m2 = matchmod.match('', '', patterns=['path:dir/subdir']) |
|
285 dm = matchmod.differencematcher(m1, m2) |
|
286 self.assertEqual(dm.visitchildrenset('.'), 'this') |
|
287 self.assertEqual(dm.visitchildrenset('dir'), 'this') |
|
288 self.assertEqual(dm.visitchildrenset('dir/subdir'), set()) |
|
289 self.assertEqual(dm.visitchildrenset('dir/foo'), 'all') |
|
290 self.assertEqual(dm.visitchildrenset('folder'), 'all') |
|
291 # OPT: We should probably return set() for these; we don't because |
|
292 # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of |
|
293 # an 'all' pattern, just 'this'. |
|
294 self.assertEqual(dm.visitchildrenset('dir/subdir/z'), 'this') |
|
295 self.assertEqual(dm.visitchildrenset('dir/subdir/x'), 'this') |
|
296 |
168 # We're using includematcher instead of patterns because it behaves slightly |
297 # We're using includematcher instead of patterns because it behaves slightly |
169 # better (giving narrower results) than patternmatcher. |
298 # better (giving narrower results) than patternmatcher. |
170 def testVisitdirIncludeIncludfe(self): |
299 def testVisitdirIncludeIncludfe(self): |
171 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
300 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
172 m2 = matchmod.match('', '', include=['rootfilesin:dir']) |
301 m2 = matchmod.match('', '', include=['rootfilesin:dir']) |
180 # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of |
309 # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of |
181 # an 'all' pattern, just True. |
310 # an 'all' pattern, just True. |
182 self.assertEqual(dm.visitdir('dir/subdir/z'), True) |
311 self.assertEqual(dm.visitdir('dir/subdir/z'), True) |
183 self.assertEqual(dm.visitdir('dir/subdir/x'), True) |
312 self.assertEqual(dm.visitdir('dir/subdir/x'), True) |
184 |
313 |
|
314 def testVisitchildrensetIncludeInclude(self): |
|
315 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
|
316 m2 = matchmod.match('', '', include=['rootfilesin:dir']) |
|
317 dm = matchmod.differencematcher(m1, m2) |
|
318 self.assertEqual(dm.visitchildrenset('.'), {'dir'}) |
|
319 self.assertEqual(dm.visitchildrenset('dir'), {'subdir'}) |
|
320 self.assertEqual(dm.visitchildrenset('dir/subdir'), 'all') |
|
321 self.assertEqual(dm.visitchildrenset('dir/foo'), set()) |
|
322 self.assertEqual(dm.visitchildrenset('folder'), set()) |
|
323 # OPT: We should probably return set() for these; we don't because |
|
324 # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of |
|
325 # an 'all' pattern, just 'this'. |
|
326 self.assertEqual(dm.visitchildrenset('dir/subdir/z'), 'this') |
|
327 self.assertEqual(dm.visitchildrenset('dir/subdir/x'), 'this') |
|
328 |
185 class IntersectionMatcherTests(unittest.TestCase): |
329 class IntersectionMatcherTests(unittest.TestCase): |
186 |
330 |
187 def testVisitdirM2always(self): |
331 def testVisitdirM2always(self): |
188 m1 = matchmod.alwaysmatcher('', '') |
332 m1 = matchmod.alwaysmatcher('', '') |
189 m2 = matchmod.alwaysmatcher('', '') |
333 m2 = matchmod.alwaysmatcher('', '') |
195 self.assertEqual(im.visitdir('dir/subdir/z'), 'all') |
339 self.assertEqual(im.visitdir('dir/subdir/z'), 'all') |
196 self.assertEqual(im.visitdir('dir/foo'), 'all') |
340 self.assertEqual(im.visitdir('dir/foo'), 'all') |
197 self.assertEqual(im.visitdir('dir/subdir/x'), 'all') |
341 self.assertEqual(im.visitdir('dir/subdir/x'), 'all') |
198 self.assertEqual(im.visitdir('folder'), 'all') |
342 self.assertEqual(im.visitdir('folder'), 'all') |
199 |
343 |
|
344 def testVisitchildrensetM2always(self): |
|
345 m1 = matchmod.alwaysmatcher('', '') |
|
346 m2 = matchmod.alwaysmatcher('', '') |
|
347 im = matchmod.intersectmatchers(m1, m2) |
|
348 # im should be equivalent to a alwaysmatcher. |
|
349 self.assertEqual(im.visitchildrenset('.'), 'all') |
|
350 self.assertEqual(im.visitchildrenset('dir'), 'all') |
|
351 self.assertEqual(im.visitchildrenset('dir/subdir'), 'all') |
|
352 self.assertEqual(im.visitchildrenset('dir/subdir/z'), 'all') |
|
353 self.assertEqual(im.visitchildrenset('dir/foo'), 'all') |
|
354 self.assertEqual(im.visitchildrenset('dir/subdir/x'), 'all') |
|
355 self.assertEqual(im.visitchildrenset('folder'), 'all') |
|
356 |
200 def testVisitdirM2never(self): |
357 def testVisitdirM2never(self): |
201 m1 = matchmod.alwaysmatcher('', '') |
358 m1 = matchmod.alwaysmatcher('', '') |
202 m2 = matchmod.nevermatcher('', '') |
359 m2 = matchmod.nevermatcher('', '') |
203 im = matchmod.intersectmatchers(m1, m2) |
360 im = matchmod.intersectmatchers(m1, m2) |
204 # im should be equivalent to a nevermatcher. |
361 # im should be equivalent to a nevermatcher. |
207 self.assertFalse(im.visitdir('dir/subdir')) |
364 self.assertFalse(im.visitdir('dir/subdir')) |
208 self.assertFalse(im.visitdir('dir/subdir/z')) |
365 self.assertFalse(im.visitdir('dir/subdir/z')) |
209 self.assertFalse(im.visitdir('dir/foo')) |
366 self.assertFalse(im.visitdir('dir/foo')) |
210 self.assertFalse(im.visitdir('dir/subdir/x')) |
367 self.assertFalse(im.visitdir('dir/subdir/x')) |
211 self.assertFalse(im.visitdir('folder')) |
368 self.assertFalse(im.visitdir('folder')) |
|
369 |
|
370 def testVisitchildrensetM2never(self): |
|
371 m1 = matchmod.alwaysmatcher('', '') |
|
372 m2 = matchmod.nevermatcher('', '') |
|
373 im = matchmod.intersectmatchers(m1, m2) |
|
374 # im should be equivalent to a nevermqtcher. |
|
375 self.assertEqual(im.visitchildrenset('.'), set()) |
|
376 self.assertEqual(im.visitchildrenset('dir'), set()) |
|
377 self.assertEqual(im.visitchildrenset('dir/subdir'), set()) |
|
378 self.assertEqual(im.visitchildrenset('dir/subdir/z'), set()) |
|
379 self.assertEqual(im.visitchildrenset('dir/foo'), set()) |
|
380 self.assertEqual(im.visitchildrenset('dir/subdir/x'), set()) |
|
381 self.assertEqual(im.visitchildrenset('folder'), set()) |
212 |
382 |
213 def testVisitdirM2SubdirPrefix(self): |
383 def testVisitdirM2SubdirPrefix(self): |
214 m1 = matchmod.alwaysmatcher('', '') |
384 m1 = matchmod.alwaysmatcher('', '') |
215 m2 = matchmod.match('', '', patterns=['path:dir/subdir']) |
385 m2 = matchmod.match('', '', patterns=['path:dir/subdir']) |
216 im = matchmod.intersectmatchers(m1, m2) |
386 im = matchmod.intersectmatchers(m1, m2) |
223 # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of |
393 # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of |
224 # an 'all' pattern, just True. |
394 # an 'all' pattern, just True. |
225 self.assertEqual(im.visitdir('dir/subdir/z'), True) |
395 self.assertEqual(im.visitdir('dir/subdir/z'), True) |
226 self.assertEqual(im.visitdir('dir/subdir/x'), True) |
396 self.assertEqual(im.visitdir('dir/subdir/x'), True) |
227 |
397 |
|
398 def testVisitchildrensetM2SubdirPrefix(self): |
|
399 m1 = matchmod.alwaysmatcher('', '') |
|
400 m2 = matchmod.match('', '', include=['path:dir/subdir']) |
|
401 im = matchmod.intersectmatchers(m1, m2) |
|
402 self.assertEqual(im.visitchildrenset('.'), {'dir'}) |
|
403 self.assertEqual(im.visitchildrenset('dir'), {'subdir'}) |
|
404 self.assertEqual(im.visitchildrenset('dir/subdir'), 'all') |
|
405 self.assertEqual(im.visitchildrenset('dir/foo'), set()) |
|
406 self.assertEqual(im.visitchildrenset('folder'), set()) |
|
407 # OPT: We should probably return 'all' for these |
|
408 self.assertEqual(im.visitchildrenset('dir/subdir/z'), 'this') |
|
409 self.assertEqual(im.visitchildrenset('dir/subdir/x'), 'this') |
|
410 |
228 # We're using includematcher instead of patterns because it behaves slightly |
411 # We're using includematcher instead of patterns because it behaves slightly |
229 # better (giving narrower results) than patternmatcher. |
412 # better (giving narrower results) than patternmatcher. |
230 def testVisitdirIncludeIncludfe(self): |
413 def testVisitdirIncludeIncludfe(self): |
231 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
414 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
232 m2 = matchmod.match('', '', include=['rootfilesin:dir']) |
415 m2 = matchmod.match('', '', include=['rootfilesin:dir']) |
236 self.assertFalse(im.visitdir('dir/subdir')) |
419 self.assertFalse(im.visitdir('dir/subdir')) |
237 self.assertFalse(im.visitdir('dir/foo')) |
420 self.assertFalse(im.visitdir('dir/foo')) |
238 self.assertFalse(im.visitdir('folder')) |
421 self.assertFalse(im.visitdir('folder')) |
239 self.assertFalse(im.visitdir('dir/subdir/z')) |
422 self.assertFalse(im.visitdir('dir/subdir/z')) |
240 self.assertFalse(im.visitdir('dir/subdir/x')) |
423 self.assertFalse(im.visitdir('dir/subdir/x')) |
|
424 |
|
425 def testVisitchildrensetIncludeInclude(self): |
|
426 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
|
427 m2 = matchmod.match('', '', include=['rootfilesin:dir']) |
|
428 im = matchmod.intersectmatchers(m1, m2) |
|
429 self.assertEqual(im.visitchildrenset('.'), {'dir'}) |
|
430 self.assertEqual(im.visitchildrenset('dir'), 'this') |
|
431 self.assertEqual(im.visitchildrenset('dir/subdir'), set()) |
|
432 self.assertEqual(im.visitchildrenset('dir/foo'), set()) |
|
433 self.assertEqual(im.visitchildrenset('folder'), set()) |
|
434 self.assertEqual(im.visitchildrenset('dir/subdir/z'), set()) |
|
435 self.assertEqual(im.visitchildrenset('dir/subdir/x'), set()) |
241 |
436 |
242 # We're using includematcher instead of patterns because it behaves slightly |
437 # We're using includematcher instead of patterns because it behaves slightly |
243 # better (giving narrower results) than patternmatcher. |
438 # better (giving narrower results) than patternmatcher. |
244 def testVisitdirIncludeInclude2(self): |
439 def testVisitdirIncludeInclude2(self): |
245 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
440 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
252 self.assertFalse(im.visitdir('dir/foo')) |
447 self.assertFalse(im.visitdir('dir/foo')) |
253 self.assertFalse(im.visitdir('folder')) |
448 self.assertFalse(im.visitdir('folder')) |
254 self.assertFalse(im.visitdir('dir/subdir/z')) |
449 self.assertFalse(im.visitdir('dir/subdir/z')) |
255 self.assertFalse(im.visitdir('dir/subdir/x')) |
450 self.assertFalse(im.visitdir('dir/subdir/x')) |
256 |
451 |
|
452 def testVisitchildrensetIncludeInclude2(self): |
|
453 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
|
454 m2 = matchmod.match('', '', include=['path:folder']) |
|
455 im = matchmod.intersectmatchers(m1, m2) |
|
456 # FIXME: is set() correct here? |
|
457 self.assertEqual(im.visitchildrenset('.'), set()) |
|
458 self.assertEqual(im.visitchildrenset('dir'), set()) |
|
459 self.assertEqual(im.visitchildrenset('dir/subdir'), set()) |
|
460 self.assertEqual(im.visitchildrenset('dir/foo'), set()) |
|
461 self.assertEqual(im.visitchildrenset('folder'), set()) |
|
462 self.assertEqual(im.visitchildrenset('dir/subdir/z'), set()) |
|
463 self.assertEqual(im.visitchildrenset('dir/subdir/x'), set()) |
|
464 |
257 # We're using includematcher instead of patterns because it behaves slightly |
465 # We're using includematcher instead of patterns because it behaves slightly |
258 # better (giving narrower results) than patternmatcher. |
466 # better (giving narrower results) than patternmatcher. |
259 def testVisitdirIncludeInclude3(self): |
467 def testVisitdirIncludeInclude3(self): |
260 m1 = matchmod.match('', '', include=['path:dir/subdir/x']) |
468 m1 = matchmod.match('', '', include=['path:dir/subdir/x']) |
261 m2 = matchmod.match('', '', include=['path:dir/subdir']) |
469 m2 = matchmod.match('', '', include=['path:dir/subdir']) |
267 self.assertFalse(im.visitdir('folder')) |
475 self.assertFalse(im.visitdir('folder')) |
268 self.assertFalse(im.visitdir('dir/subdir/z')) |
476 self.assertFalse(im.visitdir('dir/subdir/z')) |
269 # OPT: this should probably be 'all' not True. |
477 # OPT: this should probably be 'all' not True. |
270 self.assertEqual(im.visitdir('dir/subdir/x'), True) |
478 self.assertEqual(im.visitdir('dir/subdir/x'), True) |
271 |
479 |
|
480 def testVisitchildrensetIncludeInclude3(self): |
|
481 m1 = matchmod.match('', '', include=['path:dir/subdir/x']) |
|
482 m2 = matchmod.match('', '', include=['path:dir/subdir']) |
|
483 im = matchmod.intersectmatchers(m1, m2) |
|
484 self.assertEqual(im.visitchildrenset('.'), {'dir'}) |
|
485 self.assertEqual(im.visitchildrenset('dir'), {'subdir'}) |
|
486 self.assertEqual(im.visitchildrenset('dir/subdir'), {'x'}) |
|
487 self.assertEqual(im.visitchildrenset('dir/foo'), set()) |
|
488 self.assertEqual(im.visitchildrenset('folder'), set()) |
|
489 self.assertEqual(im.visitchildrenset('dir/subdir/z'), set()) |
|
490 # OPT: this should probably be 'all' not 'this'. |
|
491 self.assertEqual(im.visitchildrenset('dir/subdir/x'), 'this') |
|
492 |
272 # We're using includematcher instead of patterns because it behaves slightly |
493 # We're using includematcher instead of patterns because it behaves slightly |
273 # better (giving narrower results) than patternmatcher. |
494 # better (giving narrower results) than patternmatcher. |
274 def testVisitdirIncludeInclude4(self): |
495 def testVisitdirIncludeInclude4(self): |
275 m1 = matchmod.match('', '', include=['path:dir/subdir/x']) |
496 m1 = matchmod.match('', '', include=['path:dir/subdir/x']) |
276 m2 = matchmod.match('', '', include=['path:dir/subdir/z']) |
497 m2 = matchmod.match('', '', include=['path:dir/subdir/z']) |
282 self.assertFalse(im.visitdir('dir/foo')) |
503 self.assertFalse(im.visitdir('dir/foo')) |
283 self.assertFalse(im.visitdir('folder')) |
504 self.assertFalse(im.visitdir('folder')) |
284 self.assertFalse(im.visitdir('dir/subdir/z')) |
505 self.assertFalse(im.visitdir('dir/subdir/z')) |
285 self.assertFalse(im.visitdir('dir/subdir/x')) |
506 self.assertFalse(im.visitdir('dir/subdir/x')) |
286 |
507 |
|
508 def testVisitchildrensetIncludeInclude4(self): |
|
509 m1 = matchmod.match('', '', include=['path:dir/subdir/x']) |
|
510 m2 = matchmod.match('', '', include=['path:dir/subdir/z']) |
|
511 im = matchmod.intersectmatchers(m1, m2) |
|
512 # OPT: these next two could probably be set() as well. |
|
513 self.assertEqual(im.visitchildrenset('.'), {'dir'}) |
|
514 self.assertEqual(im.visitchildrenset('dir'), {'subdir'}) |
|
515 self.assertEqual(im.visitchildrenset('dir/subdir'), set()) |
|
516 self.assertEqual(im.visitchildrenset('dir/foo'), set()) |
|
517 self.assertEqual(im.visitchildrenset('folder'), set()) |
|
518 self.assertEqual(im.visitchildrenset('dir/subdir/z'), set()) |
|
519 self.assertEqual(im.visitchildrenset('dir/subdir/x'), set()) |
|
520 |
287 class UnionMatcherTests(unittest.TestCase): |
521 class UnionMatcherTests(unittest.TestCase): |
288 |
522 |
289 def testVisitdirM2always(self): |
523 def testVisitdirM2always(self): |
290 m1 = matchmod.alwaysmatcher('', '') |
524 m1 = matchmod.alwaysmatcher('', '') |
291 m2 = matchmod.alwaysmatcher('', '') |
525 m2 = matchmod.alwaysmatcher('', '') |
297 self.assertEqual(um.visitdir('dir/subdir/z'), 'all') |
531 self.assertEqual(um.visitdir('dir/subdir/z'), 'all') |
298 self.assertEqual(um.visitdir('dir/foo'), 'all') |
532 self.assertEqual(um.visitdir('dir/foo'), 'all') |
299 self.assertEqual(um.visitdir('dir/subdir/x'), 'all') |
533 self.assertEqual(um.visitdir('dir/subdir/x'), 'all') |
300 self.assertEqual(um.visitdir('folder'), 'all') |
534 self.assertEqual(um.visitdir('folder'), 'all') |
301 |
535 |
|
536 def testVisitchildrensetM2always(self): |
|
537 m1 = matchmod.alwaysmatcher('', '') |
|
538 m2 = matchmod.alwaysmatcher('', '') |
|
539 um = matchmod.unionmatcher([m1, m2]) |
|
540 # um should be equivalent to a alwaysmatcher. |
|
541 self.assertEqual(um.visitchildrenset('.'), 'all') |
|
542 self.assertEqual(um.visitchildrenset('dir'), 'all') |
|
543 self.assertEqual(um.visitchildrenset('dir/subdir'), 'all') |
|
544 self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all') |
|
545 self.assertEqual(um.visitchildrenset('dir/foo'), 'all') |
|
546 self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all') |
|
547 self.assertEqual(um.visitchildrenset('folder'), 'all') |
|
548 |
302 def testVisitdirM1never(self): |
549 def testVisitdirM1never(self): |
303 m1 = matchmod.nevermatcher('', '') |
550 m1 = matchmod.nevermatcher('', '') |
304 m2 = matchmod.alwaysmatcher('', '') |
551 m2 = matchmod.alwaysmatcher('', '') |
305 um = matchmod.unionmatcher([m1, m2]) |
552 um = matchmod.unionmatcher([m1, m2]) |
306 # um should be equivalent to a alwaysmatcher. |
553 # um should be equivalent to a alwaysmatcher. |
310 self.assertEqual(um.visitdir('dir/subdir/z'), 'all') |
557 self.assertEqual(um.visitdir('dir/subdir/z'), 'all') |
311 self.assertEqual(um.visitdir('dir/foo'), 'all') |
558 self.assertEqual(um.visitdir('dir/foo'), 'all') |
312 self.assertEqual(um.visitdir('dir/subdir/x'), 'all') |
559 self.assertEqual(um.visitdir('dir/subdir/x'), 'all') |
313 self.assertEqual(um.visitdir('folder'), 'all') |
560 self.assertEqual(um.visitdir('folder'), 'all') |
314 |
561 |
|
562 def testVisitchildrensetM1never(self): |
|
563 m1 = matchmod.nevermatcher('', '') |
|
564 m2 = matchmod.alwaysmatcher('', '') |
|
565 um = matchmod.unionmatcher([m1, m2]) |
|
566 # um should be equivalent to a alwaysmatcher. |
|
567 self.assertEqual(um.visitchildrenset('.'), 'all') |
|
568 self.assertEqual(um.visitchildrenset('dir'), 'all') |
|
569 self.assertEqual(um.visitchildrenset('dir/subdir'), 'all') |
|
570 self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all') |
|
571 self.assertEqual(um.visitchildrenset('dir/foo'), 'all') |
|
572 self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all') |
|
573 self.assertEqual(um.visitchildrenset('folder'), 'all') |
|
574 |
315 def testVisitdirM2never(self): |
575 def testVisitdirM2never(self): |
316 m1 = matchmod.alwaysmatcher('', '') |
576 m1 = matchmod.alwaysmatcher('', '') |
317 m2 = matchmod.nevermatcher('', '') |
577 m2 = matchmod.nevermatcher('', '') |
318 um = matchmod.unionmatcher([m1, m2]) |
578 um = matchmod.unionmatcher([m1, m2]) |
319 # um should be equivalent to a alwaysmatcher. |
579 # um should be equivalent to a alwaysmatcher. |
323 self.assertEqual(um.visitdir('dir/subdir/z'), 'all') |
583 self.assertEqual(um.visitdir('dir/subdir/z'), 'all') |
324 self.assertEqual(um.visitdir('dir/foo'), 'all') |
584 self.assertEqual(um.visitdir('dir/foo'), 'all') |
325 self.assertEqual(um.visitdir('dir/subdir/x'), 'all') |
585 self.assertEqual(um.visitdir('dir/subdir/x'), 'all') |
326 self.assertEqual(um.visitdir('folder'), 'all') |
586 self.assertEqual(um.visitdir('folder'), 'all') |
327 |
587 |
|
588 def testVisitchildrensetM2never(self): |
|
589 m1 = matchmod.alwaysmatcher('', '') |
|
590 m2 = matchmod.nevermatcher('', '') |
|
591 um = matchmod.unionmatcher([m1, m2]) |
|
592 # um should be equivalent to a alwaysmatcher. |
|
593 self.assertEqual(um.visitchildrenset('.'), 'all') |
|
594 self.assertEqual(um.visitchildrenset('dir'), 'all') |
|
595 self.assertEqual(um.visitchildrenset('dir/subdir'), 'all') |
|
596 self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all') |
|
597 self.assertEqual(um.visitchildrenset('dir/foo'), 'all') |
|
598 self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all') |
|
599 self.assertEqual(um.visitchildrenset('folder'), 'all') |
|
600 |
328 def testVisitdirM2SubdirPrefix(self): |
601 def testVisitdirM2SubdirPrefix(self): |
329 m1 = matchmod.alwaysmatcher('', '') |
602 m1 = matchmod.alwaysmatcher('', '') |
330 m2 = matchmod.match('', '', patterns=['path:dir/subdir']) |
603 m2 = matchmod.match('', '', patterns=['path:dir/subdir']) |
331 um = matchmod.unionmatcher([m1, m2]) |
604 um = matchmod.unionmatcher([m1, m2]) |
332 self.assertEqual(um.visitdir('.'), 'all') |
605 self.assertEqual(um.visitdir('.'), 'all') |
334 self.assertEqual(um.visitdir('dir/subdir'), 'all') |
607 self.assertEqual(um.visitdir('dir/subdir'), 'all') |
335 self.assertEqual(um.visitdir('dir/foo'), 'all') |
608 self.assertEqual(um.visitdir('dir/foo'), 'all') |
336 self.assertEqual(um.visitdir('folder'), 'all') |
609 self.assertEqual(um.visitdir('folder'), 'all') |
337 self.assertEqual(um.visitdir('dir/subdir/z'), 'all') |
610 self.assertEqual(um.visitdir('dir/subdir/z'), 'all') |
338 self.assertEqual(um.visitdir('dir/subdir/x'), 'all') |
611 self.assertEqual(um.visitdir('dir/subdir/x'), 'all') |
|
612 |
|
613 def testVisitchildrensetM2SubdirPrefix(self): |
|
614 m1 = matchmod.alwaysmatcher('', '') |
|
615 m2 = matchmod.match('', '', include=['path:dir/subdir']) |
|
616 um = matchmod.unionmatcher([m1, m2]) |
|
617 self.assertEqual(um.visitchildrenset('.'), 'all') |
|
618 self.assertEqual(um.visitchildrenset('dir'), 'all') |
|
619 self.assertEqual(um.visitchildrenset('dir/subdir'), 'all') |
|
620 self.assertEqual(um.visitchildrenset('dir/foo'), 'all') |
|
621 self.assertEqual(um.visitchildrenset('folder'), 'all') |
|
622 self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all') |
|
623 self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all') |
339 |
624 |
340 # We're using includematcher instead of patterns because it behaves slightly |
625 # We're using includematcher instead of patterns because it behaves slightly |
341 # better (giving narrower results) than patternmatcher. |
626 # better (giving narrower results) than patternmatcher. |
342 def testVisitdirIncludeIncludfe(self): |
627 def testVisitdirIncludeIncludfe(self): |
343 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
628 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
350 self.assertFalse(um.visitdir('folder')) |
635 self.assertFalse(um.visitdir('folder')) |
351 # OPT: These two should probably be 'all' not True. |
636 # OPT: These two should probably be 'all' not True. |
352 self.assertEqual(um.visitdir('dir/subdir/z'), True) |
637 self.assertEqual(um.visitdir('dir/subdir/z'), True) |
353 self.assertEqual(um.visitdir('dir/subdir/x'), True) |
638 self.assertEqual(um.visitdir('dir/subdir/x'), True) |
354 |
639 |
|
640 def testVisitchildrensetIncludeInclude(self): |
|
641 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
|
642 m2 = matchmod.match('', '', include=['rootfilesin:dir']) |
|
643 um = matchmod.unionmatcher([m1, m2]) |
|
644 self.assertEqual(um.visitchildrenset('.'), {'dir'}) |
|
645 self.assertEqual(um.visitchildrenset('dir'), 'this') |
|
646 self.assertEqual(um.visitchildrenset('dir/subdir'), 'all') |
|
647 self.assertEqual(um.visitchildrenset('dir/foo'), set()) |
|
648 self.assertEqual(um.visitchildrenset('folder'), set()) |
|
649 # OPT: These next two could be 'all' instead of 'this'. |
|
650 self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'this') |
|
651 self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'this') |
|
652 |
355 # We're using includematcher instead of patterns because it behaves slightly |
653 # We're using includematcher instead of patterns because it behaves slightly |
356 # better (giving narrower results) than patternmatcher. |
654 # better (giving narrower results) than patternmatcher. |
357 def testVisitdirIncludeInclude2(self): |
655 def testVisitdirIncludeInclude2(self): |
358 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
656 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
359 m2 = matchmod.match('', '', include=['path:folder']) |
657 m2 = matchmod.match('', '', include=['path:folder']) |
365 self.assertEqual(um.visitdir('folder'), 'all') |
663 self.assertEqual(um.visitdir('folder'), 'all') |
366 # OPT: These should probably be 'all' not True. |
664 # OPT: These should probably be 'all' not True. |
367 self.assertEqual(um.visitdir('dir/subdir/z'), True) |
665 self.assertEqual(um.visitdir('dir/subdir/z'), True) |
368 self.assertEqual(um.visitdir('dir/subdir/x'), True) |
666 self.assertEqual(um.visitdir('dir/subdir/x'), True) |
369 |
667 |
|
668 def testVisitchildrensetIncludeInclude2(self): |
|
669 m1 = matchmod.match('', '', include=['path:dir/subdir']) |
|
670 m2 = matchmod.match('', '', include=['path:folder']) |
|
671 um = matchmod.unionmatcher([m1, m2]) |
|
672 self.assertEqual(um.visitchildrenset('.'), {'folder', 'dir'}) |
|
673 self.assertEqual(um.visitchildrenset('dir'), {'subdir'}) |
|
674 self.assertEqual(um.visitchildrenset('dir/subdir'), 'all') |
|
675 self.assertEqual(um.visitchildrenset('dir/foo'), set()) |
|
676 self.assertEqual(um.visitchildrenset('folder'), 'all') |
|
677 # OPT: These next two could be 'all' instead of 'this'. |
|
678 self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'this') |
|
679 self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'this') |
|
680 |
370 # We're using includematcher instead of patterns because it behaves slightly |
681 # We're using includematcher instead of patterns because it behaves slightly |
371 # better (giving narrower results) than patternmatcher. |
682 # better (giving narrower results) than patternmatcher. |
372 def testVisitdirIncludeInclude3(self): |
683 def testVisitdirIncludeInclude3(self): |
373 m1 = matchmod.match('', '', include=['path:dir/subdir/x']) |
684 m1 = matchmod.match('', '', include=['path:dir/subdir/x']) |
374 m2 = matchmod.match('', '', include=['path:dir/subdir']) |
685 m2 = matchmod.match('', '', include=['path:dir/subdir']) |
380 self.assertFalse(um.visitdir('folder')) |
691 self.assertFalse(um.visitdir('folder')) |
381 self.assertEqual(um.visitdir('dir/subdir/x'), 'all') |
692 self.assertEqual(um.visitdir('dir/subdir/x'), 'all') |
382 # OPT: this should probably be 'all' not True. |
693 # OPT: this should probably be 'all' not True. |
383 self.assertEqual(um.visitdir('dir/subdir/z'), True) |
694 self.assertEqual(um.visitdir('dir/subdir/z'), True) |
384 |
695 |
|
696 def testVisitchildrensetIncludeInclude3(self): |
|
697 m1 = matchmod.match('', '', include=['path:dir/subdir/x']) |
|
698 m2 = matchmod.match('', '', include=['path:dir/subdir']) |
|
699 um = matchmod.unionmatcher([m1, m2]) |
|
700 self.assertEqual(um.visitchildrenset('.'), {'dir'}) |
|
701 self.assertEqual(um.visitchildrenset('dir'), {'subdir'}) |
|
702 self.assertEqual(um.visitchildrenset('dir/subdir'), 'all') |
|
703 self.assertEqual(um.visitchildrenset('dir/foo'), set()) |
|
704 self.assertEqual(um.visitchildrenset('folder'), set()) |
|
705 self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all') |
|
706 # OPT: this should probably be 'all' not 'this'. |
|
707 self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'this') |
|
708 |
385 # We're using includematcher instead of patterns because it behaves slightly |
709 # We're using includematcher instead of patterns because it behaves slightly |
386 # better (giving narrower results) than patternmatcher. |
710 # better (giving narrower results) than patternmatcher. |
387 def testVisitdirIncludeInclude4(self): |
711 def testVisitdirIncludeInclude4(self): |
388 m1 = matchmod.match('', '', include=['path:dir/subdir/x']) |
712 m1 = matchmod.match('', '', include=['path:dir/subdir/x']) |
389 m2 = matchmod.match('', '', include=['path:dir/subdir/z']) |
713 m2 = matchmod.match('', '', include=['path:dir/subdir/z']) |
395 self.assertFalse(um.visitdir('dir/foo')) |
719 self.assertFalse(um.visitdir('dir/foo')) |
396 self.assertFalse(um.visitdir('folder')) |
720 self.assertFalse(um.visitdir('folder')) |
397 self.assertEqual(um.visitdir('dir/subdir/z'), 'all') |
721 self.assertEqual(um.visitdir('dir/subdir/z'), 'all') |
398 self.assertEqual(um.visitdir('dir/subdir/x'), 'all') |
722 self.assertEqual(um.visitdir('dir/subdir/x'), 'all') |
399 |
723 |
|
724 def testVisitchildrensetIncludeInclude4(self): |
|
725 m1 = matchmod.match('', '', include=['path:dir/subdir/x']) |
|
726 m2 = matchmod.match('', '', include=['path:dir/subdir/z']) |
|
727 um = matchmod.unionmatcher([m1, m2]) |
|
728 self.assertEqual(um.visitchildrenset('.'), {'dir'}) |
|
729 self.assertEqual(um.visitchildrenset('dir'), {'subdir'}) |
|
730 self.assertEqual(um.visitchildrenset('dir/subdir'), {'x', 'z'}) |
|
731 self.assertEqual(um.visitchildrenset('dir/foo'), set()) |
|
732 self.assertEqual(um.visitchildrenset('folder'), set()) |
|
733 self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all') |
|
734 self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all') |
|
735 |
400 class SubdirMatcherTests(unittest.TestCase): |
736 class SubdirMatcherTests(unittest.TestCase): |
401 |
737 |
402 def testVisitdir(self): |
738 def testVisitdir(self): |
403 m = matchmod.match('', '', include=['path:dir/subdir']) |
739 m = matchmod.match('', '', include=['path:dir/subdir']) |
404 sm = matchmod.subdirmatcher('dir', m) |
740 sm = matchmod.subdirmatcher('dir', m) |
407 self.assertEqual(sm.visitdir('subdir'), 'all') |
743 self.assertEqual(sm.visitdir('subdir'), 'all') |
408 # OPT: These next two should probably be 'all' not True. |
744 # OPT: These next two should probably be 'all' not True. |
409 self.assertEqual(sm.visitdir('subdir/x'), True) |
745 self.assertEqual(sm.visitdir('subdir/x'), True) |
410 self.assertEqual(sm.visitdir('subdir/z'), True) |
746 self.assertEqual(sm.visitdir('subdir/z'), True) |
411 self.assertFalse(sm.visitdir('foo')) |
747 self.assertFalse(sm.visitdir('foo')) |
|
748 |
|
749 def testVisitchildrenset(self): |
|
750 m = matchmod.match('', '', include=['path:dir/subdir']) |
|
751 sm = matchmod.subdirmatcher('dir', m) |
|
752 |
|
753 self.assertEqual(sm.visitchildrenset('.'), {'subdir'}) |
|
754 self.assertEqual(sm.visitchildrenset('subdir'), 'all') |
|
755 # OPT: These next two should probably be 'all' not 'this'. |
|
756 self.assertEqual(sm.visitchildrenset('subdir/x'), 'this') |
|
757 self.assertEqual(sm.visitchildrenset('subdir/z'), 'this') |
|
758 self.assertEqual(sm.visitchildrenset('foo'), set()) |
412 |
759 |
413 class PrefixdirMatcherTests(unittest.TestCase): |
760 class PrefixdirMatcherTests(unittest.TestCase): |
414 |
761 |
415 def testVisitdir(self): |
762 def testVisitdir(self): |
416 m = matchmod.match(util.localpath('root/d'), 'e/f', |
763 m = matchmod.match(util.localpath('root/d'), 'e/f', |
442 self.assertEqual(pm.visitdir('d'), True) |
789 self.assertEqual(pm.visitdir('d'), True) |
443 self.assertEqual(pm.visitdir('d/e'), True) |
790 self.assertEqual(pm.visitdir('d/e'), True) |
444 self.assertEqual(pm.visitdir('d/e/f'), True) |
791 self.assertEqual(pm.visitdir('d/e/f'), True) |
445 self.assertEqual(pm.visitdir('d/e/f/g'), False) |
792 self.assertEqual(pm.visitdir('d/e/f/g'), False) |
446 |
793 |
|
794 def testVisitchildrenset(self): |
|
795 m = matchmod.match(util.localpath('root/d'), 'e/f', |
|
796 ['../a.txt', 'b.txt']) |
|
797 pm = matchmod.prefixdirmatcher('root', 'd/e/f', 'd', m) |
|
798 |
|
799 # OPT: visitchildrenset could possibly return {'e'} and {'f'} for these |
|
800 # next two, respectively; patternmatcher does not have this |
|
801 # optimization. |
|
802 self.assertEqual(m.visitchildrenset('.'), 'this') |
|
803 self.assertEqual(m.visitchildrenset('e'), 'this') |
|
804 self.assertEqual(m.visitchildrenset('e/f'), 'this') |
|
805 self.assertEqual(m.visitchildrenset('e/f/g'), set()) |
|
806 |
|
807 # OPT: visitchildrenset could possibly return {'d'}, {'e'}, and {'f'} |
|
808 # for these next three, respectively; patternmatcher does not have this |
|
809 # optimization. |
|
810 self.assertEqual(pm.visitchildrenset('.'), 'this') |
|
811 self.assertEqual(pm.visitchildrenset('d'), 'this') |
|
812 self.assertEqual(pm.visitchildrenset('d/e'), 'this') |
|
813 self.assertEqual(pm.visitchildrenset('d/e/f'), 'this') |
|
814 self.assertEqual(pm.visitchildrenset('d/e/f/g'), set()) |
|
815 |
447 if __name__ == '__main__': |
816 if __name__ == '__main__': |
448 silenttestrunner.main(__name__) |
817 silenttestrunner.main(__name__) |