9     util,

    11 

    12 class BaseMatcherTests(unittest.TestCase):

    13 

    14     def testVisitdir(self):

    15         m = matchmod.basematcher('', '')

    16         self.assertTrue(m.visitdir('.'))

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

    18 

    19 class AlwaysMatcherTests(unittest.TestCase):

    20 

    21     def testVisitdir(self):

    22         m = matchmod.alwaysmatcher('', '')

    23         self.assertEqual(m.visitdir('.'), 'all')

    24         self.assertEqual(m.visitdir('dir'), 'all')

    33 class PredicateMatcherTests(unittest.TestCase):

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

    35     # this is equivalent to BaseMatcherTests.

    36 

    37     def testVisitdir(self):

    38         m = matchmod.predicatematcher('', '', lambda *a: False)

    39         self.assertTrue(m.visitdir('.'))

    40         self.assertTrue(m.visitdir('dir'))

    41 

    42 class PatternMatcherTests(unittest.TestCase):

    43 

    44     def testVisitdirPrefix(self):

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

    46         assert isinstance(m, matchmod.patternmatcher)

    47         self.assertTrue(m.visitdir('.'))

    48         self.assertTrue(m.visitdir('dir'))

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

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

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

    52         self.assertFalse(m.visitdir('folder'))

    53 

    54     def testVisitdirRootfilesin(self):

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

    56         assert isinstance(m, matchmod.patternmatcher)

    57         self.assertTrue(m.visitdir('.'))

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

    59         self.assertFalse(m.visitdir('folder'))

    60         # FIXME: These should probably be True.

    61         self.assertFalse(m.visitdir('dir'))

    62         self.assertFalse(m.visitdir('dir/subdir'))

    63 

    64     def testVisitdirGlob(self):

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

    66         assert isinstance(m, matchmod.patternmatcher)

    67         self.assertTrue(m.visitdir('.'))

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

    69         self.assertFalse(m.visitdir('folder'))

    70         # OPT: these should probably be False.

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

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

    73 

    74 class IncludeMatcherTests(unittest.TestCase):

    75 

    76     def testVisitdirPrefix(self):

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

    78         assert isinstance(m, matchmod.includematcher)

    79         self.assertTrue(m.visitdir('.'))

    80         self.assertTrue(m.visitdir('dir'))

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

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

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

    84         self.assertFalse(m.visitdir('folder'))

    85 

    86     def testVisitdirRootfilesin(self):

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

    88         assert isinstance(m, matchmod.includematcher)

    89         self.assertTrue(m.visitdir('.'))

    90         self.assertTrue(m.visitdir('dir'))

    91         self.assertTrue(m.visitdir('dir/subdir'))

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

    93         self.assertFalse(m.visitdir('folder'))

    94 

    95     def testVisitdirGlob(self):

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

    97         assert isinstance(m, matchmod.includematcher)

    98         self.assertTrue(m.visitdir('.'))

    99         self.assertTrue(m.visitdir('dir'))

   100         self.assertFalse(m.visitdir('folder'))

   101         # OPT: these should probably be False.

   102         self.assertTrue(m.visitdir('dir/subdir'))

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

   104 

   105 class ExactMatcherTests(unittest.TestCase):

   106 

   107     def testVisitdir(self):

   108         m = matchmod.match('x', '', patterns=['dir/subdir/foo.txt'], exact=True)

   109         assert isinstance(m, matchmod.exactmatcher)

   110         self.assertTrue(m.visitdir('.'))

   111         self.assertTrue(m.visitdir('dir'))

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

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

   114         self.assertFalse(m.visitdir('dir/foo'))

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

   116         self.assertFalse(m.visitdir('folder'))

   117 

   118 class DifferenceMatcherTests(unittest.TestCase):

   119 

   120     def testVisitdirM2always(self):

   121         m1 = matchmod.alwaysmatcher('', '')

   122         m2 = matchmod.alwaysmatcher('', '')

   123         dm = matchmod.differencematcher(m1, m2)

   124         # dm should be equivalent to a nevermatcher.

   125         self.assertFalse(dm.visitdir('.'))

   126         self.assertFalse(dm.visitdir('dir'))

   127         self.assertFalse(dm.visitdir('dir/subdir'))

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

   129         self.assertFalse(dm.visitdir('dir/foo'))

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

   131         self.assertFalse(dm.visitdir('folder'))

   132 

   133     def testVisitdirM2never(self):

   134         m1 = matchmod.alwaysmatcher('', '')

   135         m2 = matchmod.nevermatcher('', '')

   136         dm = matchmod.differencematcher(m1, m2)

   137         # dm should be equivalent to a alwaysmatcher. OPT: if m2 is a

   138         # nevermatcher, we could return 'all' for these.

   139         #

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

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

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

   143         # not currently do so.

   144         self.assertEqual(dm.visitdir('.'), True)

   145         self.assertEqual(dm.visitdir('dir'), True)

   146         self.assertEqual(dm.visitdir('dir/subdir'), True)

   147         self.assertEqual(dm.visitdir('dir/subdir/z'), True)

   148         self.assertEqual(dm.visitdir('dir/foo'), True)

   149         self.assertEqual(dm.visitdir('dir/subdir/x'), True)

   150         self.assertEqual(dm.visitdir('folder'), True)

   151 

   152     def testVisitdirM2SubdirPrefix(self):

   153         m1 = matchmod.alwaysmatcher('', '')

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

   155         dm = matchmod.differencematcher(m1, m2)

   156         self.assertEqual(dm.visitdir('.'), True)

   157         self.assertEqual(dm.visitdir('dir'), True)

   158         self.assertFalse(dm.visitdir('dir/subdir'))

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

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

   161         # an 'all' pattern, just True.

   162         self.assertEqual(dm.visitdir('dir/subdir/z'), True)

   163         self.assertEqual(dm.visitdir('dir/subdir/x'), True)

   164         # OPT: We could return 'all' for these.

   165         self.assertEqual(dm.visitdir('dir/foo'), True)

   166         self.assertEqual(dm.visitdir('folder'), True)

   167 

   168     # We're using includematcher instead of patterns because it behaves slightly

   169     # better (giving narrower results) than patternmatcher.

   170     def testVisitdirIncludeIncludfe(self):

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

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

   173         dm = matchmod.differencematcher(m1, m2)

   174         self.assertEqual(dm.visitdir('.'), True)

   175         self.assertEqual(dm.visitdir('dir'), True)

   176         self.assertEqual(dm.visitdir('dir/subdir'), True)

   177         self.assertFalse(dm.visitdir('dir/foo'))

   178         self.assertFalse(dm.visitdir('folder'))

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

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

   181         # an 'all' pattern, just True.

   182         self.assertEqual(dm.visitdir('dir/subdir/z'), True)

   183         self.assertEqual(dm.visitdir('dir/subdir/x'), True)

   184 

   185 class IntersectionMatcherTests(unittest.TestCase):

   186 

   187     def testVisitdirM2always(self):

   188         m1 = matchmod.alwaysmatcher('', '')

   189         m2 = matchmod.alwaysmatcher('', '')

   190         im = matchmod.intersectmatchers(m1, m2)

   191         # im should be equivalent to a alwaysmatcher.

   192         self.assertEqual(im.visitdir('.'), 'all')

   193         self.assertEqual(im.visitdir('dir'), 'all')

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

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

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

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

   198         self.assertEqual(im.visitdir('folder'), 'all')

   199 

   200     def testVisitdirM2never(self):

   201         m1 = matchmod.alwaysmatcher('', '')

   202         m2 = matchmod.nevermatcher('', '')

   203         im = matchmod.intersectmatchers(m1, m2)

   204         # im should be equivalent to a nevermatcher.

   205         self.assertFalse(im.visitdir('.'))

   206         self.assertFalse(im.visitdir('dir'))

   207         self.assertFalse(im.visitdir('dir/subdir'))

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

   209         self.assertFalse(im.visitdir('dir/foo'))

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

   211         self.assertFalse(im.visitdir('folder'))

   212 

   213     def testVisitdirM2SubdirPrefix(self):

   214         m1 = matchmod.alwaysmatcher('', '')

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

   216         im = matchmod.intersectmatchers(m1, m2)

   217         self.assertEqual(im.visitdir('.'), True)

   218         self.assertEqual(im.visitdir('dir'), True)

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

   220         self.assertFalse(im.visitdir('dir/foo'))

   221         self.assertFalse(im.visitdir('folder'))

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

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

   224         # an 'all' pattern, just True.

   225         self.assertEqual(im.visitdir('dir/subdir/z'), True)

   226         self.assertEqual(im.visitdir('dir/subdir/x'), True)

   227 

   228     # We're using includematcher instead of patterns because it behaves slightly

   229     # better (giving narrower results) than patternmatcher.

   230     def testVisitdirIncludeIncludfe(self):

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

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

   233         im = matchmod.intersectmatchers(m1, m2)

   234         self.assertEqual(im.visitdir('.'), True)

   235         self.assertEqual(im.visitdir('dir'), True)

   236         self.assertFalse(im.visitdir('dir/subdir'))

   237         self.assertFalse(im.visitdir('dir/foo'))

   238         self.assertFalse(im.visitdir('folder'))

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

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

   241 

   242     # We're using includematcher instead of patterns because it behaves slightly

   243     # better (giving narrower results) than patternmatcher.

   244     def testVisitdirIncludeInclude2(self):

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

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

   247         im = matchmod.intersectmatchers(m1, m2)

   248         # FIXME: is True correct here?

   249         self.assertEqual(im.visitdir('.'), True)

   250         self.assertFalse(im.visitdir('dir'))

   251         self.assertFalse(im.visitdir('dir/subdir'))

   252         self.assertFalse(im.visitdir('dir/foo'))

   253         self.assertFalse(im.visitdir('folder'))

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

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

   256 

   257     # We're using includematcher instead of patterns because it behaves slightly

   258     # better (giving narrower results) than patternmatcher.

   259     def testVisitdirIncludeInclude3(self):

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

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

   262         im = matchmod.intersectmatchers(m1, m2)

   263         self.assertEqual(im.visitdir('.'), True)

   264         self.assertEqual(im.visitdir('dir'), True)

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

   266         self.assertFalse(im.visitdir('dir/foo'))

   267         self.assertFalse(im.visitdir('folder'))

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

   269         # OPT: this should probably be 'all' not True.

   270         self.assertEqual(im.visitdir('dir/subdir/x'), True)

   271 

   272     # We're using includematcher instead of patterns because it behaves slightly

   273     # better (giving narrower results) than patternmatcher.

   274     def testVisitdirIncludeInclude4(self):

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

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

   277         im = matchmod.intersectmatchers(m1, m2)

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

   279         self.assertEqual(im.visitdir('.'), True)

   280         self.assertEqual(im.visitdir('dir'), True)

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

   282         self.assertFalse(im.visitdir('dir/foo'))

   283         self.assertFalse(im.visitdir('folder'))

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

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

   286 

   287 class UnionMatcherTests(unittest.TestCase):

   288 

   289     def testVisitdirM2always(self):

   290         m1 = matchmod.alwaysmatcher('', '')

   291         m2 = matchmod.alwaysmatcher('', '')

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

   293         # um should be equivalent to a alwaysmatcher.

   294         self.assertEqual(um.visitdir('.'), 'all')

   295         self.assertEqual(um.visitdir('dir'), 'all')

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

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

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

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

   300         self.assertEqual(um.visitdir('folder'), 'all')

   301 

   302     def testVisitdirM1never(self):

   303         m1 = matchmod.nevermatcher('', '')

   304         m2 = matchmod.alwaysmatcher('', '')

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

   306         # um should be equivalent to a alwaysmatcher.

   307         self.assertEqual(um.visitdir('.'), 'all')

   308         self.assertEqual(um.visitdir('dir'), 'all')

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

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

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

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

   313         self.assertEqual(um.visitdir('folder'), 'all')

   314 

   315     def testVisitdirM2never(self):

   316         m1 = matchmod.alwaysmatcher('', '')

   317         m2 = matchmod.nevermatcher('', '')

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

   319         # um should be equivalent to a alwaysmatcher.

   320         self.assertEqual(um.visitdir('.'), 'all')

   321         self.assertEqual(um.visitdir('dir'), 'all')

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

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

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

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

   326         self.assertEqual(um.visitdir('folder'), 'all')

   327 

   328     def testVisitdirM2SubdirPrefix(self):

   329         m1 = matchmod.alwaysmatcher('', '')

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

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

   332         self.assertEqual(um.visitdir('.'), 'all')

   333         self.assertEqual(um.visitdir('dir'), 'all')

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

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

   336         self.assertEqual(um.visitdir('folder'), 'all')

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

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

   339 

   340     # We're using includematcher instead of patterns because it behaves slightly

   341     # better (giving narrower results) than patternmatcher.

   342     def testVisitdirIncludeIncludfe(self):

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

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

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

   346         self.assertEqual(um.visitdir('.'), True)

   347         self.assertEqual(um.visitdir('dir'), True)

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

   349         self.assertFalse(um.visitdir('dir/foo'))

   350         self.assertFalse(um.visitdir('folder'))

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

   352         self.assertEqual(um.visitdir('dir/subdir/z'), True)

   353         self.assertEqual(um.visitdir('dir/subdir/x'), True)

   354 

   355     # We're using includematcher instead of patterns because it behaves slightly

   356     # better (giving narrower results) than patternmatcher.

   357     def testVisitdirIncludeInclude2(self):

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

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

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

   361         self.assertEqual(um.visitdir('.'), True)

   362         self.assertEqual(um.visitdir('dir'), True)

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

   364         self.assertFalse(um.visitdir('dir/foo'))

   365         self.assertEqual(um.visitdir('folder'), 'all')

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

   367         self.assertEqual(um.visitdir('dir/subdir/z'), True)

   368         self.assertEqual(um.visitdir('dir/subdir/x'), True)

   369 

   370     # We're using includematcher instead of patterns because it behaves slightly

   371     # better (giving narrower results) than patternmatcher.

   372     def testVisitdirIncludeInclude3(self):

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

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

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

   376         self.assertEqual(um.visitdir('.'), True)

   377         self.assertEqual(um.visitdir('dir'), True)

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

   379         self.assertFalse(um.visitdir('dir/foo'))

   380         self.assertFalse(um.visitdir('folder'))

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

   382         # OPT: this should probably be 'all' not True.

   383         self.assertEqual(um.visitdir('dir/subdir/z'), True)

   384 

   385     # We're using includematcher instead of patterns because it behaves slightly

   386     # better (giving narrower results) than patternmatcher.

   387     def testVisitdirIncludeInclude4(self):

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

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

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

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

   392         self.assertEqual(um.visitdir('.'), True)

   393         self.assertEqual(um.visitdir('dir'), True)

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

   395         self.assertFalse(um.visitdir('dir/foo'))

   396         self.assertFalse(um.visitdir('folder'))

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

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

   399 

   400 class SubdirMatcherTests(unittest.TestCase):

   401 

   402     def testVisitdir(self):

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

   404         sm = matchmod.subdirmatcher('dir', m)

   405 

   406         self.assertEqual(sm.visitdir('.'), True)

   407         self.assertEqual(sm.visitdir('subdir'), 'all')

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

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

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

   411         self.assertFalse(sm.visitdir('foo'))

   412 

   413 class PrefixdirMatcherTests(unittest.TestCase):

   414 

   415     def testVisitdir(self):

   416         m = matchmod.match(util.localpath('root/d'), 'e/f',

   417                 ['../a.txt', 'b.txt'])

   418         pm = matchmod.prefixdirmatcher('root', 'd/e/f', 'd', m)

   419 

   420         # `m` elides 'd' because it's part of the root, and the rest of the

   421         # patterns are relative.

   422         self.assertEqual(bool(m('a.txt')), False)

   423         self.assertEqual(bool(m('b.txt')), False)

   424         self.assertEqual(bool(m('e/a.txt')), True)

   425         self.assertEqual(bool(m('e/b.txt')), False)

   426         self.assertEqual(bool(m('e/f/b.txt')), True)

   427 

   428         # The prefix matcher re-adds 'd' to the paths, so they need to be

   429         # specified when using the prefixdirmatcher.

   430         self.assertEqual(bool(pm('a.txt')), False)

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

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

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

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

   435 

   436         self.assertEqual(m.visitdir('.'), True)

   437         self.assertEqual(m.visitdir('e'), True)

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

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

   440 

   441         self.assertEqual(pm.visitdir('.'), True)

   442         self.assertEqual(pm.visitdir('d'), True)

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

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

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

   446