Mercurial Mercurial > mercurial / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
tests/test-match.py
changeset 43949 8b1a9ba375e5
parent 43375 c2c3ee8794dd
child 43964 8f67735344ae
equal deleted inserted replaced
43948:9595b6a9f0d5 43949:8b1a9ba375e5 
     6 
     6 
     7 from mercurial import (
 
     7 from mercurial import (
 
     8     match as matchmod,
 
     8     match as matchmod,
 
     9     util,
 
     9     util,
 
    10 )
 
    10 )
 
       
    11 
       
    12 
       
    13 noop_auditor = lambda name: None
 
    11 
    14 
    12 
    15 
    13 class BaseMatcherTests(unittest.TestCase):
 
    16 class BaseMatcherTests(unittest.TestCase):
 
    14     def testVisitdir(self):
 
    17     def testVisitdir(self):
 
    15         m = matchmod.basematcher()
 
    18         m = matchmod.basematcher()
 
    61         self.assertEqual(m.visitchildrenset(b'dir'), b'this')
 
    64         self.assertEqual(m.visitchildrenset(b'dir'), b'this')
 
    62 
    65 
    63 
    66 
    64 class PatternMatcherTests(unittest.TestCase):
 
    67 class PatternMatcherTests(unittest.TestCase):
 
    65     def testVisitdirPrefix(self):
 
    68     def testVisitdirPrefix(self):
 
    66         m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir'])
 
    69         m = matchmod.match(b'/repo', b'', patterns=[b'path:dir/subdir'])
 
    67         assert isinstance(m, matchmod.patternmatcher)
 
    70         assert isinstance(m, matchmod.patternmatcher)
 
    68         self.assertTrue(m.visitdir(b''))
 
    71         self.assertTrue(m.visitdir(b''))
 
    69         self.assertTrue(m.visitdir(b'dir'))
 
    72         self.assertTrue(m.visitdir(b'dir'))
 
    70         self.assertEqual(m.visitdir(b'dir/subdir'), b'all')
 
    73         self.assertEqual(m.visitdir(b'dir/subdir'), b'all')
 
    71         # OPT: This should probably be 'all' if its parent is?
 
    74         # OPT: This should probably be 'all' if its parent is?
 
    72         self.assertTrue(m.visitdir(b'dir/subdir/x'))
 
    75         self.assertTrue(m.visitdir(b'dir/subdir/x'))
 
    73         self.assertFalse(m.visitdir(b'folder'))
 
    76         self.assertFalse(m.visitdir(b'folder'))
 
    74 
    77 
    75     def testVisitchildrensetPrefix(self):
 
    78     def testVisitchildrensetPrefix(self):
 
    76         m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir'])
 
    79         m = matchmod.match(b'/repo', b'', patterns=[b'path:dir/subdir'])
 
    77         assert isinstance(m, matchmod.patternmatcher)
 
    80         assert isinstance(m, matchmod.patternmatcher)
 
    78         self.assertEqual(m.visitchildrenset(b''), b'this')
 
    81         self.assertEqual(m.visitchildrenset(b''), b'this')
 
    79         self.assertEqual(m.visitchildrenset(b'dir'), b'this')
 
    82         self.assertEqual(m.visitchildrenset(b'dir'), b'this')
 
    80         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')
 
    83         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')
 
    81         # OPT: This should probably be 'all' if its parent is?
 
    84         # OPT: This should probably be 'all' if its parent is?
 
    82         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
 
    85         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
 
    83         self.assertEqual(m.visitchildrenset(b'folder'), set())
 
    86         self.assertEqual(m.visitchildrenset(b'folder'), set())
 
    84 
    87 
    85     def testVisitdirRootfilesin(self):
 
    88     def testVisitdirRootfilesin(self):
 
    86         m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir'])
 
    89         m = matchmod.match(b'/repo', b'', patterns=[b'rootfilesin:dir/subdir'])
 
    87         assert isinstance(m, matchmod.patternmatcher)
 
    90         assert isinstance(m, matchmod.patternmatcher)
 
    88         self.assertFalse(m.visitdir(b'dir/subdir/x'))
 
    91         self.assertFalse(m.visitdir(b'dir/subdir/x'))
 
    89         self.assertFalse(m.visitdir(b'folder'))
 
    92         self.assertFalse(m.visitdir(b'folder'))
 
    90         # FIXME: These should probably be True.
 
    93         # FIXME: These should probably be True.
 
    91         self.assertFalse(m.visitdir(b''))
 
    94         self.assertFalse(m.visitdir(b''))
 
    92         self.assertFalse(m.visitdir(b'dir'))
 
    95         self.assertFalse(m.visitdir(b'dir'))
 
    93         self.assertFalse(m.visitdir(b'dir/subdir'))
 
    96         self.assertFalse(m.visitdir(b'dir/subdir'))
 
    94 
    97 
    95     def testVisitchildrensetRootfilesin(self):
 
    98     def testVisitchildrensetRootfilesin(self):
 
    96         m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir'])
 
    99         m = matchmod.match(b'/repo', b'', patterns=[b'rootfilesin:dir/subdir'])
 
    97         assert isinstance(m, matchmod.patternmatcher)
 
   100         assert isinstance(m, matchmod.patternmatcher)
 
    98         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())
 
   101         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())
 
    99         self.assertEqual(m.visitchildrenset(b'folder'), set())
 
   102         self.assertEqual(m.visitchildrenset(b'folder'), set())
 
   100         # FIXME: These should probably be {'dir'}, {'subdir'} and 'this',
 
   103         # FIXME: These should probably be {'dir'}, {'subdir'} and 'this',
 
   101         # respectively, or at least 'this' for all three.
 
   104         # respectively, or at least 'this' for all three.
 
   102         self.assertEqual(m.visitchildrenset(b''), set())
 
   105         self.assertEqual(m.visitchildrenset(b''), set())
 
   103         self.assertEqual(m.visitchildrenset(b'dir'), set())
 
   106         self.assertEqual(m.visitchildrenset(b'dir'), set())
 
   104         self.assertEqual(m.visitchildrenset(b'dir/subdir'), set())
 
   107         self.assertEqual(m.visitchildrenset(b'dir/subdir'), set())
 
   105 
   108 
   106     def testVisitdirGlob(self):
 
   109     def testVisitdirGlob(self):
 
   107         m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*'])
 
   110         m = matchmod.match(b'/repo', b'', patterns=[b'glob:dir/z*'])
 
   108         assert isinstance(m, matchmod.patternmatcher)
 
   111         assert isinstance(m, matchmod.patternmatcher)
 
   109         self.assertTrue(m.visitdir(b''))
 
   112         self.assertTrue(m.visitdir(b''))
 
   110         self.assertTrue(m.visitdir(b'dir'))
 
   113         self.assertTrue(m.visitdir(b'dir'))
 
   111         self.assertFalse(m.visitdir(b'folder'))
 
   114         self.assertFalse(m.visitdir(b'folder'))
 
   112         # OPT: these should probably be False.
 
   115         # OPT: these should probably be False.
 
   113         self.assertTrue(m.visitdir(b'dir/subdir'))
 
   116         self.assertTrue(m.visitdir(b'dir/subdir'))
 
   114         self.assertTrue(m.visitdir(b'dir/subdir/x'))
 
   117         self.assertTrue(m.visitdir(b'dir/subdir/x'))
 
   115 
   118 
   116     def testVisitchildrensetGlob(self):
 
   119     def testVisitchildrensetGlob(self):
 
   117         m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*'])
 
   120         m = matchmod.match(b'/repo', b'', patterns=[b'glob:dir/z*'])
 
   118         assert isinstance(m, matchmod.patternmatcher)
 
   121         assert isinstance(m, matchmod.patternmatcher)
 
   119         self.assertEqual(m.visitchildrenset(b''), b'this')
 
   122         self.assertEqual(m.visitchildrenset(b''), b'this')
 
   120         self.assertEqual(m.visitchildrenset(b'folder'), set())
 
   123         self.assertEqual(m.visitchildrenset(b'folder'), set())
 
   121         self.assertEqual(m.visitchildrenset(b'dir'), b'this')
 
   124         self.assertEqual(m.visitchildrenset(b'dir'), b'this')
 
   122         # OPT: these should probably be set().
 
   125         # OPT: these should probably be set().
 
   124         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
 
   127         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
 
   125 
   128 
   126 
   129 
   127 class IncludeMatcherTests(unittest.TestCase):
 
   130 class IncludeMatcherTests(unittest.TestCase):
 
   128     def testVisitdirPrefix(self):
 
   131     def testVisitdirPrefix(self):
 
   129         m = matchmod.match(b'x', b'', include=[b'path:dir/subdir'])
 
   132         m = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   130         assert isinstance(m, matchmod.includematcher)
 
   133         assert isinstance(m, matchmod.includematcher)
 
   131         self.assertTrue(m.visitdir(b''))
 
   134         self.assertTrue(m.visitdir(b''))
 
   132         self.assertTrue(m.visitdir(b'dir'))
 
   135         self.assertTrue(m.visitdir(b'dir'))
 
   133         self.assertEqual(m.visitdir(b'dir/subdir'), b'all')
 
   136         self.assertEqual(m.visitdir(b'dir/subdir'), b'all')
 
   134         # OPT: This should probably be 'all' if its parent is?
 
   137         # OPT: This should probably be 'all' if its parent is?
 
   135         self.assertTrue(m.visitdir(b'dir/subdir/x'))
 
   138         self.assertTrue(m.visitdir(b'dir/subdir/x'))
 
   136         self.assertFalse(m.visitdir(b'folder'))
 
   139         self.assertFalse(m.visitdir(b'folder'))
 
   137 
   140 
   138     def testVisitchildrensetPrefix(self):
 
   141     def testVisitchildrensetPrefix(self):
 
   139         m = matchmod.match(b'x', b'', include=[b'path:dir/subdir'])
 
   142         m = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   140         assert isinstance(m, matchmod.includematcher)
 
   143         assert isinstance(m, matchmod.includematcher)
 
   141         self.assertEqual(m.visitchildrenset(b''), {b'dir'})
 
   144         self.assertEqual(m.visitchildrenset(b''), {b'dir'})
 
   142         self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})
 
   145         self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})
 
   143         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')
 
   146         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')
 
   144         # OPT: This should probably be 'all' if its parent is?
 
   147         # OPT: This should probably be 'all' if its parent is?
 
   145         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
 
   148         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
 
   146         self.assertEqual(m.visitchildrenset(b'folder'), set())
 
   149         self.assertEqual(m.visitchildrenset(b'folder'), set())
 
   147 
   150 
   148     def testVisitdirRootfilesin(self):
 
   151     def testVisitdirRootfilesin(self):
 
   149         m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir'])
 
   152         m = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir/subdir'])
 
   150         assert isinstance(m, matchmod.includematcher)
 
   153         assert isinstance(m, matchmod.includematcher)
 
   151         self.assertTrue(m.visitdir(b''))
 
   154         self.assertTrue(m.visitdir(b''))
 
   152         self.assertTrue(m.visitdir(b'dir'))
 
   155         self.assertTrue(m.visitdir(b'dir'))
 
   153         self.assertTrue(m.visitdir(b'dir/subdir'))
 
   156         self.assertTrue(m.visitdir(b'dir/subdir'))
 
   154         self.assertFalse(m.visitdir(b'dir/subdir/x'))
 
   157         self.assertFalse(m.visitdir(b'dir/subdir/x'))
 
   155         self.assertFalse(m.visitdir(b'folder'))
 
   158         self.assertFalse(m.visitdir(b'folder'))
 
   156 
   159 
   157     def testVisitchildrensetRootfilesin(self):
 
   160     def testVisitchildrensetRootfilesin(self):
 
   158         m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir'])
 
   161         m = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir/subdir'])
 
   159         assert isinstance(m, matchmod.includematcher)
 
   162         assert isinstance(m, matchmod.includematcher)
 
   160         self.assertEqual(m.visitchildrenset(b''), {b'dir'})
 
   163         self.assertEqual(m.visitchildrenset(b''), {b'dir'})
 
   161         self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})
 
   164         self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})
 
   162         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')
 
   165         self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')
 
   163         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())
 
   166         self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())
 
   164         self.assertEqual(m.visitchildrenset(b'folder'), set())
 
   167         self.assertEqual(m.visitchildrenset(b'folder'), set())
 
   165 
   168 
   166     def testVisitdirGlob(self):
 
   169     def testVisitdirGlob(self):
 
   167         m = matchmod.match(b'x', b'', include=[b'glob:dir/z*'])
 
   170         m = matchmod.match(b'/repo', b'', include=[b'glob:dir/z*'])
 
   168         assert isinstance(m, matchmod.includematcher)
 
   171         assert isinstance(m, matchmod.includematcher)
 
   169         self.assertTrue(m.visitdir(b''))
 
   172         self.assertTrue(m.visitdir(b''))
 
   170         self.assertTrue(m.visitdir(b'dir'))
 
   173         self.assertTrue(m.visitdir(b'dir'))
 
   171         self.assertFalse(m.visitdir(b'folder'))
 
   174         self.assertFalse(m.visitdir(b'folder'))
 
   172         # OPT: these should probably be False.
 
   175         # OPT: these should probably be False.
 
   173         self.assertTrue(m.visitdir(b'dir/subdir'))
 
   176         self.assertTrue(m.visitdir(b'dir/subdir'))
 
   174         self.assertTrue(m.visitdir(b'dir/subdir/x'))
 
   177         self.assertTrue(m.visitdir(b'dir/subdir/x'))
 
   175 
   178 
   176     def testVisitchildrensetGlob(self):
 
   179     def testVisitchildrensetGlob(self):
 
   177         m = matchmod.match(b'x', b'', include=[b'glob:dir/z*'])
 
   180         m = matchmod.match(b'/repo', b'', include=[b'glob:dir/z*'])
 
   178         assert isinstance(m, matchmod.includematcher)
 
   181         assert isinstance(m, matchmod.includematcher)
 
   179         self.assertEqual(m.visitchildrenset(b''), {b'dir'})
 
   182         self.assertEqual(m.visitchildrenset(b''), {b'dir'})
 
   180         self.assertEqual(m.visitchildrenset(b'folder'), set())
 
   183         self.assertEqual(m.visitchildrenset(b'folder'), set())
 
   181         self.assertEqual(m.visitchildrenset(b'dir'), b'this')
 
   184         self.assertEqual(m.visitchildrenset(b'dir'), b'this')
 
   182         # OPT: these should probably be set().
 
   185         # OPT: these should probably be set().
 
   284         self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'all')
 
   287         self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'all')
 
   285         self.assertEqual(dm.visitchildrenset(b'folder'), b'all')
 
   288         self.assertEqual(dm.visitchildrenset(b'folder'), b'all')
 
   286 
   289 
   287     def testVisitdirM2SubdirPrefix(self):
 
   290     def testVisitdirM2SubdirPrefix(self):
 
   288         m1 = matchmod.alwaysmatcher()
 
   291         m1 = matchmod.alwaysmatcher()
 
   289         m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])
 
   292         m2 = matchmod.match(b'/repo', b'', patterns=[b'path:dir/subdir'])
 
   290         dm = matchmod.differencematcher(m1, m2)
 
   293         dm = matchmod.differencematcher(m1, m2)
 
   291         self.assertEqual(dm.visitdir(b''), True)
 
   294         self.assertEqual(dm.visitdir(b''), True)
 
   292         self.assertEqual(dm.visitdir(b'dir'), True)
 
   295         self.assertEqual(dm.visitdir(b'dir'), True)
 
   293         self.assertFalse(dm.visitdir(b'dir/subdir'))
 
   296         self.assertFalse(dm.visitdir(b'dir/subdir'))
 
   294         # OPT: We should probably return False for these; we don't because
 
   297         # OPT: We should probably return False for these; we don't because
 
   299         self.assertEqual(dm.visitdir(b'dir/foo'), b'all')
 
   302         self.assertEqual(dm.visitdir(b'dir/foo'), b'all')
 
   300         self.assertEqual(dm.visitdir(b'folder'), b'all')
 
   303         self.assertEqual(dm.visitdir(b'folder'), b'all')
 
   301 
   304 
   302     def testVisitchildrensetM2SubdirPrefix(self):
 
   305     def testVisitchildrensetM2SubdirPrefix(self):
 
   303         m1 = matchmod.alwaysmatcher()
 
   306         m1 = matchmod.alwaysmatcher()
 
   304         m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])
 
   307         m2 = matchmod.match(b'/repo', b'', patterns=[b'path:dir/subdir'])
 
   305         dm = matchmod.differencematcher(m1, m2)
 
   308         dm = matchmod.differencematcher(m1, m2)
 
   306         self.assertEqual(dm.visitchildrenset(b''), b'this')
 
   309         self.assertEqual(dm.visitchildrenset(b''), b'this')
 
   307         self.assertEqual(dm.visitchildrenset(b'dir'), b'this')
 
   310         self.assertEqual(dm.visitchildrenset(b'dir'), b'this')
 
   308         self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set())
 
   311         self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set())
 
   309         self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all')
 
   312         self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all')
 
   315         self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'this')
 
   318         self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'this')
 
   316 
   319 
   317     # We're using includematcher instead of patterns because it behaves slightly
 
   320     # We're using includematcher instead of patterns because it behaves slightly
 
   318     # better (giving narrower results) than patternmatcher.
 
   321     # better (giving narrower results) than patternmatcher.
 
   319     def testVisitdirIncludeInclude(self):
 
   322     def testVisitdirIncludeInclude(self):
 
   320         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   323         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   321         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
 
   324         m2 = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir'])
 
   322         dm = matchmod.differencematcher(m1, m2)
 
   325         dm = matchmod.differencematcher(m1, m2)
 
   323         self.assertEqual(dm.visitdir(b''), True)
 
   326         self.assertEqual(dm.visitdir(b''), True)
 
   324         self.assertEqual(dm.visitdir(b'dir'), True)
 
   327         self.assertEqual(dm.visitdir(b'dir'), True)
 
   325         self.assertEqual(dm.visitdir(b'dir/subdir'), b'all')
 
   328         self.assertEqual(dm.visitdir(b'dir/subdir'), b'all')
 
   326         self.assertFalse(dm.visitdir(b'dir/foo'))
 
   329         self.assertFalse(dm.visitdir(b'dir/foo'))
 
   330         # an 'all' pattern, just True.
 
   333         # an 'all' pattern, just True.
 
   331         self.assertEqual(dm.visitdir(b'dir/subdir/z'), True)
 
   334         self.assertEqual(dm.visitdir(b'dir/subdir/z'), True)
 
   332         self.assertEqual(dm.visitdir(b'dir/subdir/x'), True)
 
   335         self.assertEqual(dm.visitdir(b'dir/subdir/x'), True)
 
   333 
   336 
   334     def testVisitchildrensetIncludeInclude(self):
 
   337     def testVisitchildrensetIncludeInclude(self):
 
   335         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   338         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   336         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
 
   339         m2 = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir'])
 
   337         dm = matchmod.differencematcher(m1, m2)
 
   340         dm = matchmod.differencematcher(m1, m2)
 
   338         self.assertEqual(dm.visitchildrenset(b''), {b'dir'})
 
   341         self.assertEqual(dm.visitchildrenset(b''), {b'dir'})
 
   339         self.assertEqual(dm.visitchildrenset(b'dir'), {b'subdir'})
 
   342         self.assertEqual(dm.visitchildrenset(b'dir'), {b'subdir'})
 
   340         self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all')
 
   343         self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all')
 
   341         self.assertEqual(dm.visitchildrenset(b'dir/foo'), set())
 
   344         self.assertEqual(dm.visitchildrenset(b'dir/foo'), set())
 
   400         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
 
   403         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
 
   401         self.assertEqual(im.visitchildrenset(b'folder'), set())
 
   404         self.assertEqual(im.visitchildrenset(b'folder'), set())
 
   402 
   405 
   403     def testVisitdirM2SubdirPrefix(self):
 
   406     def testVisitdirM2SubdirPrefix(self):
 
   404         m1 = matchmod.alwaysmatcher()
 
   407         m1 = matchmod.alwaysmatcher()
 
   405         m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])
 
   408         m2 = matchmod.match(b'/repo', b'', patterns=[b'path:dir/subdir'])
 
   406         im = matchmod.intersectmatchers(m1, m2)
 
   409         im = matchmod.intersectmatchers(m1, m2)
 
   407         self.assertEqual(im.visitdir(b''), True)
 
   410         self.assertEqual(im.visitdir(b''), True)
 
   408         self.assertEqual(im.visitdir(b'dir'), True)
 
   411         self.assertEqual(im.visitdir(b'dir'), True)
 
   409         self.assertEqual(im.visitdir(b'dir/subdir'), b'all')
 
   412         self.assertEqual(im.visitdir(b'dir/subdir'), b'all')
 
   410         self.assertFalse(im.visitdir(b'dir/foo'))
 
   413         self.assertFalse(im.visitdir(b'dir/foo'))
 
   415         self.assertEqual(im.visitdir(b'dir/subdir/z'), True)
 
   418         self.assertEqual(im.visitdir(b'dir/subdir/z'), True)
 
   416         self.assertEqual(im.visitdir(b'dir/subdir/x'), True)
 
   419         self.assertEqual(im.visitdir(b'dir/subdir/x'), True)
 
   417 
   420 
   418     def testVisitchildrensetM2SubdirPrefix(self):
 
   421     def testVisitchildrensetM2SubdirPrefix(self):
 
   419         m1 = matchmod.alwaysmatcher()
 
   422         m1 = matchmod.alwaysmatcher()
 
   420         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   423         m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   421         im = matchmod.intersectmatchers(m1, m2)
 
   424         im = matchmod.intersectmatchers(m1, m2)
 
   422         self.assertEqual(im.visitchildrenset(b''), {b'dir'})
 
   425         self.assertEqual(im.visitchildrenset(b''), {b'dir'})
 
   423         self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
 
   426         self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
 
   424         self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all')
 
   427         self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all')
 
   425         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
 
   428         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
 
   429         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this')
 
   432         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this')
 
   430 
   433 
   431     # We're using includematcher instead of patterns because it behaves slightly
 
   434     # We're using includematcher instead of patterns because it behaves slightly
 
   432     # better (giving narrower results) than patternmatcher.
 
   435     # better (giving narrower results) than patternmatcher.
 
   433     def testVisitdirIncludeInclude(self):
 
   436     def testVisitdirIncludeInclude(self):
 
   434         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   437         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   435         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
 
   438         m2 = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir'])
 
   436         im = matchmod.intersectmatchers(m1, m2)
 
   439         im = matchmod.intersectmatchers(m1, m2)
 
   437         self.assertEqual(im.visitdir(b''), True)
 
   440         self.assertEqual(im.visitdir(b''), True)
 
   438         self.assertEqual(im.visitdir(b'dir'), True)
 
   441         self.assertEqual(im.visitdir(b'dir'), True)
 
   439         self.assertFalse(im.visitdir(b'dir/subdir'))
 
   442         self.assertFalse(im.visitdir(b'dir/subdir'))
 
   440         self.assertFalse(im.visitdir(b'dir/foo'))
 
   443         self.assertFalse(im.visitdir(b'dir/foo'))
 
   441         self.assertFalse(im.visitdir(b'folder'))
 
   444         self.assertFalse(im.visitdir(b'folder'))
 
   442         self.assertFalse(im.visitdir(b'dir/subdir/z'))
 
   445         self.assertFalse(im.visitdir(b'dir/subdir/z'))
 
   443         self.assertFalse(im.visitdir(b'dir/subdir/x'))
 
   446         self.assertFalse(im.visitdir(b'dir/subdir/x'))
 
   444 
   447 
   445     def testVisitchildrensetIncludeInclude(self):
 
   448     def testVisitchildrensetIncludeInclude(self):
 
   446         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   449         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   447         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
 
   450         m2 = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir'])
 
   448         im = matchmod.intersectmatchers(m1, m2)
 
   451         im = matchmod.intersectmatchers(m1, m2)
 
   449         self.assertEqual(im.visitchildrenset(b''), {b'dir'})
 
   452         self.assertEqual(im.visitchildrenset(b''), {b'dir'})
 
   450         self.assertEqual(im.visitchildrenset(b'dir'), b'this')
 
   453         self.assertEqual(im.visitchildrenset(b'dir'), b'this')
 
   451         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
 
   454         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
 
   452         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
 
   455         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
 
   455         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
 
   458         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
 
   456 
   459 
   457     # We're using includematcher instead of patterns because it behaves slightly
 
   460     # We're using includematcher instead of patterns because it behaves slightly
 
   458     # better (giving narrower results) than patternmatcher.
 
   461     # better (giving narrower results) than patternmatcher.
 
   459     def testVisitdirIncludeInclude2(self):
 
   462     def testVisitdirIncludeInclude2(self):
 
   460         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   463         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   461         m2 = matchmod.match(b'', b'', include=[b'path:folder'])
 
   464         m2 = matchmod.match(b'/repo', b'', include=[b'path:folder'])
 
   462         im = matchmod.intersectmatchers(m1, m2)
 
   465         im = matchmod.intersectmatchers(m1, m2)
 
   463         # FIXME: is True correct here?
 
   466         # FIXME: is True correct here?
 
   464         self.assertEqual(im.visitdir(b''), True)
 
   467         self.assertEqual(im.visitdir(b''), True)
 
   465         self.assertFalse(im.visitdir(b'dir'))
 
   468         self.assertFalse(im.visitdir(b'dir'))
 
   466         self.assertFalse(im.visitdir(b'dir/subdir'))
 
   469         self.assertFalse(im.visitdir(b'dir/subdir'))
 
   468         self.assertFalse(im.visitdir(b'folder'))
 
   471         self.assertFalse(im.visitdir(b'folder'))
 
   469         self.assertFalse(im.visitdir(b'dir/subdir/z'))
 
   472         self.assertFalse(im.visitdir(b'dir/subdir/z'))
 
   470         self.assertFalse(im.visitdir(b'dir/subdir/x'))
 
   473         self.assertFalse(im.visitdir(b'dir/subdir/x'))
 
   471 
   474 
   472     def testVisitchildrensetIncludeInclude2(self):
 
   475     def testVisitchildrensetIncludeInclude2(self):
 
   473         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   476         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   474         m2 = matchmod.match(b'', b'', include=[b'path:folder'])
 
   477         m2 = matchmod.match(b'/repo', b'', include=[b'path:folder'])
 
   475         im = matchmod.intersectmatchers(m1, m2)
 
   478         im = matchmod.intersectmatchers(m1, m2)
 
   476         # FIXME: is set() correct here?
 
   479         # FIXME: is set() correct here?
 
   477         self.assertEqual(im.visitchildrenset(b''), set())
 
   480         self.assertEqual(im.visitchildrenset(b''), set())
 
   478         self.assertEqual(im.visitchildrenset(b'dir'), set())
 
   481         self.assertEqual(im.visitchildrenset(b'dir'), set())
 
   479         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
 
   482         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
 
   483         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
 
   486         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
 
   484 
   487 
   485     # We're using includematcher instead of patterns because it behaves slightly
 
   488     # We're using includematcher instead of patterns because it behaves slightly
 
   486     # better (giving narrower results) than patternmatcher.
 
   489     # better (giving narrower results) than patternmatcher.
 
   487     def testVisitdirIncludeInclude3(self):
 
   490     def testVisitdirIncludeInclude3(self):
 
   488         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
 
   491         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x'])
 
   489         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   492         m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   490         im = matchmod.intersectmatchers(m1, m2)
 
   493         im = matchmod.intersectmatchers(m1, m2)
 
   491         self.assertEqual(im.visitdir(b''), True)
 
   494         self.assertEqual(im.visitdir(b''), True)
 
   492         self.assertEqual(im.visitdir(b'dir'), True)
 
   495         self.assertEqual(im.visitdir(b'dir'), True)
 
   493         self.assertEqual(im.visitdir(b'dir/subdir'), True)
 
   496         self.assertEqual(im.visitdir(b'dir/subdir'), True)
 
   494         self.assertFalse(im.visitdir(b'dir/foo'))
 
   497         self.assertFalse(im.visitdir(b'dir/foo'))
 
   496         self.assertFalse(im.visitdir(b'dir/subdir/z'))
 
   499         self.assertFalse(im.visitdir(b'dir/subdir/z'))
 
   497         # OPT: this should probably be 'all' not True.
 
   500         # OPT: this should probably be 'all' not True.
 
   498         self.assertEqual(im.visitdir(b'dir/subdir/x'), True)
 
   501         self.assertEqual(im.visitdir(b'dir/subdir/x'), True)
 
   499 
   502 
   500     def testVisitchildrensetIncludeInclude3(self):
 
   503     def testVisitchildrensetIncludeInclude3(self):
 
   501         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
 
   504         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x'])
 
   502         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   505         m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   503         im = matchmod.intersectmatchers(m1, m2)
 
   506         im = matchmod.intersectmatchers(m1, m2)
 
   504         self.assertEqual(im.visitchildrenset(b''), {b'dir'})
 
   507         self.assertEqual(im.visitchildrenset(b''), {b'dir'})
 
   505         self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
 
   508         self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
 
   506         self.assertEqual(im.visitchildrenset(b'dir/subdir'), {b'x'})
 
   509         self.assertEqual(im.visitchildrenset(b'dir/subdir'), {b'x'})
 
   507         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
 
   510         self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
 
   511         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this')
 
   514         self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this')
 
   512 
   515 
   513     # We're using includematcher instead of patterns because it behaves slightly
 
   516     # We're using includematcher instead of patterns because it behaves slightly
 
   514     # better (giving narrower results) than patternmatcher.
 
   517     # better (giving narrower results) than patternmatcher.
 
   515     def testVisitdirIncludeInclude4(self):
 
   518     def testVisitdirIncludeInclude4(self):
 
   516         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
 
   519         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x'])
 
   517         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])
 
   520         m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/z'])
 
   518         im = matchmod.intersectmatchers(m1, m2)
 
   521         im = matchmod.intersectmatchers(m1, m2)
 
   519         # OPT: these next three could probably be False as well.
 
   522         # OPT: these next three could probably be False as well.
 
   520         self.assertEqual(im.visitdir(b''), True)
 
   523         self.assertEqual(im.visitdir(b''), True)
 
   521         self.assertEqual(im.visitdir(b'dir'), True)
 
   524         self.assertEqual(im.visitdir(b'dir'), True)
 
   522         self.assertEqual(im.visitdir(b'dir/subdir'), True)
 
   525         self.assertEqual(im.visitdir(b'dir/subdir'), True)
 
   524         self.assertFalse(im.visitdir(b'folder'))
 
   527         self.assertFalse(im.visitdir(b'folder'))
 
   525         self.assertFalse(im.visitdir(b'dir/subdir/z'))
 
   528         self.assertFalse(im.visitdir(b'dir/subdir/z'))
 
   526         self.assertFalse(im.visitdir(b'dir/subdir/x'))
 
   529         self.assertFalse(im.visitdir(b'dir/subdir/x'))
 
   527 
   530 
   528     def testVisitchildrensetIncludeInclude4(self):
 
   531     def testVisitchildrensetIncludeInclude4(self):
 
   529         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
 
   532         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x'])
 
   530         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])
 
   533         m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/z'])
 
   531         im = matchmod.intersectmatchers(m1, m2)
 
   534         im = matchmod.intersectmatchers(m1, m2)
 
   532         # OPT: these next two could probably be set() as well.
 
   535         # OPT: these next two could probably be set() as well.
 
   533         self.assertEqual(im.visitchildrenset(b''), {b'dir'})
 
   536         self.assertEqual(im.visitchildrenset(b''), {b'dir'})
 
   534         self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
 
   537         self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
 
   535         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
 
   538         self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
 
   618         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
 
   621         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
 
   619         self.assertEqual(um.visitchildrenset(b'folder'), b'all')
 
   622         self.assertEqual(um.visitchildrenset(b'folder'), b'all')
 
   620 
   623 
   621     def testVisitdirM2SubdirPrefix(self):
 
   624     def testVisitdirM2SubdirPrefix(self):
 
   622         m1 = matchmod.alwaysmatcher()
 
   625         m1 = matchmod.alwaysmatcher()
 
   623         m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])
 
   626         m2 = matchmod.match(b'/repo', b'', patterns=[b'path:dir/subdir'])
 
   624         um = matchmod.unionmatcher([m1, m2])
 
   627         um = matchmod.unionmatcher([m1, m2])
 
   625         self.assertEqual(um.visitdir(b''), b'all')
 
   628         self.assertEqual(um.visitdir(b''), b'all')
 
   626         self.assertEqual(um.visitdir(b'dir'), b'all')
 
   629         self.assertEqual(um.visitdir(b'dir'), b'all')
 
   627         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
 
   630         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
 
   628         self.assertEqual(um.visitdir(b'dir/foo'), b'all')
 
   631         self.assertEqual(um.visitdir(b'dir/foo'), b'all')
 
   630         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')
 
   633         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')
 
   631         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
 
   634         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
 
   632 
   635 
   633     def testVisitchildrensetM2SubdirPrefix(self):
 
   636     def testVisitchildrensetM2SubdirPrefix(self):
 
   634         m1 = matchmod.alwaysmatcher()
 
   637         m1 = matchmod.alwaysmatcher()
 
   635         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   638         m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   636         um = matchmod.unionmatcher([m1, m2])
 
   639         um = matchmod.unionmatcher([m1, m2])
 
   637         self.assertEqual(um.visitchildrenset(b''), b'all')
 
   640         self.assertEqual(um.visitchildrenset(b''), b'all')
 
   638         self.assertEqual(um.visitchildrenset(b'dir'), b'all')
 
   641         self.assertEqual(um.visitchildrenset(b'dir'), b'all')
 
   639         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
 
   642         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
 
   640         self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')
 
   643         self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')
 
   643         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
 
   646         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
 
   644 
   647 
   645     # We're using includematcher instead of patterns because it behaves slightly
 
   648     # We're using includematcher instead of patterns because it behaves slightly
 
   646     # better (giving narrower results) than patternmatcher.
 
   649     # better (giving narrower results) than patternmatcher.
 
   647     def testVisitdirIncludeInclude(self):
 
   650     def testVisitdirIncludeInclude(self):
 
   648         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   651         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   649         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
 
   652         m2 = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir'])
 
   650         um = matchmod.unionmatcher([m1, m2])
 
   653         um = matchmod.unionmatcher([m1, m2])
 
   651         self.assertEqual(um.visitdir(b''), True)
 
   654         self.assertEqual(um.visitdir(b''), True)
 
   652         self.assertEqual(um.visitdir(b'dir'), True)
 
   655         self.assertEqual(um.visitdir(b'dir'), True)
 
   653         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
 
   656         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
 
   654         self.assertFalse(um.visitdir(b'dir/foo'))
 
   657         self.assertFalse(um.visitdir(b'dir/foo'))
 
   656         # OPT: These two should probably be 'all' not True.
 
   659         # OPT: These two should probably be 'all' not True.
 
   657         self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
 
   660         self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
 
   658         self.assertEqual(um.visitdir(b'dir/subdir/x'), True)
 
   661         self.assertEqual(um.visitdir(b'dir/subdir/x'), True)
 
   659 
   662 
   660     def testVisitchildrensetIncludeInclude(self):
 
   663     def testVisitchildrensetIncludeInclude(self):
 
   661         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   664         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   662         m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
 
   665         m2 = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir'])
 
   663         um = matchmod.unionmatcher([m1, m2])
 
   666         um = matchmod.unionmatcher([m1, m2])
 
   664         self.assertEqual(um.visitchildrenset(b''), {b'dir'})
 
   667         self.assertEqual(um.visitchildrenset(b''), {b'dir'})
 
   665         self.assertEqual(um.visitchildrenset(b'dir'), b'this')
 
   668         self.assertEqual(um.visitchildrenset(b'dir'), b'this')
 
   666         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
 
   669         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
 
   667         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
 
   670         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
 
   671         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this')
 
   674         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this')
 
   672 
   675 
   673     # We're using includematcher instead of patterns because it behaves slightly
 
   676     # We're using includematcher instead of patterns because it behaves slightly
 
   674     # better (giving narrower results) than patternmatcher.
 
   677     # better (giving narrower results) than patternmatcher.
 
   675     def testVisitdirIncludeInclude2(self):
 
   678     def testVisitdirIncludeInclude2(self):
 
   676         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   679         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   677         m2 = matchmod.match(b'', b'', include=[b'path:folder'])
 
   680         m2 = matchmod.match(b'/repo', b'', include=[b'path:folder'])
 
   678         um = matchmod.unionmatcher([m1, m2])
 
   681         um = matchmod.unionmatcher([m1, m2])
 
   679         self.assertEqual(um.visitdir(b''), True)
 
   682         self.assertEqual(um.visitdir(b''), True)
 
   680         self.assertEqual(um.visitdir(b'dir'), True)
 
   683         self.assertEqual(um.visitdir(b'dir'), True)
 
   681         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
 
   684         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
 
   682         self.assertFalse(um.visitdir(b'dir/foo'))
 
   685         self.assertFalse(um.visitdir(b'dir/foo'))
 
   684         # OPT: These should probably be 'all' not True.
 
   687         # OPT: These should probably be 'all' not True.
 
   685         self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
 
   688         self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
 
   686         self.assertEqual(um.visitdir(b'dir/subdir/x'), True)
 
   689         self.assertEqual(um.visitdir(b'dir/subdir/x'), True)
 
   687 
   690 
   688     def testVisitchildrensetIncludeInclude2(self):
 
   691     def testVisitchildrensetIncludeInclude2(self):
 
   689         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   692         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   690         m2 = matchmod.match(b'', b'', include=[b'path:folder'])
 
   693         m2 = matchmod.match(b'/repo', b'', include=[b'path:folder'])
 
   691         um = matchmod.unionmatcher([m1, m2])
 
   694         um = matchmod.unionmatcher([m1, m2])
 
   692         self.assertEqual(um.visitchildrenset(b''), {b'folder', b'dir'})
 
   695         self.assertEqual(um.visitchildrenset(b''), {b'folder', b'dir'})
 
   693         self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
 
   696         self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
 
   694         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
 
   697         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
 
   695         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
 
   698         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
 
   699         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this')
 
   702         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this')
 
   700 
   703 
   701     # We're using includematcher instead of patterns because it behaves slightly
 
   704     # We're using includematcher instead of patterns because it behaves slightly
 
   702     # better (giving narrower results) than patternmatcher.
 
   705     # better (giving narrower results) than patternmatcher.
 
   703     def testVisitdirIncludeInclude3(self):
 
   706     def testVisitdirIncludeInclude3(self):
 
   704         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
 
   707         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x'])
 
   705         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   708         m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   706         um = matchmod.unionmatcher([m1, m2])
 
   709         um = matchmod.unionmatcher([m1, m2])
 
   707         self.assertEqual(um.visitdir(b''), True)
 
   710         self.assertEqual(um.visitdir(b''), True)
 
   708         self.assertEqual(um.visitdir(b'dir'), True)
 
   711         self.assertEqual(um.visitdir(b'dir'), True)
 
   709         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
 
   712         self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
 
   710         self.assertFalse(um.visitdir(b'dir/foo'))
 
   713         self.assertFalse(um.visitdir(b'dir/foo'))
 
   712         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
 
   715         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
 
   713         # OPT: this should probably be 'all' not True.
 
   716         # OPT: this should probably be 'all' not True.
 
   714         self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
 
   717         self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
 
   715 
   718 
   716     def testVisitchildrensetIncludeInclude3(self):
 
   719     def testVisitchildrensetIncludeInclude3(self):
 
   717         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
 
   720         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x'])
 
   718         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   721         m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   719         um = matchmod.unionmatcher([m1, m2])
 
   722         um = matchmod.unionmatcher([m1, m2])
 
   720         self.assertEqual(um.visitchildrenset(b''), {b'dir'})
 
   723         self.assertEqual(um.visitchildrenset(b''), {b'dir'})
 
   721         self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
 
   724         self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
 
   722         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
 
   725         self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
 
   723         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
 
   726         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
 
   727         self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this')
 
   730         self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this')
 
   728 
   731 
   729     # We're using includematcher instead of patterns because it behaves slightly
 
   732     # We're using includematcher instead of patterns because it behaves slightly
 
   730     # better (giving narrower results) than patternmatcher.
 
   733     # better (giving narrower results) than patternmatcher.
 
   731     def testVisitdirIncludeInclude4(self):
 
   734     def testVisitdirIncludeInclude4(self):
 
   732         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
 
   735         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x'])
 
   733         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])
 
   736         m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/z'])
 
   734         um = matchmod.unionmatcher([m1, m2])
 
   737         um = matchmod.unionmatcher([m1, m2])
 
   735         # OPT: these next three could probably be False as well.
 
   738         # OPT: these next three could probably be False as well.
 
   736         self.assertEqual(um.visitdir(b''), True)
 
   739         self.assertEqual(um.visitdir(b''), True)
 
   737         self.assertEqual(um.visitdir(b'dir'), True)
 
   740         self.assertEqual(um.visitdir(b'dir'), True)
 
   738         self.assertEqual(um.visitdir(b'dir/subdir'), True)
 
   741         self.assertEqual(um.visitdir(b'dir/subdir'), True)
 
   740         self.assertFalse(um.visitdir(b'folder'))
 
   743         self.assertFalse(um.visitdir(b'folder'))
 
   741         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')
 
   744         self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')
 
   742         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
 
   745         self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
 
   743 
   746 
   744     def testVisitchildrensetIncludeInclude4(self):
 
   747     def testVisitchildrensetIncludeInclude4(self):
 
   745         m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
 
   748         m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x'])
 
   746         m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])
 
   749         m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/z'])
 
   747         um = matchmod.unionmatcher([m1, m2])
 
   750         um = matchmod.unionmatcher([m1, m2])
 
   748         self.assertEqual(um.visitchildrenset(b''), {b'dir'})
 
   751         self.assertEqual(um.visitchildrenset(b''), {b'dir'})
 
   749         self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
 
   752         self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
 
   750         self.assertEqual(um.visitchildrenset(b'dir/subdir'), {b'x', b'z'})
 
   753         self.assertEqual(um.visitchildrenset(b'dir/subdir'), {b'x', b'z'})
 
   751         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
 
   754         self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
 
   754         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
 
   757         self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
 
   755 
   758 
   756 
   759 
   757 class SubdirMatcherTests(unittest.TestCase):
 
   760 class SubdirMatcherTests(unittest.TestCase):
 
   758     def testVisitdir(self):
 
   761     def testVisitdir(self):
 
   759         m = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   762         m = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   760         sm = matchmod.subdirmatcher(b'dir', m)
 
   763         sm = matchmod.subdirmatcher(b'dir', m)
 
   761 
   764 
   762         self.assertEqual(sm.visitdir(b''), True)
 
   765         self.assertEqual(sm.visitdir(b''), True)
 
   763         self.assertEqual(sm.visitdir(b'subdir'), b'all')
 
   766         self.assertEqual(sm.visitdir(b'subdir'), b'all')
 
   764         # OPT: These next two should probably be 'all' not True.
 
   767         # OPT: These next two should probably be 'all' not True.
 
   765         self.assertEqual(sm.visitdir(b'subdir/x'), True)
 
   768         self.assertEqual(sm.visitdir(b'subdir/x'), True)
 
   766         self.assertEqual(sm.visitdir(b'subdir/z'), True)
 
   769         self.assertEqual(sm.visitdir(b'subdir/z'), True)
 
   767         self.assertFalse(sm.visitdir(b'foo'))
 
   770         self.assertFalse(sm.visitdir(b'foo'))
 
   768 
   771 
   769     def testVisitchildrenset(self):
 
   772     def testVisitchildrenset(self):
 
   770         m = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
 
   773         m = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir'])
 
   771         sm = matchmod.subdirmatcher(b'dir', m)
 
   774         sm = matchmod.subdirmatcher(b'dir', m)
 
   772 
   775 
   773         self.assertEqual(sm.visitchildrenset(b''), {b'subdir'})
 
   776         self.assertEqual(sm.visitchildrenset(b''), {b'subdir'})
 
   774         self.assertEqual(sm.visitchildrenset(b'subdir'), b'all')
 
   777         self.assertEqual(sm.visitchildrenset(b'subdir'), b'all')
 
   775         # OPT: These next two should probably be 'all' not 'this'.
 
   778         # OPT: These next two should probably be 'all' not 'this'.
 
   779 
   782 
   780 
   783 
   781 class PrefixdirMatcherTests(unittest.TestCase):
 
   784 class PrefixdirMatcherTests(unittest.TestCase):
 
   782     def testVisitdir(self):
 
   785     def testVisitdir(self):
 
   783         m = matchmod.match(
 
   786         m = matchmod.match(
 
   784             util.localpath(b'root/d'), b'e/f', [b'../a.txt', b'b.txt']
 
   787             util.localpath(b'/root/d'),
 
       
   788             b'e/f',
 
       
   789             [b'../a.txt', b'b.txt'],
 
       
   790             auditor=noop_auditor,
 
   785         )
 
   791         )
 
   786         pm = matchmod.prefixdirmatcher(b'd', m)
 
   792         pm = matchmod.prefixdirmatcher(b'd', m)
 
   787 
   793 
   788         # `m` elides 'd' because it's part of the root, and the rest of the
 
   794         # `m` elides 'd' because it's part of the root, and the rest of the
 
   789         # patterns are relative.
 
   795         # patterns are relative.
 
   812         self.assertEqual(pm.visitdir(b'd/e/f'), True)
 
   818         self.assertEqual(pm.visitdir(b'd/e/f'), True)
 
   813         self.assertEqual(pm.visitdir(b'd/e/f/g'), False)
 
   819         self.assertEqual(pm.visitdir(b'd/e/f/g'), False)
 
   814 
   820 
   815     def testVisitchildrenset(self):
 
   821     def testVisitchildrenset(self):
 
   816         m = matchmod.match(
 
   822         m = matchmod.match(
 
   817             util.localpath(b'root/d'), b'e/f', [b'../a.txt', b'b.txt']
 
   823             util.localpath(b'/root/d'),
 
       
   824             b'e/f',
 
       
   825             [b'../a.txt', b'b.txt'],
 
       
   826             auditor=noop_auditor,
 
   818         )
 
   827         )
 
   819         pm = matchmod.prefixdirmatcher(b'd', m)
 
   828         pm = matchmod.prefixdirmatcher(b'd', m)
 
   820 
   829 
   821         # OPT: visitchildrenset could possibly return {'e'} and {'f'} for these
 
   830         # OPT: visitchildrenset could possibly return {'e'} and {'f'} for these
 
   822         # next two, respectively; patternmatcher does not have this
 
   831         # next two, respectively; patternmatcher does not have this
mercurial