11 

    11 

    12 class BaseMatcherTests(unittest.TestCase):

    12 class BaseMatcherTests(unittest.TestCase):

    13 

    13 

    14     def testVisitdir(self):

    14     def testVisitdir(self):

    15         m = matchmod.basematcher()

    15         m = matchmod.basematcher()

    17         self.assertTrue(m.visitdir(b'dir'))

    17         self.assertTrue(m.visitdir(b'dir'))

    18 

    18 

    19     def testVisitchildrenset(self):

    19     def testVisitchildrenset(self):

    20         m = matchmod.basematcher()

    20         m = matchmod.basematcher()

    22         self.assertEqual(m.visitchildrenset(b'dir'), b'this')

    22         self.assertEqual(m.visitchildrenset(b'dir'), b'this')

    23 

    23 

    24 class AlwaysMatcherTests(unittest.TestCase):

    24 class AlwaysMatcherTests(unittest.TestCase):

    25 

    25 

    26     def testVisitdir(self):

    26     def testVisitdir(self):

    27         m = matchmod.alwaysmatcher()

    27         m = matchmod.alwaysmatcher()

    29         self.assertEqual(m.visitdir(b'dir'), b'all')

    29         self.assertEqual(m.visitdir(b'dir'), b'all')

    30 

    30 

    31     def testVisitchildrenset(self):

    31     def testVisitchildrenset(self):

    32         m = matchmod.alwaysmatcher()

    32         m = matchmod.alwaysmatcher()

    34         self.assertEqual(m.visitchildrenset(b'dir'), b'all')

    34         self.assertEqual(m.visitchildrenset(b'dir'), b'all')

    35 

    35 

    36 class NeverMatcherTests(unittest.TestCase):

    36 class NeverMatcherTests(unittest.TestCase):

    37 

    37 

    38     def testVisitdir(self):

    38     def testVisitdir(self):

    39         m = matchmod.nevermatcher()

    39         m = matchmod.nevermatcher()

    41         self.assertFalse(m.visitdir(b'dir'))

    41         self.assertFalse(m.visitdir(b'dir'))

    42 

    42 

    43     def testVisitchildrenset(self):

    43     def testVisitchildrenset(self):

    44         m = matchmod.nevermatcher()

    44         m = matchmod.nevermatcher()

    46         self.assertEqual(m.visitchildrenset(b'dir'), set())

    46         self.assertEqual(m.visitchildrenset(b'dir'), set())

    47 

    47 

    48 class PredicateMatcherTests(unittest.TestCase):

    48 class PredicateMatcherTests(unittest.TestCase):

    49     # predicatematcher does not currently define either of these methods, so

    49     # predicatematcher does not currently define either of these methods, so

    50     # this is equivalent to BaseMatcherTests.

    50     # this is equivalent to BaseMatcherTests.

    51 

    51 

    52     def testVisitdir(self):

    52     def testVisitdir(self):

    53         m = matchmod.predicatematcher(lambda *a: False)

    53         m = matchmod.predicatematcher(lambda *a: False)

    55         self.assertTrue(m.visitdir(b'dir'))

    55         self.assertTrue(m.visitdir(b'dir'))

    56 

    56 

    57     def testVisitchildrenset(self):

    57     def testVisitchildrenset(self):

    58         m = matchmod.predicatematcher(lambda *a: False)

    58         m = matchmod.predicatematcher(lambda *a: False)

    60         self.assertEqual(m.visitchildrenset(b'dir'), b'this')

    60         self.assertEqual(m.visitchildrenset(b'dir'), b'this')

    61 

    61 

    62 class PatternMatcherTests(unittest.TestCase):

    62 class PatternMatcherTests(unittest.TestCase):

    63 

    63 

    64     def testVisitdirPrefix(self):

    64     def testVisitdirPrefix(self):

    65         m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir'])

    65         m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir'])

    66         assert isinstance(m, matchmod.patternmatcher)

    66         assert isinstance(m, matchmod.patternmatcher)

    68         self.assertTrue(m.visitdir(b'dir'))

    68         self.assertTrue(m.visitdir(b'dir'))

    69         self.assertEqual(m.visitdir(b'dir/subdir'), b'all')

    69         self.assertEqual(m.visitdir(b'dir/subdir'), b'all')

    70         # OPT: This should probably be 'all' if its parent is?

    70         # OPT: This should probably be 'all' if its parent is?

    71         self.assertTrue(m.visitdir(b'dir/subdir/x'))

    71         self.assertTrue(m.visitdir(b'dir/subdir/x'))

    72         self.assertFalse(m.visitdir(b'folder'))

    72         self.assertFalse(m.visitdir(b'folder'))

    73 

    73 

    74     def testVisitchildrensetPrefix(self):

    74     def testVisitchildrensetPrefix(self):

    75         m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir'])

    75         m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir'])

    76         assert isinstance(m, matchmod.patternmatcher)

    76         assert isinstance(m, matchmod.patternmatcher)

    78         self.assertEqual(m.visitchildrenset(b'dir'), b'this')

    78         self.assertEqual(m.visitchildrenset(b'dir'), b'this')

    79         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')

    79         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')

    80         # OPT: This should probably be 'all' if its parent is?

    80         # OPT: This should probably be 'all' if its parent is?

    81         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')

    81         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')

    82         self.assertEqual(m.visitchildrenset(b'folder'), set())

    82         self.assertEqual(m.visitchildrenset(b'folder'), set())

    83 

    83 

    84     def testVisitdirRootfilesin(self):

    84     def testVisitdirRootfilesin(self):

    85         m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir'])

    85         m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir'])

    86         assert isinstance(m, matchmod.patternmatcher)

    86         assert isinstance(m, matchmod.patternmatcher)

    88         self.assertFalse(m.visitdir(b'dir/subdir/x'))

    88         self.assertFalse(m.visitdir(b'dir/subdir/x'))

    89         self.assertFalse(m.visitdir(b'folder'))

    89         self.assertFalse(m.visitdir(b'folder'))

    90         # FIXME: These should probably be True.

    90         # FIXME: These should probably be True.

    91         self.assertFalse(m.visitdir(b'dir'))

    91         self.assertFalse(m.visitdir(b'dir'))

    92         self.assertFalse(m.visitdir(b'dir/subdir'))

    92         self.assertFalse(m.visitdir(b'dir/subdir'))

    93 

    93 

    94     def testVisitchildrensetRootfilesin(self):

    94     def testVisitchildrensetRootfilesin(self):

    95         m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir'])

    95         m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir'])

    96         assert isinstance(m, matchmod.patternmatcher)

    96         assert isinstance(m, matchmod.patternmatcher)

    98         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())

    98         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())

    99         self.assertEqual(m.visitchildrenset(b'folder'), set())

    99         self.assertEqual(m.visitchildrenset(b'folder'), set())

   100         # FIXME: These should probably be {'subdir'} and 'this', respectively,

   100         # FIXME: These should probably be {'subdir'} and 'this', respectively,

   101         # or at least 'this' and 'this'.

   101         # or at least 'this' and 'this'.

   102         self.assertEqual(m.visitchildrenset(b'dir'), set())

   102         self.assertEqual(m.visitchildrenset(b'dir'), set())

   103         self.assertEqual(m.visitchildrenset(b'dir/subdir'), set())

   103         self.assertEqual(m.visitchildrenset(b'dir/subdir'), set())

   104 

   104 

   105     def testVisitdirGlob(self):

   105     def testVisitdirGlob(self):

   106         m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*'])

   106         m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*'])

   107         assert isinstance(m, matchmod.patternmatcher)

   107         assert isinstance(m, matchmod.patternmatcher)

   109         self.assertTrue(m.visitdir(b'dir'))

   109         self.assertTrue(m.visitdir(b'dir'))

   110         self.assertFalse(m.visitdir(b'folder'))

   110         self.assertFalse(m.visitdir(b'folder'))

   111         # OPT: these should probably be False.

   111         # OPT: these should probably be False.

   112         self.assertTrue(m.visitdir(b'dir/subdir'))

   112         self.assertTrue(m.visitdir(b'dir/subdir'))

   113         self.assertTrue(m.visitdir(b'dir/subdir/x'))

   113         self.assertTrue(m.visitdir(b'dir/subdir/x'))

   114 

   114 

   115     def testVisitchildrensetGlob(self):

   115     def testVisitchildrensetGlob(self):

   116         m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*'])

   116         m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*'])

   117         assert isinstance(m, matchmod.patternmatcher)

   117         assert isinstance(m, matchmod.patternmatcher)

   119         self.assertEqual(m.visitchildrenset(b'folder'), set())

   119         self.assertEqual(m.visitchildrenset(b'folder'), set())

   120         self.assertEqual(m.visitchildrenset(b'dir'), b'this')

   120         self.assertEqual(m.visitchildrenset(b'dir'), b'this')

   121         # OPT: these should probably be set().

   121         # OPT: these should probably be set().

   122         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')

   122         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')

   123         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')

   123         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')

   125 class IncludeMatcherTests(unittest.TestCase):

   125 class IncludeMatcherTests(unittest.TestCase):

   126 

   126 

   127     def testVisitdirPrefix(self):

   127     def testVisitdirPrefix(self):

   128         m = matchmod.match(b'x', b'', include=[b'path:dir/subdir'])

   128         m = matchmod.match(b'x', b'', include=[b'path:dir/subdir'])

   129         assert isinstance(m, matchmod.includematcher)

   129         assert isinstance(m, matchmod.includematcher)

   131         self.assertTrue(m.visitdir(b'dir'))

   131         self.assertTrue(m.visitdir(b'dir'))

   132         self.assertEqual(m.visitdir(b'dir/subdir'), b'all')

   132         self.assertEqual(m.visitdir(b'dir/subdir'), b'all')

   133         # OPT: This should probably be 'all' if its parent is?

   133         # OPT: This should probably be 'all' if its parent is?

   134         self.assertTrue(m.visitdir(b'dir/subdir/x'))

   134         self.assertTrue(m.visitdir(b'dir/subdir/x'))

   135         self.assertFalse(m.visitdir(b'folder'))

   135         self.assertFalse(m.visitdir(b'folder'))

   136 

   136 

   137     def testVisitchildrensetPrefix(self):

   137     def testVisitchildrensetPrefix(self):

   138         m = matchmod.match(b'x', b'', include=[b'path:dir/subdir'])

   138         m = matchmod.match(b'x', b'', include=[b'path:dir/subdir'])

   139         assert isinstance(m, matchmod.includematcher)

   139         assert isinstance(m, matchmod.includematcher)

   141         self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})

   141         self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})

   142         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')

   142         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')

   143         # OPT: This should probably be 'all' if its parent is?

   143         # OPT: This should probably be 'all' if its parent is?

   144         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')

   144         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')

   145         self.assertEqual(m.visitchildrenset(b'folder'), set())

   145         self.assertEqual(m.visitchildrenset(b'folder'), set())

   146 

   146 

   147     def testVisitdirRootfilesin(self):

   147     def testVisitdirRootfilesin(self):

   148         m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir'])

   148         m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir'])

   149         assert isinstance(m, matchmod.includematcher)

   149         assert isinstance(m, matchmod.includematcher)

   151         self.assertTrue(m.visitdir(b'dir'))

   151         self.assertTrue(m.visitdir(b'dir'))

   152         self.assertTrue(m.visitdir(b'dir/subdir'))

   152         self.assertTrue(m.visitdir(b'dir/subdir'))

   153         self.assertFalse(m.visitdir(b'dir/subdir/x'))

   153         self.assertFalse(m.visitdir(b'dir/subdir/x'))

   154         self.assertFalse(m.visitdir(b'folder'))

   154         self.assertFalse(m.visitdir(b'folder'))

   155 

   155 

   156     def testVisitchildrensetRootfilesin(self):

   156     def testVisitchildrensetRootfilesin(self):

   157         m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir'])

   157         m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir'])

   158         assert isinstance(m, matchmod.includematcher)

   158         assert isinstance(m, matchmod.includematcher)

   160         self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})

   160         self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})

   161         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')

   161         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')

   162         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())

   162         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())

   163         self.assertEqual(m.visitchildrenset(b'folder'), set())

   163         self.assertEqual(m.visitchildrenset(b'folder'), set())

   164 

   164 

   165     def testVisitdirGlob(self):

   165     def testVisitdirGlob(self):

   166         m = matchmod.match(b'x', b'', include=[b'glob:dir/z*'])

   166         m = matchmod.match(b'x', b'', include=[b'glob:dir/z*'])

   167         assert isinstance(m, matchmod.includematcher)

   167         assert isinstance(m, matchmod.includematcher)

   169         self.assertTrue(m.visitdir(b'dir'))

   169         self.assertTrue(m.visitdir(b'dir'))

   170         self.assertFalse(m.visitdir(b'folder'))

   170         self.assertFalse(m.visitdir(b'folder'))

   171         # OPT: these should probably be False.

   171         # OPT: these should probably be False.

   172         self.assertTrue(m.visitdir(b'dir/subdir'))

   172         self.assertTrue(m.visitdir(b'dir/subdir'))

   173         self.assertTrue(m.visitdir(b'dir/subdir/x'))

   173         self.assertTrue(m.visitdir(b'dir/subdir/x'))

   174 

   174 

   175     def testVisitchildrensetGlob(self):

   175     def testVisitchildrensetGlob(self):

   176         m = matchmod.match(b'x', b'', include=[b'glob:dir/z*'])

   176         m = matchmod.match(b'x', b'', include=[b'glob:dir/z*'])

   177         assert isinstance(m, matchmod.includematcher)

   177         assert isinstance(m, matchmod.includematcher)

   179         self.assertEqual(m.visitchildrenset(b'folder'), set())

   179         self.assertEqual(m.visitchildrenset(b'folder'), set())

   180         self.assertEqual(m.visitchildrenset(b'dir'), b'this')

   180         self.assertEqual(m.visitchildrenset(b'dir'), b'this')

   181         # OPT: these should probably be set().

   181         # OPT: these should probably be set().

   182         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')

   182         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')

   183         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')

   183         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')

   185 class ExactMatcherTests(unittest.TestCase):

   185 class ExactMatcherTests(unittest.TestCase):

   186 

   186 

   187     def testVisitdir(self):

   187     def testVisitdir(self):

   188         m = matchmod.exact(files=[b'dir/subdir/foo.txt'])

   188         m = matchmod.exact(files=[b'dir/subdir/foo.txt'])

   189         assert isinstance(m, matchmod.exactmatcher)

   189         assert isinstance(m, matchmod.exactmatcher)

   191         self.assertTrue(m.visitdir(b'dir'))

   191         self.assertTrue(m.visitdir(b'dir'))

   192         self.assertTrue(m.visitdir(b'dir/subdir'))

   192         self.assertTrue(m.visitdir(b'dir/subdir'))

   193         self.assertFalse(m.visitdir(b'dir/subdir/foo.txt'))

   193         self.assertFalse(m.visitdir(b'dir/subdir/foo.txt'))

   194         self.assertFalse(m.visitdir(b'dir/foo'))

   194         self.assertFalse(m.visitdir(b'dir/foo'))

   195         self.assertFalse(m.visitdir(b'dir/subdir/x'))

   195         self.assertFalse(m.visitdir(b'dir/subdir/x'))

   196         self.assertFalse(m.visitdir(b'folder'))

   196         self.assertFalse(m.visitdir(b'folder'))

   197 

   197 

   198     def testVisitchildrenset(self):

   198     def testVisitchildrenset(self):

   199         m = matchmod.exact(files=[b'dir/subdir/foo.txt'])

   199         m = matchmod.exact(files=[b'dir/subdir/foo.txt'])

   200         assert isinstance(m, matchmod.exactmatcher)

   200         assert isinstance(m, matchmod.exactmatcher)

   202         self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})

   202         self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})

   203         self.assertEqual(m.visitchildrenset(b'dir/subdir'), {b'foo.txt'})

   203         self.assertEqual(m.visitchildrenset(b'dir/subdir'), {b'foo.txt'})

   204         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())

   204         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())

   205         self.assertEqual(m.visitchildrenset(b'dir/subdir/foo.txt'), set())

   205         self.assertEqual(m.visitchildrenset(b'dir/subdir/foo.txt'), set())

   206         self.assertEqual(m.visitchildrenset(b'folder'), set())

   206         self.assertEqual(m.visitchildrenset(b'folder'), set())

   210                                   b'a/file1.txt',

   210                                   b'a/file1.txt',

   211                                   b'a/b/file2.txt',

   211                                   b'a/b/file2.txt',

   212                                   # no file in a/b/c

   212                                   # no file in a/b/c

   213                                   b'a/b/c/d/file4.txt'])

   213                                   b'a/b/c/d/file4.txt'])

   214         assert isinstance(m, matchmod.exactmatcher)

   214         assert isinstance(m, matchmod.exactmatcher)

   216         self.assertEqual(m.visitchildrenset(b'a'), {b'b', b'file1.txt'})

   216         self.assertEqual(m.visitchildrenset(b'a'), {b'b', b'file1.txt'})

   217         self.assertEqual(m.visitchildrenset(b'a/b'), {b'c', b'file2.txt'})

   217         self.assertEqual(m.visitchildrenset(b'a/b'), {b'c', b'file2.txt'})

   218         self.assertEqual(m.visitchildrenset(b'a/b/c'), {b'd'})

   218         self.assertEqual(m.visitchildrenset(b'a/b/c'), {b'd'})

   219         self.assertEqual(m.visitchildrenset(b'a/b/c/d'), {b'file4.txt'})

   219         self.assertEqual(m.visitchildrenset(b'a/b/c/d'), {b'file4.txt'})

   220         self.assertEqual(m.visitchildrenset(b'a/b/c/d/e'), set())

   220         self.assertEqual(m.visitchildrenset(b'a/b/c/d/e'), set())

   225     def testVisitdirM2always(self):

   225     def testVisitdirM2always(self):

   226         m1 = matchmod.alwaysmatcher()

   226         m1 = matchmod.alwaysmatcher()

   227         m2 = matchmod.alwaysmatcher()

   227         m2 = matchmod.alwaysmatcher()

   228         dm = matchmod.differencematcher(m1, m2)

   228         dm = matchmod.differencematcher(m1, m2)

   229         # dm should be equivalent to a nevermatcher.

   229         # dm should be equivalent to a nevermatcher.

   231         self.assertFalse(dm.visitdir(b'dir'))

   231         self.assertFalse(dm.visitdir(b'dir'))

   232         self.assertFalse(dm.visitdir(b'dir/subdir'))

   232         self.assertFalse(dm.visitdir(b'dir/subdir'))

   233         self.assertFalse(dm.visitdir(b'dir/subdir/z'))

   233         self.assertFalse(dm.visitdir(b'dir/subdir/z'))

   234         self.assertFalse(dm.visitdir(b'dir/foo'))

   234         self.assertFalse(dm.visitdir(b'dir/foo'))

   235         self.assertFalse(dm.visitdir(b'dir/subdir/x'))

   235         self.assertFalse(dm.visitdir(b'dir/subdir/x'))

   238     def testVisitchildrensetM2always(self):

   238     def testVisitchildrensetM2always(self):

   239         m1 = matchmod.alwaysmatcher()

   239         m1 = matchmod.alwaysmatcher()

   240         m2 = matchmod.alwaysmatcher()

   240         m2 = matchmod.alwaysmatcher()

   241         dm = matchmod.differencematcher(m1, m2)

   241         dm = matchmod.differencematcher(m1, m2)

   242         # dm should be equivalent to a nevermatcher.

   242         # dm should be equivalent to a nevermatcher.

   244         self.assertEqual(dm.visitchildrenset(b'dir'), set())

   244         self.assertEqual(dm.visitchildrenset(b'dir'), set())

   245         self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set())

   245         self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set())

   246         self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), set())

   246         self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), set())

   247         self.assertEqual(dm.visitchildrenset(b'dir/foo'), set())

   247         self.assertEqual(dm.visitchildrenset(b'dir/foo'), set())

   248         self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), set())

   248         self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), set())

   256         #

   256         #

   257         # We're testing Equal-to-True instead of just 'assertTrue' since

   257         # We're testing Equal-to-True instead of just 'assertTrue' since

   258         # assertTrue does NOT verify that it's a bool, just that it's truthy.

   258         # assertTrue does NOT verify that it's a bool, just that it's truthy.

   259         # While we may want to eventually make these return 'all', they should

   259         # While we may want to eventually make these return 'all', they should

   260         # not currently do so.

   260         # not currently do so.

   262         self.assertEqual(dm.visitdir(b'dir'), b'all')

   262         self.assertEqual(dm.visitdir(b'dir'), b'all')

   263         self.assertEqual(dm.visitdir(b'dir/subdir'), b'all')

   263         self.assertEqual(dm.visitdir(b'dir/subdir'), b'all')

   264         self.assertEqual(dm.visitdir(b'dir/subdir/z'), b'all')

   264         self.assertEqual(dm.visitdir(b'dir/subdir/z'), b'all')

   265         self.assertEqual(dm.visitdir(b'dir/foo'), b'all')

   265         self.assertEqual(dm.visitdir(b'dir/foo'), b'all')

   266         self.assertEqual(dm.visitdir(b'dir/subdir/x'), b'all')

   266         self.assertEqual(dm.visitdir(b'dir/subdir/x'), b'all')

   269     def testVisitchildrensetM2never(self):

   269     def testVisitchildrensetM2never(self):

   270         m1 = matchmod.alwaysmatcher()

   270         m1 = matchmod.alwaysmatcher()

   271         m2 = matchmod.nevermatcher()

   271         m2 = matchmod.nevermatcher()

   272         dm = matchmod.differencematcher(m1, m2)

   272         dm = matchmod.differencematcher(m1, m2)

   273         # dm should be equivalent to a alwaysmatcher.

   273         # dm should be equivalent to a alwaysmatcher.

   275         self.assertEqual(dm.visitchildrenset(b'dir'), b'all')

   275         self.assertEqual(dm.visitchildrenset(b'dir'), b'all')

   276         self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all')

   276         self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all')

   277         self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'all')

   277         self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'all')

   278         self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all')

   278         self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all')

   279         self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'all')

   279         self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'all')

   281 

   281 

   282     def testVisitdirM2SubdirPrefix(self):

   282     def testVisitdirM2SubdirPrefix(self):

   283         m1 = matchmod.alwaysmatcher()

   283         m1 = matchmod.alwaysmatcher()

   284         m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])

   284         m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])

   285         dm = matchmod.differencematcher(m1, m2)

   285         dm = matchmod.differencematcher(m1, m2)

   287         self.assertEqual(dm.visitdir(b'dir'), True)

   287         self.assertEqual(dm.visitdir(b'dir'), True)

   288         self.assertFalse(dm.visitdir(b'dir/subdir'))

   288         self.assertFalse(dm.visitdir(b'dir/subdir'))

   289         # OPT: We should probably return False for these; we don't because

   289         # OPT: We should probably return False for these; we don't because

   290         # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of

   290         # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of

   291         # an 'all' pattern, just True.

   291         # an 'all' pattern, just True.

   296 

   296 

   297     def testVisitchildrensetM2SubdirPrefix(self):

   297     def testVisitchildrensetM2SubdirPrefix(self):

   298         m1 = matchmod.alwaysmatcher()

   298         m1 = matchmod.alwaysmatcher()

   299         m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])

   299         m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])

   300         dm = matchmod.differencematcher(m1, m2)

   300         dm = matchmod.differencematcher(m1, m2)

   302         self.assertEqual(dm.visitchildrenset(b'dir'), b'this')

   302         self.assertEqual(dm.visitchildrenset(b'dir'), b'this')

   303         self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set())

   303         self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set())

   304         self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all')

   304         self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all')

   305         self.assertEqual(dm.visitchildrenset(b'folder'), b'all')

   305         self.assertEqual(dm.visitchildrenset(b'folder'), b'all')

   306         # OPT: We should probably return set() for these; we don't because

   306         # OPT: We should probably return set() for these; we don't because

   313     # better (giving narrower results) than patternmatcher.

   313     # better (giving narrower results) than patternmatcher.

   314     def testVisitdirIncludeIncludfe(self):

   314     def testVisitdirIncludeIncludfe(self):

   315         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   315         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   316         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])

   316         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])

   317         dm = matchmod.differencematcher(m1, m2)

   317         dm = matchmod.differencematcher(m1, m2)

   319         self.assertEqual(dm.visitdir(b'dir'), True)

   319         self.assertEqual(dm.visitdir(b'dir'), True)

   320         self.assertEqual(dm.visitdir(b'dir/subdir'), b'all')

   320         self.assertEqual(dm.visitdir(b'dir/subdir'), b'all')

   321         self.assertFalse(dm.visitdir(b'dir/foo'))

   321         self.assertFalse(dm.visitdir(b'dir/foo'))

   322         self.assertFalse(dm.visitdir(b'folder'))

   322         self.assertFalse(dm.visitdir(b'folder'))

   323         # OPT: We should probably return False for these; we don't because

   323         # OPT: We should probably return False for these; we don't because

   328 

   328 

   329     def testVisitchildrensetIncludeInclude(self):

   329     def testVisitchildrensetIncludeInclude(self):

   330         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   330         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   331         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])

   331         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])

   332         dm = matchmod.differencematcher(m1, m2)

   332         dm = matchmod.differencematcher(m1, m2)

   334         self.assertEqual(dm.visitchildrenset(b'dir'), {b'subdir'})

   334         self.assertEqual(dm.visitchildrenset(b'dir'), {b'subdir'})

   335         self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all')

   335         self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all')

   336         self.assertEqual(dm.visitchildrenset(b'dir/foo'), set())

   336         self.assertEqual(dm.visitchildrenset(b'dir/foo'), set())

   337         self.assertEqual(dm.visitchildrenset(b'folder'), set())

   337         self.assertEqual(dm.visitchildrenset(b'folder'), set())

   338         # OPT: We should probably return set() for these; we don't because

   338         # OPT: We should probably return set() for these; we don't because

   346     def testVisitdirM2always(self):

   346     def testVisitdirM2always(self):

   347         m1 = matchmod.alwaysmatcher()

   347         m1 = matchmod.alwaysmatcher()

   348         m2 = matchmod.alwaysmatcher()

   348         m2 = matchmod.alwaysmatcher()

   349         im = matchmod.intersectmatchers(m1, m2)

   349         im = matchmod.intersectmatchers(m1, m2)

   350         # im should be equivalent to a alwaysmatcher.

   350         # im should be equivalent to a alwaysmatcher.

   352         self.assertEqual(im.visitdir(b'dir'), b'all')

   352         self.assertEqual(im.visitdir(b'dir'), b'all')

   353         self.assertEqual(im.visitdir(b'dir/subdir'), b'all')

   353         self.assertEqual(im.visitdir(b'dir/subdir'), b'all')

   354         self.assertEqual(im.visitdir(b'dir/subdir/z'), b'all')

   354         self.assertEqual(im.visitdir(b'dir/subdir/z'), b'all')

   355         self.assertEqual(im.visitdir(b'dir/foo'), b'all')

   355         self.assertEqual(im.visitdir(b'dir/foo'), b'all')

   356         self.assertEqual(im.visitdir(b'dir/subdir/x'), b'all')

   356         self.assertEqual(im.visitdir(b'dir/subdir/x'), b'all')

   359     def testVisitchildrensetM2always(self):

   359     def testVisitchildrensetM2always(self):

   360         m1 = matchmod.alwaysmatcher()

   360         m1 = matchmod.alwaysmatcher()

   361         m2 = matchmod.alwaysmatcher()

   361         m2 = matchmod.alwaysmatcher()

   362         im = matchmod.intersectmatchers(m1, m2)

   362         im = matchmod.intersectmatchers(m1, m2)

   363         # im should be equivalent to a alwaysmatcher.

   363         # im should be equivalent to a alwaysmatcher.

   365         self.assertEqual(im.visitchildrenset(b'dir'), b'all')

   365         self.assertEqual(im.visitchildrenset(b'dir'), b'all')

   366         self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all')

   366         self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all')

   367         self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), b'all')

   367         self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), b'all')

   368         self.assertEqual(im.visitchildrenset(b'dir/foo'), b'all')

   368         self.assertEqual(im.visitchildrenset(b'dir/foo'), b'all')

   369         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'all')

   369         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'all')

   372     def testVisitdirM2never(self):

   372     def testVisitdirM2never(self):

   373         m1 = matchmod.alwaysmatcher()

   373         m1 = matchmod.alwaysmatcher()

   374         m2 = matchmod.nevermatcher()

   374         m2 = matchmod.nevermatcher()

   375         im = matchmod.intersectmatchers(m1, m2)

   375         im = matchmod.intersectmatchers(m1, m2)

   376         # im should be equivalent to a nevermatcher.

   376         # im should be equivalent to a nevermatcher.

   378         self.assertFalse(im.visitdir(b'dir'))

   378         self.assertFalse(im.visitdir(b'dir'))

   379         self.assertFalse(im.visitdir(b'dir/subdir'))

   379         self.assertFalse(im.visitdir(b'dir/subdir'))

   380         self.assertFalse(im.visitdir(b'dir/subdir/z'))

   380         self.assertFalse(im.visitdir(b'dir/subdir/z'))

   381         self.assertFalse(im.visitdir(b'dir/foo'))

   381         self.assertFalse(im.visitdir(b'dir/foo'))

   382         self.assertFalse(im.visitdir(b'dir/subdir/x'))

   382         self.assertFalse(im.visitdir(b'dir/subdir/x'))

   385     def testVisitchildrensetM2never(self):

   385     def testVisitchildrensetM2never(self):

   386         m1 = matchmod.alwaysmatcher()

   386         m1 = matchmod.alwaysmatcher()

   387         m2 = matchmod.nevermatcher()

   387         m2 = matchmod.nevermatcher()

   388         im = matchmod.intersectmatchers(m1, m2)

   388         im = matchmod.intersectmatchers(m1, m2)

   389         # im should be equivalent to a nevermqtcher.

   389         # im should be equivalent to a nevermqtcher.

   391         self.assertEqual(im.visitchildrenset(b'dir'), set())

   391         self.assertEqual(im.visitchildrenset(b'dir'), set())

   392         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())

   392         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())

   393         self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())

   393         self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())

   394         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())

   394         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())

   395         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())

   395         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())

   397 

   397 

   398     def testVisitdirM2SubdirPrefix(self):

   398     def testVisitdirM2SubdirPrefix(self):

   399         m1 = matchmod.alwaysmatcher()

   399         m1 = matchmod.alwaysmatcher()

   400         m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])

   400         m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])

   401         im = matchmod.intersectmatchers(m1, m2)

   401         im = matchmod.intersectmatchers(m1, m2)

   403         self.assertEqual(im.visitdir(b'dir'), True)

   403         self.assertEqual(im.visitdir(b'dir'), True)

   404         self.assertEqual(im.visitdir(b'dir/subdir'), b'all')

   404         self.assertEqual(im.visitdir(b'dir/subdir'), b'all')

   405         self.assertFalse(im.visitdir(b'dir/foo'))

   405         self.assertFalse(im.visitdir(b'dir/foo'))

   406         self.assertFalse(im.visitdir(b'folder'))

   406         self.assertFalse(im.visitdir(b'folder'))

   407         # OPT: We should probably return 'all' for these; we don't because

   407         # OPT: We should probably return 'all' for these; we don't because

   412 

   412 

   413     def testVisitchildrensetM2SubdirPrefix(self):

   413     def testVisitchildrensetM2SubdirPrefix(self):

   414         m1 = matchmod.alwaysmatcher()

   414         m1 = matchmod.alwaysmatcher()

   415         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   415         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   416         im = matchmod.intersectmatchers(m1, m2)

   416         im = matchmod.intersectmatchers(m1, m2)

   418         self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})

   418         self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})

   419         self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all')

   419         self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all')

   420         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())

   420         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())

   421         self.assertEqual(im.visitchildrenset(b'folder'), set())

   421         self.assertEqual(im.visitchildrenset(b'folder'), set())

   422         # OPT: We should probably return 'all' for these

   422         # OPT: We should probably return 'all' for these

   427     # better (giving narrower results) than patternmatcher.

   427     # better (giving narrower results) than patternmatcher.

   428     def testVisitdirIncludeIncludfe(self):

   428     def testVisitdirIncludeIncludfe(self):

   429         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   429         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   430         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])

   430         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])

   431         im = matchmod.intersectmatchers(m1, m2)

   431         im = matchmod.intersectmatchers(m1, m2)

   433         self.assertEqual(im.visitdir(b'dir'), True)

   433         self.assertEqual(im.visitdir(b'dir'), True)

   434         self.assertFalse(im.visitdir(b'dir/subdir'))

   434         self.assertFalse(im.visitdir(b'dir/subdir'))

   435         self.assertFalse(im.visitdir(b'dir/foo'))

   435         self.assertFalse(im.visitdir(b'dir/foo'))

   436         self.assertFalse(im.visitdir(b'folder'))

   436         self.assertFalse(im.visitdir(b'folder'))

   437         self.assertFalse(im.visitdir(b'dir/subdir/z'))

   437         self.assertFalse(im.visitdir(b'dir/subdir/z'))

   439 

   439 

   440     def testVisitchildrensetIncludeInclude(self):

   440     def testVisitchildrensetIncludeInclude(self):

   441         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   441         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   442         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])

   442         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])

   443         im = matchmod.intersectmatchers(m1, m2)

   443         im = matchmod.intersectmatchers(m1, m2)

   445         self.assertEqual(im.visitchildrenset(b'dir'), b'this')

   445         self.assertEqual(im.visitchildrenset(b'dir'), b'this')

   446         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())

   446         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())

   447         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())

   447         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())

   448         self.assertEqual(im.visitchildrenset(b'folder'), set())

   448         self.assertEqual(im.visitchildrenset(b'folder'), set())

   449         self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())

   449         self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())

   454     def testVisitdirIncludeInclude2(self):

   454     def testVisitdirIncludeInclude2(self):

   455         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   455         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   456         m2 = matchmod.match(b'', b'', include=[b'path:folder'])

   456         m2 = matchmod.match(b'', b'', include=[b'path:folder'])

   457         im = matchmod.intersectmatchers(m1, m2)

   457         im = matchmod.intersectmatchers(m1, m2)

   458         # FIXME: is True correct here?

   458         # FIXME: is True correct here?

   460         self.assertFalse(im.visitdir(b'dir'))

   460         self.assertFalse(im.visitdir(b'dir'))

   461         self.assertFalse(im.visitdir(b'dir/subdir'))

   461         self.assertFalse(im.visitdir(b'dir/subdir'))

   462         self.assertFalse(im.visitdir(b'dir/foo'))

   462         self.assertFalse(im.visitdir(b'dir/foo'))

   463         self.assertFalse(im.visitdir(b'folder'))

   463         self.assertFalse(im.visitdir(b'folder'))

   464         self.assertFalse(im.visitdir(b'dir/subdir/z'))

   464         self.assertFalse(im.visitdir(b'dir/subdir/z'))

   467     def testVisitchildrensetIncludeInclude2(self):

   467     def testVisitchildrensetIncludeInclude2(self):

   468         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   468         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   469         m2 = matchmod.match(b'', b'', include=[b'path:folder'])

   469         m2 = matchmod.match(b'', b'', include=[b'path:folder'])

   470         im = matchmod.intersectmatchers(m1, m2)

   470         im = matchmod.intersectmatchers(m1, m2)

   471         # FIXME: is set() correct here?

   471         # FIXME: is set() correct here?

   473         self.assertEqual(im.visitchildrenset(b'dir'), set())

   473         self.assertEqual(im.visitchildrenset(b'dir'), set())

   474         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())

   474         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())

   475         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())

   475         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())

   476         self.assertEqual(im.visitchildrenset(b'folder'), set())

   476         self.assertEqual(im.visitchildrenset(b'folder'), set())

   477         self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())

   477         self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())

   481     # better (giving narrower results) than patternmatcher.

   481     # better (giving narrower results) than patternmatcher.

   482     def testVisitdirIncludeInclude3(self):

   482     def testVisitdirIncludeInclude3(self):

   483         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   483         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   484         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   484         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   485         im = matchmod.intersectmatchers(m1, m2)

   485         im = matchmod.intersectmatchers(m1, m2)

   487         self.assertEqual(im.visitdir(b'dir'), True)

   487         self.assertEqual(im.visitdir(b'dir'), True)

   488         self.assertEqual(im.visitdir(b'dir/subdir'), True)

   488         self.assertEqual(im.visitdir(b'dir/subdir'), True)

   489         self.assertFalse(im.visitdir(b'dir/foo'))

   489         self.assertFalse(im.visitdir(b'dir/foo'))

   490         self.assertFalse(im.visitdir(b'folder'))

   490         self.assertFalse(im.visitdir(b'folder'))

   491         self.assertFalse(im.visitdir(b'dir/subdir/z'))

   491         self.assertFalse(im.visitdir(b'dir/subdir/z'))

   494 

   494 

   495     def testVisitchildrensetIncludeInclude3(self):

   495     def testVisitchildrensetIncludeInclude3(self):

   496         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   496         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   497         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   497         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   498         im = matchmod.intersectmatchers(m1, m2)

   498         im = matchmod.intersectmatchers(m1, m2)

   500         self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})

   500         self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})

   501         self.assertEqual(im.visitchildrenset(b'dir/subdir'), {b'x'})

   501         self.assertEqual(im.visitchildrenset(b'dir/subdir'), {b'x'})

   502         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())

   502         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())

   503         self.assertEqual(im.visitchildrenset(b'folder'), set())

   503         self.assertEqual(im.visitchildrenset(b'folder'), set())

   504         self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())

   504         self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())

   510     def testVisitdirIncludeInclude4(self):

   510     def testVisitdirIncludeInclude4(self):

   511         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   511         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   512         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])

   512         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])

   513         im = matchmod.intersectmatchers(m1, m2)

   513         im = matchmod.intersectmatchers(m1, m2)

   514         # OPT: these next three could probably be False as well.

   514         # OPT: these next three could probably be False as well.

   516         self.assertEqual(im.visitdir(b'dir'), True)

   516         self.assertEqual(im.visitdir(b'dir'), True)

   517         self.assertEqual(im.visitdir(b'dir/subdir'), True)

   517         self.assertEqual(im.visitdir(b'dir/subdir'), True)

   518         self.assertFalse(im.visitdir(b'dir/foo'))

   518         self.assertFalse(im.visitdir(b'dir/foo'))

   519         self.assertFalse(im.visitdir(b'folder'))

   519         self.assertFalse(im.visitdir(b'folder'))

   520         self.assertFalse(im.visitdir(b'dir/subdir/z'))

   520         self.assertFalse(im.visitdir(b'dir/subdir/z'))

   523     def testVisitchildrensetIncludeInclude4(self):

   523     def testVisitchildrensetIncludeInclude4(self):

   524         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   524         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   525         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])

   525         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])

   526         im = matchmod.intersectmatchers(m1, m2)

   526         im = matchmod.intersectmatchers(m1, m2)

   527         # OPT: these next two could probably be set() as well.

   527         # OPT: these next two could probably be set() as well.

   529         self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})

   529         self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})

   530         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())

   530         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())

   531         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())

   531         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())

   532         self.assertEqual(im.visitchildrenset(b'folder'), set())

   532         self.assertEqual(im.visitchildrenset(b'folder'), set())

   533         self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())

   533         self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())

   538     def testVisitdirM2always(self):

   538     def testVisitdirM2always(self):

   539         m1 = matchmod.alwaysmatcher()

   539         m1 = matchmod.alwaysmatcher()

   540         m2 = matchmod.alwaysmatcher()

   540         m2 = matchmod.alwaysmatcher()

   541         um = matchmod.unionmatcher([m1, m2])

   541         um = matchmod.unionmatcher([m1, m2])

   542         # um should be equivalent to a alwaysmatcher.

   542         # um should be equivalent to a alwaysmatcher.

   544         self.assertEqual(um.visitdir(b'dir'), b'all')

   544         self.assertEqual(um.visitdir(b'dir'), b'all')

   545         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   545         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   546         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')

   546         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')

   547         self.assertEqual(um.visitdir(b'dir/foo'), b'all')

   547         self.assertEqual(um.visitdir(b'dir/foo'), b'all')

   548         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')

   548         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')

   551     def testVisitchildrensetM2always(self):

   551     def testVisitchildrensetM2always(self):

   552         m1 = matchmod.alwaysmatcher()

   552         m1 = matchmod.alwaysmatcher()

   553         m2 = matchmod.alwaysmatcher()

   553         m2 = matchmod.alwaysmatcher()

   554         um = matchmod.unionmatcher([m1, m2])

   554         um = matchmod.unionmatcher([m1, m2])

   555         # um should be equivalent to a alwaysmatcher.

   555         # um should be equivalent to a alwaysmatcher.

   557         self.assertEqual(um.visitchildrenset(b'dir'), b'all')

   557         self.assertEqual(um.visitchildrenset(b'dir'), b'all')

   558         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   558         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   559         self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')

   559         self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')

   560         self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')

   560         self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')

   561         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')

   561         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')

   564     def testVisitdirM1never(self):

   564     def testVisitdirM1never(self):

   565         m1 = matchmod.nevermatcher()

   565         m1 = matchmod.nevermatcher()

   566         m2 = matchmod.alwaysmatcher()

   566         m2 = matchmod.alwaysmatcher()

   567         um = matchmod.unionmatcher([m1, m2])

   567         um = matchmod.unionmatcher([m1, m2])

   568         # um should be equivalent to a alwaysmatcher.

   568         # um should be equivalent to a alwaysmatcher.

   570         self.assertEqual(um.visitdir(b'dir'), b'all')

   570         self.assertEqual(um.visitdir(b'dir'), b'all')

   571         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   571         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   572         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')

   572         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')

   573         self.assertEqual(um.visitdir(b'dir/foo'), b'all')

   573         self.assertEqual(um.visitdir(b'dir/foo'), b'all')

   574         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')

   574         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')

   577     def testVisitchildrensetM1never(self):

   577     def testVisitchildrensetM1never(self):

   578         m1 = matchmod.nevermatcher()

   578         m1 = matchmod.nevermatcher()

   579         m2 = matchmod.alwaysmatcher()

   579         m2 = matchmod.alwaysmatcher()

   580         um = matchmod.unionmatcher([m1, m2])

   580         um = matchmod.unionmatcher([m1, m2])

   581         # um should be equivalent to a alwaysmatcher.

   581         # um should be equivalent to a alwaysmatcher.

   583         self.assertEqual(um.visitchildrenset(b'dir'), b'all')

   583         self.assertEqual(um.visitchildrenset(b'dir'), b'all')

   584         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   584         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   585         self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')

   585         self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')

   586         self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')

   586         self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')

   587         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')

   587         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')

   590     def testVisitdirM2never(self):

   590     def testVisitdirM2never(self):

   591         m1 = matchmod.alwaysmatcher()

   591         m1 = matchmod.alwaysmatcher()

   592         m2 = matchmod.nevermatcher()

   592         m2 = matchmod.nevermatcher()

   593         um = matchmod.unionmatcher([m1, m2])

   593         um = matchmod.unionmatcher([m1, m2])

   594         # um should be equivalent to a alwaysmatcher.

   594         # um should be equivalent to a alwaysmatcher.

   596         self.assertEqual(um.visitdir(b'dir'), b'all')

   596         self.assertEqual(um.visitdir(b'dir'), b'all')

   597         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   597         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   598         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')

   598         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')

   599         self.assertEqual(um.visitdir(b'dir/foo'), b'all')

   599         self.assertEqual(um.visitdir(b'dir/foo'), b'all')

   600         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')

   600         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')

   603     def testVisitchildrensetM2never(self):

   603     def testVisitchildrensetM2never(self):

   604         m1 = matchmod.alwaysmatcher()

   604         m1 = matchmod.alwaysmatcher()

   605         m2 = matchmod.nevermatcher()

   605         m2 = matchmod.nevermatcher()

   606         um = matchmod.unionmatcher([m1, m2])

   606         um = matchmod.unionmatcher([m1, m2])

   607         # um should be equivalent to a alwaysmatcher.

   607         # um should be equivalent to a alwaysmatcher.

   609         self.assertEqual(um.visitchildrenset(b'dir'), b'all')

   609         self.assertEqual(um.visitchildrenset(b'dir'), b'all')

   610         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   610         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   611         self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')

   611         self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')

   612         self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')

   612         self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')

   613         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')

   613         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')

   615 

   615 

   616     def testVisitdirM2SubdirPrefix(self):

   616     def testVisitdirM2SubdirPrefix(self):

   617         m1 = matchmod.alwaysmatcher()

   617         m1 = matchmod.alwaysmatcher()

   618         m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])

   618         m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])

   619         um = matchmod.unionmatcher([m1, m2])

   619         um = matchmod.unionmatcher([m1, m2])

   621         self.assertEqual(um.visitdir(b'dir'), b'all')

   621         self.assertEqual(um.visitdir(b'dir'), b'all')

   622         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   622         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   623         self.assertEqual(um.visitdir(b'dir/foo'), b'all')

   623         self.assertEqual(um.visitdir(b'dir/foo'), b'all')

   624         self.assertEqual(um.visitdir(b'folder'), b'all')

   624         self.assertEqual(um.visitdir(b'folder'), b'all')

   625         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')

   625         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')

   627 

   627 

   628     def testVisitchildrensetM2SubdirPrefix(self):

   628     def testVisitchildrensetM2SubdirPrefix(self):

   629         m1 = matchmod.alwaysmatcher()

   629         m1 = matchmod.alwaysmatcher()

   630         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   630         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   631         um = matchmod.unionmatcher([m1, m2])

   631         um = matchmod.unionmatcher([m1, m2])

   633         self.assertEqual(um.visitchildrenset(b'dir'), b'all')

   633         self.assertEqual(um.visitchildrenset(b'dir'), b'all')

   634         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   634         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   635         self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')

   635         self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')

   636         self.assertEqual(um.visitchildrenset(b'folder'), b'all')

   636         self.assertEqual(um.visitchildrenset(b'folder'), b'all')

   637         self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')

   637         self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')

   641     # better (giving narrower results) than patternmatcher.

   641     # better (giving narrower results) than patternmatcher.

   642     def testVisitdirIncludeIncludfe(self):

   642     def testVisitdirIncludeIncludfe(self):

   643         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   643         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   644         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])

   644         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])

   645         um = matchmod.unionmatcher([m1, m2])

   645         um = matchmod.unionmatcher([m1, m2])

   647         self.assertEqual(um.visitdir(b'dir'), True)

   647         self.assertEqual(um.visitdir(b'dir'), True)

   648         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   648         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   649         self.assertFalse(um.visitdir(b'dir/foo'))

   649         self.assertFalse(um.visitdir(b'dir/foo'))

   650         self.assertFalse(um.visitdir(b'folder'))

   650         self.assertFalse(um.visitdir(b'folder'))

   651         # OPT: These two should probably be 'all' not True.

   651         # OPT: These two should probably be 'all' not True.

   654 

   654 

   655     def testVisitchildrensetIncludeInclude(self):

   655     def testVisitchildrensetIncludeInclude(self):

   656         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   656         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   657         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])

   657         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])

   658         um = matchmod.unionmatcher([m1, m2])

   658         um = matchmod.unionmatcher([m1, m2])

   660         self.assertEqual(um.visitchildrenset(b'dir'), b'this')

   660         self.assertEqual(um.visitchildrenset(b'dir'), b'this')

   661         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   661         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   662         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())

   662         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())

   663         self.assertEqual(um.visitchildrenset(b'folder'), set())

   663         self.assertEqual(um.visitchildrenset(b'folder'), set())

   664         # OPT: These next two could be 'all' instead of 'this'.

   664         # OPT: These next two could be 'all' instead of 'this'.

   669     # better (giving narrower results) than patternmatcher.

   669     # better (giving narrower results) than patternmatcher.

   670     def testVisitdirIncludeInclude2(self):

   670     def testVisitdirIncludeInclude2(self):

   671         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   671         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   672         m2 = matchmod.match(b'', b'', include=[b'path:folder'])

   672         m2 = matchmod.match(b'', b'', include=[b'path:folder'])

   673         um = matchmod.unionmatcher([m1, m2])

   673         um = matchmod.unionmatcher([m1, m2])

   675         self.assertEqual(um.visitdir(b'dir'), True)

   675         self.assertEqual(um.visitdir(b'dir'), True)

   676         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   676         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   677         self.assertFalse(um.visitdir(b'dir/foo'))

   677         self.assertFalse(um.visitdir(b'dir/foo'))

   678         self.assertEqual(um.visitdir(b'folder'), b'all')

   678         self.assertEqual(um.visitdir(b'folder'), b'all')

   679         # OPT: These should probably be 'all' not True.

   679         # OPT: These should probably be 'all' not True.

   682 

   682 

   683     def testVisitchildrensetIncludeInclude2(self):

   683     def testVisitchildrensetIncludeInclude2(self):

   684         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   684         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   685         m2 = matchmod.match(b'', b'', include=[b'path:folder'])

   685         m2 = matchmod.match(b'', b'', include=[b'path:folder'])

   686         um = matchmod.unionmatcher([m1, m2])

   686         um = matchmod.unionmatcher([m1, m2])

   688         self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})

   688         self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})

   689         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   689         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   690         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())

   690         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())

   691         self.assertEqual(um.visitchildrenset(b'folder'), b'all')

   691         self.assertEqual(um.visitchildrenset(b'folder'), b'all')

   692         # OPT: These next two could be 'all' instead of 'this'.

   692         # OPT: These next two could be 'all' instead of 'this'.

   697     # better (giving narrower results) than patternmatcher.

   697     # better (giving narrower results) than patternmatcher.

   698     def testVisitdirIncludeInclude3(self):

   698     def testVisitdirIncludeInclude3(self):

   699         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   699         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   700         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   700         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   701         um = matchmod.unionmatcher([m1, m2])

   701         um = matchmod.unionmatcher([m1, m2])

   703         self.assertEqual(um.visitdir(b'dir'), True)

   703         self.assertEqual(um.visitdir(b'dir'), True)

   704         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   704         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')

   705         self.assertFalse(um.visitdir(b'dir/foo'))

   705         self.assertFalse(um.visitdir(b'dir/foo'))

   706         self.assertFalse(um.visitdir(b'folder'))

   706         self.assertFalse(um.visitdir(b'folder'))

   707         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')

   707         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')

   710 

   710 

   711     def testVisitchildrensetIncludeInclude3(self):

   711     def testVisitchildrensetIncludeInclude3(self):

   712         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   712         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   713         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   713         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   714         um = matchmod.unionmatcher([m1, m2])

   714         um = matchmod.unionmatcher([m1, m2])

   716         self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})

   716         self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})

   717         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   717         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')

   718         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())

   718         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())

   719         self.assertEqual(um.visitchildrenset(b'folder'), set())

   719         self.assertEqual(um.visitchildrenset(b'folder'), set())

   720         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')

   720         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')

   726     def testVisitdirIncludeInclude4(self):

   726     def testVisitdirIncludeInclude4(self):

   727         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   727         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   728         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])

   728         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])

   729         um = matchmod.unionmatcher([m1, m2])

   729         um = matchmod.unionmatcher([m1, m2])

   730         # OPT: these next three could probably be False as well.

   730         # OPT: these next three could probably be False as well.

   732         self.assertEqual(um.visitdir(b'dir'), True)

   732         self.assertEqual(um.visitdir(b'dir'), True)

   733         self.assertEqual(um.visitdir(b'dir/subdir'), True)

   733         self.assertEqual(um.visitdir(b'dir/subdir'), True)

   734         self.assertFalse(um.visitdir(b'dir/foo'))

   734         self.assertFalse(um.visitdir(b'dir/foo'))

   735         self.assertFalse(um.visitdir(b'folder'))

   735         self.assertFalse(um.visitdir(b'folder'))

   736         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')

   736         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')

   738 

   738 

   739     def testVisitchildrensetIncludeInclude4(self):

   739     def testVisitchildrensetIncludeInclude4(self):

   740         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   740         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])

   741         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])

   741         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])

   742         um = matchmod.unionmatcher([m1, m2])

   742         um = matchmod.unionmatcher([m1, m2])

   744         self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})

   744         self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})

   745         self.assertEqual(um.visitchildrenset(b'dir/subdir'), {b'x', b'z'})

   745         self.assertEqual(um.visitchildrenset(b'dir/subdir'), {b'x', b'z'})

   746         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())

   746         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())

   747         self.assertEqual(um.visitchildrenset(b'folder'), set())

   747         self.assertEqual(um.visitchildrenset(b'folder'), set())

   748         self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')

   748         self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')

   752 

   752 

   753     def testVisitdir(self):

   753     def testVisitdir(self):

   754         m = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   754         m = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   755         sm = matchmod.subdirmatcher(b'dir', m)

   755         sm = matchmod.subdirmatcher(b'dir', m)

   756 

   756 

   758         self.assertEqual(sm.visitdir(b'subdir'), b'all')

   758         self.assertEqual(sm.visitdir(b'subdir'), b'all')

   759         # OPT: These next two should probably be 'all' not True.

   759         # OPT: These next two should probably be 'all' not True.

   760         self.assertEqual(sm.visitdir(b'subdir/x'), True)

   760         self.assertEqual(sm.visitdir(b'subdir/x'), True)

   761         self.assertEqual(sm.visitdir(b'subdir/z'), True)

   761         self.assertEqual(sm.visitdir(b'subdir/z'), True)

   762         self.assertFalse(sm.visitdir(b'foo'))

   762         self.assertFalse(sm.visitdir(b'foo'))

   763 

   763 

   764     def testVisitchildrenset(self):

   764     def testVisitchildrenset(self):

   765         m = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   765         m = matchmod.match(b'', b'', include=[b'path:dir/subdir'])

   766         sm = matchmod.subdirmatcher(b'dir', m)

   766         sm = matchmod.subdirmatcher(b'dir', m)

   767 

   767 

   769         self.assertEqual(sm.visitchildrenset(b'subdir'), b'all')

   769         self.assertEqual(sm.visitchildrenset(b'subdir'), b'all')

   770         # OPT: These next two should probably be 'all' not 'this'.

   770         # OPT: These next two should probably be 'all' not 'this'.

   771         self.assertEqual(sm.visitchildrenset(b'subdir/x'), b'this')

   771         self.assertEqual(sm.visitchildrenset(b'subdir/x'), b'this')

   772         self.assertEqual(sm.visitchildrenset(b'subdir/z'), b'this')

   772         self.assertEqual(sm.visitchildrenset(b'subdir/z'), b'this')

   773         self.assertEqual(sm.visitchildrenset(b'foo'), set())

   773         self.assertEqual(sm.visitchildrenset(b'foo'), set())

   793         self.assertEqual(bool(pm(b'b.txt')), False)

   793         self.assertEqual(bool(pm(b'b.txt')), False)

   794         self.assertEqual(bool(pm(b'd/e/a.txt')), True)

   794         self.assertEqual(bool(pm(b'd/e/a.txt')), True)

   795         self.assertEqual(bool(pm(b'd/e/b.txt')), False)

   795         self.assertEqual(bool(pm(b'd/e/b.txt')), False)

   796         self.assertEqual(bool(pm(b'd/e/f/b.txt')), True)

   796         self.assertEqual(bool(pm(b'd/e/f/b.txt')), True)

   797 

   797 

   799         self.assertEqual(m.visitdir(b'e'), True)

   799         self.assertEqual(m.visitdir(b'e'), True)

   800         self.assertEqual(m.visitdir(b'e/f'), True)

   800         self.assertEqual(m.visitdir(b'e/f'), True)

   801         self.assertEqual(m.visitdir(b'e/f/g'), False)

   801         self.assertEqual(m.visitdir(b'e/f/g'), False)

   802 

   802 

   804         self.assertEqual(pm.visitdir(b'd'), True)

   804         self.assertEqual(pm.visitdir(b'd'), True)

   805         self.assertEqual(pm.visitdir(b'd/e'), True)

   805         self.assertEqual(pm.visitdir(b'd/e'), True)

   806         self.assertEqual(pm.visitdir(b'd/e/f'), True)

   806         self.assertEqual(pm.visitdir(b'd/e/f'), True)

   807         self.assertEqual(pm.visitdir(b'd/e/f/g'), False)

   807         self.assertEqual(pm.visitdir(b'd/e/f/g'), False)

   808 

   808 

   812         pm = matchmod.prefixdirmatcher(b'd', m)

   812         pm = matchmod.prefixdirmatcher(b'd', m)

   813 

   813 

   814         # OPT: visitchildrenset could possibly return {'e'} and {'f'} for these

   814         # OPT: visitchildrenset could possibly return {'e'} and {'f'} for these

   815         # next two, respectively; patternmatcher does not have this

   815         # next two, respectively; patternmatcher does not have this

   816         # optimization.

   816         # optimization.

   818         self.assertEqual(m.visitchildrenset(b'e'), b'this')

   818         self.assertEqual(m.visitchildrenset(b'e'), b'this')

   819         self.assertEqual(m.visitchildrenset(b'e/f'), b'this')

   819         self.assertEqual(m.visitchildrenset(b'e/f'), b'this')

   820         self.assertEqual(m.visitchildrenset(b'e/f/g'), set())

   820         self.assertEqual(m.visitchildrenset(b'e/f/g'), set())

   821 

   821 

   822         # OPT: visitchildrenset could possibly return {'d'}, {'e'}, and {'f'}

   822         # OPT: visitchildrenset could possibly return {'d'}, {'e'}, and {'f'}

   823         # for these next three, respectively; patternmatcher does not have this

   823         # for these next three, respectively; patternmatcher does not have this

   824         # optimization.

   824         # optimization.

   826         self.assertEqual(pm.visitchildrenset(b'd'), b'this')

   826         self.assertEqual(pm.visitchildrenset(b'd'), b'this')

   827         self.assertEqual(pm.visitchildrenset(b'd/e'), b'this')

   827         self.assertEqual(pm.visitchildrenset(b'd/e'), b'this')

   828         self.assertEqual(pm.visitchildrenset(b'd/e/f'), b'this')

   828         self.assertEqual(pm.visitchildrenset(b'd/e/f'), b'this')

   829         self.assertEqual(pm.visitchildrenset(b'd/e/f/g'), set())

   829         self.assertEqual(pm.visitchildrenset(b'd/e/f/g'), set())

   830 

   830