This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7724

tests: convert the `root` arg of matchmod.match() to local path separators
ClosedPublic

Authored by mharbison72 on Dec 26 2019, 7:29 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG8f67735344ae: tests: convert the `root` arg of matchmod.match() to local path separators
Summary

This fixes tests that broke with 8b1a9ba375e5, complaining that "X not under
root /repo". The vast majority of real uses are to pass repo.root, which is
normalized by wdirvfs.base being set to the result of os.path.realpath().

Failure to convert looks like this:

  • c:/Users/Matt/hg/tests/test-match.py.out +++ c:/Users/Matt/hg/tests/test-match.py.err @@ -0,0 +1,48 @@ +ERROR: testVisitchildrensetGlob (main__.IncludeMatcherTests) + +Traceback (most recent call last): + File "c:\Users\Matt\hg\tests\test-match.py", line 180, in testVisitchildrensetGlob + m = matchmod.match(b'/repo', b'', include=[b'glob:dir/z*']) + File "c:\Users\Matt\hg\mercurial\match.py", line 271, in match + kindpats = normalize(include, b'glob', root, cwd, auditor, warn) + File "c:\Users\Matt\hg\mercurial\match.py", line 322, in _donormalize + pat = pathutil.canonpath(root, cwd, pat, auditor=auditor) + File "c:\Users\Matt\hg\mercurial\pathutil.py", line 251, in canonpath + _(b"%s not under root '%s'") % (myname, root), hint=hint +Abort: dir/z* not under root '/repo' +ERROR: testVisitdirGlob (main__.IncludeMatcherTests)

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

mharbison72 created this revision.Dec 26 2019, 7:29 PM
mharbison72 added a commit: rHG8f67735344ae: tests: convert the `root` arg of matchmod.match() to local path separators.Dec 27 2019, 12:49 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG8f67735344ae: tests: convert the `root` arg of matchmod.match() to local path separators (authored by mharbison72). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/match.py (21 lines)
Mtests/test-manifest.py (23 lines)
Mtests/test-match.py (224 lines)

Diff 18945

mercurial/match.py

'relpath:<path>' - a path relative to cwd 'relpath:<path>' - a path relative to cwd
'relre:<regexp>' - a regexp that needn't match the start of a name 'relre:<regexp>' - a regexp that needn't match the start of a name
'set:<fileset>' - a fileset expression 'set:<fileset>' - a fileset expression
'include:<path>' - a file of patterns to read and include 'include:<path>' - a file of patterns to read and include
'subinclude:<path>' - a file of patterns to match against files under 'subinclude:<path>' - a file of patterns to match against files under
the same directory the same directory
'<something>' - a pattern of the specified default type '<something>' - a pattern of the specified default type
>>> def _match(root, *args, **kwargs):
... return match(util.localpath(root), *args, **kwargs)
Usually a patternmatcher is returned: Usually a patternmatcher is returned:
>>> match(b'/foo', b'.', [b're:.*\.c$', b'path:foo/a', b'*.py']) >>> _match(b'/foo', b'.', [b're:.*\.c$', b'path:foo/a', b'*.py'])
<patternmatcher patterns='.*\\.c$|foo/a(?:/|$)|[^/]*\\.py$'> <patternmatcher patterns='.*\\.c$|foo/a(?:/|$)|[^/]*\\.py$'>
Combining 'patterns' with 'include' (resp. 'exclude') gives an Combining 'patterns' with 'include' (resp. 'exclude') gives an
intersectionmatcher (resp. a differencematcher): intersectionmatcher (resp. a differencematcher):
>>> type(match(b'/foo', b'.', [b're:.*\.c$'], include=[b'path:lib'])) >>> type(_match(b'/foo', b'.', [b're:.*\.c$'], include=[b'path:lib']))
<class 'mercurial.match.intersectionmatcher'> <class 'mercurial.match.intersectionmatcher'>
>>> type(match(b'/foo', b'.', [b're:.*\.c$'], exclude=[b'path:build'])) >>> type(_match(b'/foo', b'.', [b're:.*\.c$'], exclude=[b'path:build']))
<class 'mercurial.match.differencematcher'> <class 'mercurial.match.differencematcher'>
Notice that, if 'patterns' is empty, an alwaysmatcher is returned: Notice that, if 'patterns' is empty, an alwaysmatcher is returned:
>>> match(b'/foo', b'.', []) >>> _match(b'/foo', b'.', [])
<alwaysmatcher> <alwaysmatcher>
The 'default' argument determines which kind of pattern is assumed if a The 'default' argument determines which kind of pattern is assumed if a
pattern has no prefix: pattern has no prefix:
>>> match(b'/foo', b'.', [b'.*\.c$'], default=b're') >>> _match(b'/foo', b'.', [b'.*\.c$'], default=b're')
<patternmatcher patterns='.*\\.c$'> <patternmatcher patterns='.*\\.c$'>
>>> match(b'/foo', b'.', [b'main.py'], default=b'relpath') >>> _match(b'/foo', b'.', [b'main.py'], default=b'relpath')
<patternmatcher patterns='main\\.py(?:/|$)'> <patternmatcher patterns='main\\.py(?:/|$)'>
>>> match(b'/foo', b'.', [b'main.py'], default=b're') >>> _match(b'/foo', b'.', [b'main.py'], default=b're')
<patternmatcher patterns='main.py'> <patternmatcher patterns='main.py'>
The primary use of matchers is to check whether a value (usually a file The primary use of matchers is to check whether a value (usually a file
name) matches againset one of the patterns given at initialization. There name) matches againset one of the patterns given at initialization. There
are two ways of doing this check. are two ways of doing this check.
>>> m = match(b'/foo', b'', [b're:.*\.c$', b'relpath:a']) >>> m = _match(b'/foo', b'', [b're:.*\.c$', b'relpath:a'])
1. Calling the matcher with a file name returns True if any pattern 1. Calling the matcher with a file name returns True if any pattern
matches that file name: matches that file name:
>>> m(b'a') >>> m(b'a')
True True
>>> m(b'main.c') >>> m(b'main.c')
True True
>>> m(b'test.py') >>> m(b'test.py')
class subdirmatcher(basematcher): class subdirmatcher(basematcher):
"""Adapt a matcher to work on a subdirectory only. """Adapt a matcher to work on a subdirectory only.
The paths are remapped to remove/insert the path as needed: The paths are remapped to remove/insert the path as needed:
>>> from . import pycompat >>> from . import pycompat
>>> m1 = match(b'/root', b'', [b'a.txt', b'sub/b.txt']) >>> m1 = match(util.localpath(b'/root'), b'', [b'a.txt', b'sub/b.txt'])
>>> m2 = subdirmatcher(b'sub', m1) >>> m2 = subdirmatcher(b'sub', m1)
>>> m2(b'a.txt') >>> m2(b'a.txt')
False False
>>> m2(b'b.txt') >>> m2(b'b.txt')
True True
>>> m2.matchfn(b'a.txt') >>> m2.matchfn(b'a.txt')
False False
>>> m2.matchfn(b'b.txt') >>> m2.matchfn(b'b.txt')

tests/test-manifest.py

from __future__ import absolute_import from __future__ import absolute_import
import binascii import binascii
import itertools import itertools
import silenttestrunner import silenttestrunner
import unittest import unittest
import zlib import zlib
from mercurial import ( from mercurial import (
manifest as manifestmod, manifest as manifestmod,
match as matchmod, match as matchmod,
util,
) )
EMTPY_MANIFEST = b'' EMTPY_MANIFEST = b''
HASH_1 = b'1' * 40 HASH_1 = b'1' * 40
BIN_HASH_1 = binascii.unhexlify(HASH_1) BIN_HASH_1 = binascii.unhexlify(HASH_1)
HASH_2 = b'f' * 40 HASH_2 = b'f' * 40
BIN_HASH_2 = binascii.unhexlify(HASH_2) BIN_HASH_2 = binascii.unhexlify(HASH_2)
[(b'bar/baz/qux.py', BIN_HASH_2), (b'foo', BIN_HASH_1 + b'a')], [(b'bar/baz/qux.py', BIN_HASH_2), (b'foo', BIN_HASH_1 + b'a')],
list(m.items()), list(m.items()),
) )
# Sometimes it even tries a 22-byte fake hash, but we can # Sometimes it even tries a 22-byte fake hash, but we can
# return 21 and it'll work out # return 21 and it'll work out
m[b'foo'] = want + b'+' m[b'foo'] = want + b'+'
self.assertEqual(want, m[b'foo']) self.assertEqual(want, m[b'foo'])
# make sure the suffix survives a copy # make sure the suffix survives a copy
match = matchmod.match(b'/repo', b'', [b're:foo']) match = matchmod.match(util.localpath(b'/repo'), b'', [b're:foo'])
m2 = m.matches(match) m2 = m.matches(match)
self.assertEqual(want, m2[b'foo']) self.assertEqual(want, m2[b'foo'])
self.assertEqual(1, len(m2)) self.assertEqual(1, len(m2))
m2 = m.copy() m2 = m.copy()
self.assertEqual(want, m2[b'foo']) self.assertEqual(want, m2[b'foo'])
# suffix with iteration # suffix with iteration
self.assertEqual( self.assertEqual(
[(b'bar/baz/qux.py', BIN_HASH_2), (b'foo', want)], list(m.items()) [(b'bar/baz/qux.py', BIN_HASH_2), (b'foo', want)], list(m.items())
) )
# shows up in diff # shows up in diff
self.assertEqual({b'foo': ((want, f), (h, b''))}, m.diff(clean)) self.assertEqual({b'foo': ((want, f), (h, b''))}, m.diff(clean))
self.assertEqual({b'foo': ((h, b''), (want, f))}, clean.diff(m)) self.assertEqual({b'foo': ((h, b''), (want, f))}, clean.diff(m))
def testMatchException(self): def testMatchException(self):
m = self.parsemanifest(A_SHORT_MANIFEST) m = self.parsemanifest(A_SHORT_MANIFEST)
match = matchmod.match(b'/repo', b'', [b're:.*']) match = matchmod.match(util.localpath(b'/repo'), b'', [b're:.*'])
def filt(path): def filt(path):
if path == b'foo': if path == b'foo':
assert False assert False
return True return True
match.matchfn = filt match.matchfn = filt
with self.assertRaises(AssertionError): with self.assertRaises(AssertionError):
[b'a/b/c/bar.txt', b'a/b/d/qux.py', b'readme.txt'], m2.keys() [b'a/b/c/bar.txt', b'a/b/d/qux.py', b'readme.txt'], m2.keys()
) )
def testMatchesNonexistentDirectory(self): def testMatchesNonexistentDirectory(self):
'''Tests matches() for a relpath match on a directory that doesn't '''Tests matches() for a relpath match on a directory that doesn't
actually exist.''' actually exist.'''
m = self.parsemanifest(A_DEEPER_MANIFEST) m = self.parsemanifest(A_DEEPER_MANIFEST)
match = matchmod.match(b'/repo', b'', [b'a/f'], default=b'relpath') match = matchmod.match(
util.localpath(b'/repo'), b'', [b'a/f'], default=b'relpath'
)
m2 = m.matches(match) m2 = m.matches(match)
self.assertEqual([], m2.keys()) self.assertEqual([], m2.keys())
def testMatchesExactLarge(self): def testMatchesExactLarge(self):
'''Tests matches() for files matching a large list of exact files. '''Tests matches() for files matching a large list of exact files.
''' '''
m = self.parsemanifest(A_HUGE_MANIFEST) m = self.parsemanifest(A_HUGE_MANIFEST)
flist = m.keys()[80:300] flist = m.keys()[80:300]
match = matchmod.exact(flist) match = matchmod.exact(flist)
m2 = m.matches(match) m2 = m.matches(match)
self.assertEqual(flist, m2.keys()) self.assertEqual(flist, m2.keys())
def testMatchesFull(self): def testMatchesFull(self):
'''Tests matches() for what should be a full match.''' '''Tests matches() for what should be a full match.'''
m = self.parsemanifest(A_DEEPER_MANIFEST) m = self.parsemanifest(A_DEEPER_MANIFEST)
match = matchmod.match(b'/repo', b'', [b'']) match = matchmod.match(util.localpath(b'/repo'), b'', [b''])
m2 = m.matches(match) m2 = m.matches(match)
self.assertEqual(m.keys(), m2.keys()) self.assertEqual(m.keys(), m2.keys())
def testMatchesDirectory(self): def testMatchesDirectory(self):
'''Tests matches() on a relpath match on a directory, which should '''Tests matches() on a relpath match on a directory, which should
match against all files within said directory.''' match against all files within said directory.'''
m = self.parsemanifest(A_DEEPER_MANIFEST) m = self.parsemanifest(A_DEEPER_MANIFEST)
match = matchmod.match(b'/repo', b'', [b'a/b'], default=b'relpath') match = matchmod.match(
util.localpath(b'/repo'), b'', [b'a/b'], default=b'relpath'
)
m2 = m.matches(match) m2 = m.matches(match)
self.assertEqual( self.assertEqual(
[ [
b'a/b/c/bar.py', b'a/b/c/bar.py',
b'a/b/c/bar.txt', b'a/b/c/bar.txt',
b'a/b/c/foo.py', b'a/b/c/foo.py',
b'a/b/c/foo.txt', b'a/b/c/foo.txt',
self.assertEqual([], m2.keys()) self.assertEqual([], m2.keys())
def testMatchesCwd(self): def testMatchesCwd(self):
'''Tests matches() on a relpath match with the current directory ('.') '''Tests matches() on a relpath match with the current directory ('.')
when not in the root directory.''' when not in the root directory.'''
m = self.parsemanifest(A_DEEPER_MANIFEST) m = self.parsemanifest(A_DEEPER_MANIFEST)
match = matchmod.match(b'/repo', b'a/b', [b'.'], default=b'relpath') match = matchmod.match(
util.localpath(b'/repo'), b'a/b', [b'.'], default=b'relpath'
)
m2 = m.matches(match) m2 = m.matches(match)
self.assertEqual( self.assertEqual(
[ [
b'a/b/c/bar.py', b'a/b/c/bar.py',
b'a/b/c/bar.txt', b'a/b/c/bar.txt',
b'a/b/c/foo.py', b'a/b/c/foo.py',
b'a/b/c/foo.txt', b'a/b/c/foo.txt',
b'a/b/d/baz.py', b'a/b/d/baz.py',
b'a/b/d/qux.py', b'a/b/d/qux.py',
b'a/b/d/ten.txt', b'a/b/d/ten.txt',
b'a/b/dog.py', b'a/b/dog.py',
b'a/b/fish.py', b'a/b/fish.py',
], ],
m2.keys(), m2.keys(),
) )
def testMatchesWithPattern(self): def testMatchesWithPattern(self):
'''Tests matches() for files matching a pattern that reside '''Tests matches() for files matching a pattern that reside
deeper than the specified directory.''' deeper than the specified directory.'''
m = self.parsemanifest(A_DEEPER_MANIFEST) m = self.parsemanifest(A_DEEPER_MANIFEST)
match = matchmod.match(b'/repo', b'', [b'a/b/*/*.txt']) match = matchmod.match(util.localpath(b'/repo'), b'', [b'a/b/*/*.txt'])
m2 = m.matches(match) m2 = m.matches(match)
self.assertEqual( self.assertEqual(
[b'a/b/c/bar.txt', b'a/b/c/foo.txt', b'a/b/d/ten.txt'], m2.keys() [b'a/b/c/bar.txt', b'a/b/c/foo.txt', b'a/b/d/ten.txt'], m2.keys()
) )
class testmanifestdict(unittest.TestCase, basemanifesttests): class testmanifestdict(unittest.TestCase, basemanifesttests):
dirs = [s._dir for s in m.walksubtrees()] dirs = [s._dir for s in m.walksubtrees()]
self.assertEqual( self.assertEqual(
sorted( sorted(
[b'', b'a/', b'a/c/', b'a/d/', b'a/b/', b'a/b/c/', b'a/b/d/'] [b'', b'a/', b'a/c/', b'a/d/', b'a/b/', b'a/b/c/', b'a/b/d/']
), ),
sorted(dirs), sorted(dirs),
) )
match = matchmod.match(b'/repo', b'', [b'path:a/b/']) match = matchmod.match(util.localpath(b'/repo'), b'', [b'path:a/b/'])
dirs = [s._dir for s in m.walksubtrees(matcher=match)] dirs = [s._dir for s in m.walksubtrees(matcher=match)]
self.assertEqual(sorted([b'a/b/', b'a/b/c/', b'a/b/d/']), sorted(dirs)) self.assertEqual(sorted([b'a/b/', b'a/b/c/', b'a/b/d/']), sorted(dirs))
if __name__ == '__main__': if __name__ == '__main__':
silenttestrunner.main(__name__) silenttestrunner.main(__name__)

tests/test-match.py

def testVisitchildrenset(self): def testVisitchildrenset(self):
m = matchmod.predicatematcher(lambda *a: False) m = matchmod.predicatematcher(lambda *a: False)
self.assertEqual(m.visitchildrenset(b''), b'this') self.assertEqual(m.visitchildrenset(b''), b'this')
self.assertEqual(m.visitchildrenset(b'dir'), b'this') self.assertEqual(m.visitchildrenset(b'dir'), b'this')
class PatternMatcherTests(unittest.TestCase): class PatternMatcherTests(unittest.TestCase):
def testVisitdirPrefix(self): def testVisitdirPrefix(self):
m = matchmod.match(b'/repo', b'', patterns=[b'path:dir/subdir']) m = matchmod.match(
util.localpath(b'/repo'), b'', patterns=[b'path:dir/subdir']
)
assert isinstance(m, matchmod.patternmatcher) assert isinstance(m, matchmod.patternmatcher)
self.assertTrue(m.visitdir(b'')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
self.assertEqual(m.visitdir(b'dir/subdir'), b'all') self.assertEqual(m.visitdir(b'dir/subdir'), b'all')
# OPT: This should probably be 'all' if its parent is? # OPT: This should probably be 'all' if its parent is?
self.assertTrue(m.visitdir(b'dir/subdir/x')) self.assertTrue(m.visitdir(b'dir/subdir/x'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
def testVisitchildrensetPrefix(self): def testVisitchildrensetPrefix(self):
m = matchmod.match(b'/repo', b'', patterns=[b'path:dir/subdir']) m = matchmod.match(
util.localpath(b'/repo'), b'', patterns=[b'path:dir/subdir']
)
assert isinstance(m, matchmod.patternmatcher) assert isinstance(m, matchmod.patternmatcher)
self.assertEqual(m.visitchildrenset(b''), b'this') self.assertEqual(m.visitchildrenset(b''), b'this')
self.assertEqual(m.visitchildrenset(b'dir'), b'this') self.assertEqual(m.visitchildrenset(b'dir'), b'this')
self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')
# OPT: This should probably be 'all' if its parent is? # OPT: This should probably be 'all' if its parent is?
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
def testVisitdirRootfilesin(self): def testVisitdirRootfilesin(self):
m = matchmod.match(b'/repo', b'', patterns=[b'rootfilesin:dir/subdir']) m = matchmod.match(
util.localpath(b'/repo'), b'', patterns=[b'rootfilesin:dir/subdir'],
)
assert isinstance(m, matchmod.patternmatcher) assert isinstance(m, matchmod.patternmatcher)
self.assertFalse(m.visitdir(b'dir/subdir/x')) self.assertFalse(m.visitdir(b'dir/subdir/x'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
# FIXME: These should probably be True. # FIXME: These should probably be True.
self.assertFalse(m.visitdir(b'')) self.assertFalse(m.visitdir(b''))
self.assertFalse(m.visitdir(b'dir')) self.assertFalse(m.visitdir(b'dir'))
self.assertFalse(m.visitdir(b'dir/subdir')) self.assertFalse(m.visitdir(b'dir/subdir'))
def testVisitchildrensetRootfilesin(self): def testVisitchildrensetRootfilesin(self):
m = matchmod.match(b'/repo', b'', patterns=[b'rootfilesin:dir/subdir']) m = matchmod.match(
util.localpath(b'/repo'), b'', patterns=[b'rootfilesin:dir/subdir'],
)
assert isinstance(m, matchmod.patternmatcher) assert isinstance(m, matchmod.patternmatcher)
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
# FIXME: These should probably be {'dir'}, {'subdir'} and 'this', # FIXME: These should probably be {'dir'}, {'subdir'} and 'this',
# respectively, or at least 'this' for all three. # respectively, or at least 'this' for all three.
self.assertEqual(m.visitchildrenset(b''), set()) self.assertEqual(m.visitchildrenset(b''), set())
self.assertEqual(m.visitchildrenset(b'dir'), set()) self.assertEqual(m.visitchildrenset(b'dir'), set())
self.assertEqual(m.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(m.visitchildrenset(b'dir/subdir'), set())
def testVisitdirGlob(self): def testVisitdirGlob(self):
m = matchmod.match(b'/repo', b'', patterns=[b'glob:dir/z*']) m = matchmod.match(
util.localpath(b'/repo'), b'', patterns=[b'glob:dir/z*']
)
assert isinstance(m, matchmod.patternmatcher) assert isinstance(m, matchmod.patternmatcher)
self.assertTrue(m.visitdir(b'')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
# OPT: these should probably be False. # OPT: these should probably be False.
self.assertTrue(m.visitdir(b'dir/subdir')) self.assertTrue(m.visitdir(b'dir/subdir'))
self.assertTrue(m.visitdir(b'dir/subdir/x')) self.assertTrue(m.visitdir(b'dir/subdir/x'))
def testVisitchildrensetGlob(self): def testVisitchildrensetGlob(self):
m = matchmod.match(b'/repo', b'', patterns=[b'glob:dir/z*']) m = matchmod.match(
util.localpath(b'/repo'), b'', patterns=[b'glob:dir/z*']
)
assert isinstance(m, matchmod.patternmatcher) assert isinstance(m, matchmod.patternmatcher)
self.assertEqual(m.visitchildrenset(b''), b'this') self.assertEqual(m.visitchildrenset(b''), b'this')
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
self.assertEqual(m.visitchildrenset(b'dir'), b'this') self.assertEqual(m.visitchildrenset(b'dir'), b'this')
# OPT: these should probably be set(). # OPT: these should probably be set().
self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
class IncludeMatcherTests(unittest.TestCase): class IncludeMatcherTests(unittest.TestCase):
def testVisitdirPrefix(self): def testVisitdirPrefix(self):
m = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
assert isinstance(m, matchmod.includematcher) assert isinstance(m, matchmod.includematcher)
self.assertTrue(m.visitdir(b'')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
self.assertEqual(m.visitdir(b'dir/subdir'), b'all') self.assertEqual(m.visitdir(b'dir/subdir'), b'all')
# OPT: This should probably be 'all' if its parent is? # OPT: This should probably be 'all' if its parent is?
self.assertTrue(m.visitdir(b'dir/subdir/x')) self.assertTrue(m.visitdir(b'dir/subdir/x'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
def testVisitchildrensetPrefix(self): def testVisitchildrensetPrefix(self):
m = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
assert isinstance(m, matchmod.includematcher) assert isinstance(m, matchmod.includematcher)
self.assertEqual(m.visitchildrenset(b''), {b'dir'}) self.assertEqual(m.visitchildrenset(b''), {b'dir'})
self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')
# OPT: This should probably be 'all' if its parent is? # OPT: This should probably be 'all' if its parent is?
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
def testVisitdirRootfilesin(self): def testVisitdirRootfilesin(self):
m = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir/subdir']) m = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'rootfilesin:dir/subdir']
)
assert isinstance(m, matchmod.includematcher) assert isinstance(m, matchmod.includematcher)
self.assertTrue(m.visitdir(b'')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
self.assertTrue(m.visitdir(b'dir/subdir')) self.assertTrue(m.visitdir(b'dir/subdir'))
self.assertFalse(m.visitdir(b'dir/subdir/x')) self.assertFalse(m.visitdir(b'dir/subdir/x'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
def testVisitchildrensetRootfilesin(self): def testVisitchildrensetRootfilesin(self):
m = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir/subdir']) m = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'rootfilesin:dir/subdir']
)
assert isinstance(m, matchmod.includematcher) assert isinstance(m, matchmod.includematcher)
self.assertEqual(m.visitchildrenset(b''), {b'dir'}) self.assertEqual(m.visitchildrenset(b''), {b'dir'})
self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
def testVisitdirGlob(self): def testVisitdirGlob(self):
m = matchmod.match(b'/repo', b'', include=[b'glob:dir/z*']) m = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'glob:dir/z*']
)
assert isinstance(m, matchmod.includematcher) assert isinstance(m, matchmod.includematcher)
self.assertTrue(m.visitdir(b'')) self.assertTrue(m.visitdir(b''))
self.assertTrue(m.visitdir(b'dir')) self.assertTrue(m.visitdir(b'dir'))
self.assertFalse(m.visitdir(b'folder')) self.assertFalse(m.visitdir(b'folder'))
# OPT: these should probably be False. # OPT: these should probably be False.
self.assertTrue(m.visitdir(b'dir/subdir')) self.assertTrue(m.visitdir(b'dir/subdir'))
self.assertTrue(m.visitdir(b'dir/subdir/x')) self.assertTrue(m.visitdir(b'dir/subdir/x'))
def testVisitchildrensetGlob(self): def testVisitchildrensetGlob(self):
m = matchmod.match(b'/repo', b'', include=[b'glob:dir/z*']) m = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'glob:dir/z*']
)
assert isinstance(m, matchmod.includematcher) assert isinstance(m, matchmod.includematcher)
self.assertEqual(m.visitchildrenset(b''), {b'dir'}) self.assertEqual(m.visitchildrenset(b''), {b'dir'})
self.assertEqual(m.visitchildrenset(b'folder'), set()) self.assertEqual(m.visitchildrenset(b'folder'), set())
self.assertEqual(m.visitchildrenset(b'dir'), b'this') self.assertEqual(m.visitchildrenset(b'dir'), b'this')
# OPT: these should probably be set(). # OPT: these should probably be set().
self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')
self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'all') self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'all')
self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all') self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all')
self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'all')
self.assertEqual(dm.visitchildrenset(b'folder'), b'all') self.assertEqual(dm.visitchildrenset(b'folder'), b'all')
def testVisitdirM2SubdirPrefix(self): def testVisitdirM2SubdirPrefix(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.match(b'/repo', b'', patterns=[b'path:dir/subdir']) m2 = matchmod.match(
util.localpath(b'/repo'), b'', patterns=[b'path:dir/subdir']
)
dm = matchmod.differencematcher(m1, m2) dm = matchmod.differencematcher(m1, m2)
self.assertEqual(dm.visitdir(b''), True) self.assertEqual(dm.visitdir(b''), True)
self.assertEqual(dm.visitdir(b'dir'), True) self.assertEqual(dm.visitdir(b'dir'), True)
self.assertFalse(dm.visitdir(b'dir/subdir')) self.assertFalse(dm.visitdir(b'dir/subdir'))
# OPT: We should probably return False for these; we don't because # OPT: We should probably return False for these; we don't because
# patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
# an 'all' pattern, just True. # an 'all' pattern, just True.
self.assertEqual(dm.visitdir(b'dir/subdir/z'), True) self.assertEqual(dm.visitdir(b'dir/subdir/z'), True)
self.assertEqual(dm.visitdir(b'dir/subdir/x'), True) self.assertEqual(dm.visitdir(b'dir/subdir/x'), True)
self.assertEqual(dm.visitdir(b'dir/foo'), b'all') self.assertEqual(dm.visitdir(b'dir/foo'), b'all')
self.assertEqual(dm.visitdir(b'folder'), b'all') self.assertEqual(dm.visitdir(b'folder'), b'all')
def testVisitchildrensetM2SubdirPrefix(self): def testVisitchildrensetM2SubdirPrefix(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.match(b'/repo', b'', patterns=[b'path:dir/subdir']) m2 = matchmod.match(
util.localpath(b'/repo'), b'', patterns=[b'path:dir/subdir']
)
dm = matchmod.differencematcher(m1, m2) dm = matchmod.differencematcher(m1, m2)
self.assertEqual(dm.visitchildrenset(b''), b'this') self.assertEqual(dm.visitchildrenset(b''), b'this')
self.assertEqual(dm.visitchildrenset(b'dir'), b'this') self.assertEqual(dm.visitchildrenset(b'dir'), b'this')
self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set())
self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all') self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all')
self.assertEqual(dm.visitchildrenset(b'folder'), b'all') self.assertEqual(dm.visitchildrenset(b'folder'), b'all')
# OPT: We should probably return set() for these; we don't because # OPT: We should probably return set() for these; we don't because
# patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
# an 'all' pattern, just 'this'. # an 'all' pattern, just 'this'.
self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'this') self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'this')
self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'this')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude(self): def testVisitdirIncludeInclude(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'rootfilesin:dir']
)
dm = matchmod.differencematcher(m1, m2) dm = matchmod.differencematcher(m1, m2)
self.assertEqual(dm.visitdir(b''), True) self.assertEqual(dm.visitdir(b''), True)
self.assertEqual(dm.visitdir(b'dir'), True) self.assertEqual(dm.visitdir(b'dir'), True)
self.assertEqual(dm.visitdir(b'dir/subdir'), b'all') self.assertEqual(dm.visitdir(b'dir/subdir'), b'all')
self.assertFalse(dm.visitdir(b'dir/foo')) self.assertFalse(dm.visitdir(b'dir/foo'))
self.assertFalse(dm.visitdir(b'folder')) self.assertFalse(dm.visitdir(b'folder'))
# OPT: We should probably return False for these; we don't because # OPT: We should probably return False for these; we don't because
# patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
# an 'all' pattern, just True. # an 'all' pattern, just True.
self.assertEqual(dm.visitdir(b'dir/subdir/z'), True) self.assertEqual(dm.visitdir(b'dir/subdir/z'), True)
self.assertEqual(dm.visitdir(b'dir/subdir/x'), True) self.assertEqual(dm.visitdir(b'dir/subdir/x'), True)
def testVisitchildrensetIncludeInclude(self): def testVisitchildrensetIncludeInclude(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'rootfilesin:dir']
)
dm = matchmod.differencematcher(m1, m2) dm = matchmod.differencematcher(m1, m2)
self.assertEqual(dm.visitchildrenset(b''), {b'dir'}) self.assertEqual(dm.visitchildrenset(b''), {b'dir'})
self.assertEqual(dm.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(dm.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(dm.visitchildrenset(b'dir/foo'), set()) self.assertEqual(dm.visitchildrenset(b'dir/foo'), set())
self.assertEqual(dm.visitchildrenset(b'folder'), set()) self.assertEqual(dm.visitchildrenset(b'folder'), set())
# OPT: We should probably return set() for these; we don't because # OPT: We should probably return set() for these; we don't because
# patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
self.assertEqual(im.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
self.assertEqual(im.visitchildrenset(b'folder'), set()) self.assertEqual(im.visitchildrenset(b'folder'), set())
def testVisitdirM2SubdirPrefix(self): def testVisitdirM2SubdirPrefix(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.match(b'/repo', b'', patterns=[b'path:dir/subdir']) m2 = matchmod.match(
util.localpath(b'/repo'), b'', patterns=[b'path:dir/subdir']
)
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
self.assertEqual(im.visitdir(b''), True) self.assertEqual(im.visitdir(b''), True)
self.assertEqual(im.visitdir(b'dir'), True) self.assertEqual(im.visitdir(b'dir'), True)
self.assertEqual(im.visitdir(b'dir/subdir'), b'all') self.assertEqual(im.visitdir(b'dir/subdir'), b'all')
self.assertFalse(im.visitdir(b'dir/foo')) self.assertFalse(im.visitdir(b'dir/foo'))
self.assertFalse(im.visitdir(b'folder')) self.assertFalse(im.visitdir(b'folder'))
# OPT: We should probably return 'all' for these; we don't because # OPT: We should probably return 'all' for these; we don't because
# patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
# an 'all' pattern, just True. # an 'all' pattern, just True.
self.assertEqual(im.visitdir(b'dir/subdir/z'), True) self.assertEqual(im.visitdir(b'dir/subdir/z'), True)
self.assertEqual(im.visitdir(b'dir/subdir/x'), True) self.assertEqual(im.visitdir(b'dir/subdir/x'), True)
def testVisitchildrensetM2SubdirPrefix(self): def testVisitchildrensetM2SubdirPrefix(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
self.assertEqual(im.visitchildrenset(b''), {b'dir'}) self.assertEqual(im.visitchildrenset(b''), {b'dir'})
self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
self.assertEqual(im.visitchildrenset(b'folder'), set()) self.assertEqual(im.visitchildrenset(b'folder'), set())
# OPT: We should probably return 'all' for these # OPT: We should probably return 'all' for these
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), b'this') self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), b'this')
self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude(self): def testVisitdirIncludeInclude(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'rootfilesin:dir']
)
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
self.assertEqual(im.visitdir(b''), True) self.assertEqual(im.visitdir(b''), True)
self.assertEqual(im.visitdir(b'dir'), True) self.assertEqual(im.visitdir(b'dir'), True)
self.assertFalse(im.visitdir(b'dir/subdir')) self.assertFalse(im.visitdir(b'dir/subdir'))
self.assertFalse(im.visitdir(b'dir/foo')) self.assertFalse(im.visitdir(b'dir/foo'))
self.assertFalse(im.visitdir(b'folder')) self.assertFalse(im.visitdir(b'folder'))
self.assertFalse(im.visitdir(b'dir/subdir/z')) self.assertFalse(im.visitdir(b'dir/subdir/z'))
self.assertFalse(im.visitdir(b'dir/subdir/x')) self.assertFalse(im.visitdir(b'dir/subdir/x'))
def testVisitchildrensetIncludeInclude(self): def testVisitchildrensetIncludeInclude(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'rootfilesin:dir']
)
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
self.assertEqual(im.visitchildrenset(b''), {b'dir'}) self.assertEqual(im.visitchildrenset(b''), {b'dir'})
self.assertEqual(im.visitchildrenset(b'dir'), b'this') self.assertEqual(im.visitchildrenset(b'dir'), b'this')
self.assertEqual(im.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
self.assertEqual(im.visitchildrenset(b'folder'), set()) self.assertEqual(im.visitchildrenset(b'folder'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude2(self): def testVisitdirIncludeInclude2(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'path:folder']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:folder']
)
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
# FIXME: is True correct here? # FIXME: is True correct here?
self.assertEqual(im.visitdir(b''), True) self.assertEqual(im.visitdir(b''), True)
self.assertFalse(im.visitdir(b'dir')) self.assertFalse(im.visitdir(b'dir'))
self.assertFalse(im.visitdir(b'dir/subdir')) self.assertFalse(im.visitdir(b'dir/subdir'))
self.assertFalse(im.visitdir(b'dir/foo')) self.assertFalse(im.visitdir(b'dir/foo'))
self.assertFalse(im.visitdir(b'folder')) self.assertFalse(im.visitdir(b'folder'))
self.assertFalse(im.visitdir(b'dir/subdir/z')) self.assertFalse(im.visitdir(b'dir/subdir/z'))
self.assertFalse(im.visitdir(b'dir/subdir/x')) self.assertFalse(im.visitdir(b'dir/subdir/x'))
def testVisitchildrensetIncludeInclude2(self): def testVisitchildrensetIncludeInclude2(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'path:folder']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:folder']
)
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
# FIXME: is set() correct here? # FIXME: is set() correct here?
self.assertEqual(im.visitchildrenset(b''), set()) self.assertEqual(im.visitchildrenset(b''), set())
self.assertEqual(im.visitchildrenset(b'dir'), set()) self.assertEqual(im.visitchildrenset(b'dir'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
self.assertEqual(im.visitchildrenset(b'folder'), set()) self.assertEqual(im.visitchildrenset(b'folder'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude3(self): def testVisitdirIncludeInclude3(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir/x']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
self.assertEqual(im.visitdir(b''), True) self.assertEqual(im.visitdir(b''), True)
self.assertEqual(im.visitdir(b'dir'), True) self.assertEqual(im.visitdir(b'dir'), True)
self.assertEqual(im.visitdir(b'dir/subdir'), True) self.assertEqual(im.visitdir(b'dir/subdir'), True)
self.assertFalse(im.visitdir(b'dir/foo')) self.assertFalse(im.visitdir(b'dir/foo'))
self.assertFalse(im.visitdir(b'folder')) self.assertFalse(im.visitdir(b'folder'))
self.assertFalse(im.visitdir(b'dir/subdir/z')) self.assertFalse(im.visitdir(b'dir/subdir/z'))
# OPT: this should probably be 'all' not True. # OPT: this should probably be 'all' not True.
self.assertEqual(im.visitdir(b'dir/subdir/x'), True) self.assertEqual(im.visitdir(b'dir/subdir/x'), True)
def testVisitchildrensetIncludeInclude3(self): def testVisitchildrensetIncludeInclude3(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir/x']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
self.assertEqual(im.visitchildrenset(b''), {b'dir'}) self.assertEqual(im.visitchildrenset(b''), {b'dir'})
self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(im.visitchildrenset(b'dir/subdir'), {b'x'}) self.assertEqual(im.visitchildrenset(b'dir/subdir'), {b'x'})
self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
self.assertEqual(im.visitchildrenset(b'folder'), set()) self.assertEqual(im.visitchildrenset(b'folder'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
# OPT: this should probably be 'all' not 'this'. # OPT: this should probably be 'all' not 'this'.
self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude4(self): def testVisitdirIncludeInclude4(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/z']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir/x']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir/z']
)
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
# OPT: these next three could probably be False as well. # OPT: these next three could probably be False as well.
self.assertEqual(im.visitdir(b''), True) self.assertEqual(im.visitdir(b''), True)
self.assertEqual(im.visitdir(b'dir'), True) self.assertEqual(im.visitdir(b'dir'), True)
self.assertEqual(im.visitdir(b'dir/subdir'), True) self.assertEqual(im.visitdir(b'dir/subdir'), True)
self.assertFalse(im.visitdir(b'dir/foo')) self.assertFalse(im.visitdir(b'dir/foo'))
self.assertFalse(im.visitdir(b'folder')) self.assertFalse(im.visitdir(b'folder'))
self.assertFalse(im.visitdir(b'dir/subdir/z')) self.assertFalse(im.visitdir(b'dir/subdir/z'))
self.assertFalse(im.visitdir(b'dir/subdir/x')) self.assertFalse(im.visitdir(b'dir/subdir/x'))
def testVisitchildrensetIncludeInclude4(self): def testVisitchildrensetIncludeInclude4(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/z']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir/x']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir/z']
)
im = matchmod.intersectmatchers(m1, m2) im = matchmod.intersectmatchers(m1, m2)
# OPT: these next two could probably be set() as well. # OPT: these next two could probably be set() as well.
self.assertEqual(im.visitchildrenset(b''), {b'dir'}) self.assertEqual(im.visitchildrenset(b''), {b'dir'})
self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(im.visitchildrenset(b'dir/subdir'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
self.assertEqual(im.visitchildrenset(b'dir/foo'), set()) self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
self.assertEqual(im.visitchildrenset(b'folder'), set()) self.assertEqual(im.visitchildrenset(b'folder'), set())
self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set()) self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all') self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
self.assertEqual(um.visitchildrenset(b'folder'), b'all') self.assertEqual(um.visitchildrenset(b'folder'), b'all')
def testVisitdirM2SubdirPrefix(self): def testVisitdirM2SubdirPrefix(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.match(b'/repo', b'', patterns=[b'path:dir/subdir']) m2 = matchmod.match(
util.localpath(b'/repo'), b'', patterns=[b'path:dir/subdir']
)
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitdir(b''), b'all') self.assertEqual(um.visitdir(b''), b'all')
self.assertEqual(um.visitdir(b'dir'), b'all') self.assertEqual(um.visitdir(b'dir'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir'), b'all') self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
self.assertEqual(um.visitdir(b'dir/foo'), b'all') self.assertEqual(um.visitdir(b'dir/foo'), b'all')
self.assertEqual(um.visitdir(b'folder'), b'all') self.assertEqual(um.visitdir(b'folder'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
def testVisitchildrensetM2SubdirPrefix(self): def testVisitchildrensetM2SubdirPrefix(self):
m1 = matchmod.alwaysmatcher() m1 = matchmod.alwaysmatcher()
m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitchildrenset(b''), b'all') self.assertEqual(um.visitchildrenset(b''), b'all')
self.assertEqual(um.visitchildrenset(b'dir'), b'all') self.assertEqual(um.visitchildrenset(b'dir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all') self.assertEqual(um.visitchildrenset(b'dir/foo'), b'all')
self.assertEqual(um.visitchildrenset(b'folder'), b'all') self.assertEqual(um.visitchildrenset(b'folder'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude(self): def testVisitdirIncludeInclude(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'rootfilesin:dir']
)
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitdir(b''), True) self.assertEqual(um.visitdir(b''), True)
self.assertEqual(um.visitdir(b'dir'), True) self.assertEqual(um.visitdir(b'dir'), True)
self.assertEqual(um.visitdir(b'dir/subdir'), b'all') self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
self.assertFalse(um.visitdir(b'dir/foo')) self.assertFalse(um.visitdir(b'dir/foo'))
self.assertFalse(um.visitdir(b'folder')) self.assertFalse(um.visitdir(b'folder'))
# OPT: These two should probably be 'all' not True. # OPT: These two should probably be 'all' not True.
self.assertEqual(um.visitdir(b'dir/subdir/z'), True) self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
self.assertEqual(um.visitdir(b'dir/subdir/x'), True) self.assertEqual(um.visitdir(b'dir/subdir/x'), True)
def testVisitchildrensetIncludeInclude(self): def testVisitchildrensetIncludeInclude(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'rootfilesin:dir']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'rootfilesin:dir']
)
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitchildrenset(b''), {b'dir'}) self.assertEqual(um.visitchildrenset(b''), {b'dir'})
self.assertEqual(um.visitchildrenset(b'dir'), b'this') self.assertEqual(um.visitchildrenset(b'dir'), b'this')
self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/foo'), set()) self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
self.assertEqual(um.visitchildrenset(b'folder'), set()) self.assertEqual(um.visitchildrenset(b'folder'), set())
# OPT: These next two could be 'all' instead of 'this'. # OPT: These next two could be 'all' instead of 'this'.
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this')
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude2(self): def testVisitdirIncludeInclude2(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'path:folder']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:folder']
)
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitdir(b''), True) self.assertEqual(um.visitdir(b''), True)
self.assertEqual(um.visitdir(b'dir'), True) self.assertEqual(um.visitdir(b'dir'), True)
self.assertEqual(um.visitdir(b'dir/subdir'), b'all') self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
self.assertFalse(um.visitdir(b'dir/foo')) self.assertFalse(um.visitdir(b'dir/foo'))
self.assertEqual(um.visitdir(b'folder'), b'all') self.assertEqual(um.visitdir(b'folder'), b'all')
# OPT: These should probably be 'all' not True. # OPT: These should probably be 'all' not True.
self.assertEqual(um.visitdir(b'dir/subdir/z'), True) self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
self.assertEqual(um.visitdir(b'dir/subdir/x'), True) self.assertEqual(um.visitdir(b'dir/subdir/x'), True)
def testVisitchildrensetIncludeInclude2(self): def testVisitchildrensetIncludeInclude2(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'path:folder']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:folder']
)
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitchildrenset(b''), {b'folder', b'dir'}) self.assertEqual(um.visitchildrenset(b''), {b'folder', b'dir'})
self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/foo'), set()) self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
self.assertEqual(um.visitchildrenset(b'folder'), b'all') self.assertEqual(um.visitchildrenset(b'folder'), b'all')
# OPT: These next two could be 'all' instead of 'this'. # OPT: These next two could be 'all' instead of 'this'.
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this')
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude3(self): def testVisitdirIncludeInclude3(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir/x']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitdir(b''), True) self.assertEqual(um.visitdir(b''), True)
self.assertEqual(um.visitdir(b'dir'), True) self.assertEqual(um.visitdir(b'dir'), True)
self.assertEqual(um.visitdir(b'dir/subdir'), b'all') self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
self.assertFalse(um.visitdir(b'dir/foo')) self.assertFalse(um.visitdir(b'dir/foo'))
self.assertFalse(um.visitdir(b'folder')) self.assertFalse(um.visitdir(b'folder'))
self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
# OPT: this should probably be 'all' not True. # OPT: this should probably be 'all' not True.
self.assertEqual(um.visitdir(b'dir/subdir/z'), True) self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
def testVisitchildrensetIncludeInclude3(self): def testVisitchildrensetIncludeInclude3(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir/x']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitchildrenset(b''), {b'dir'}) self.assertEqual(um.visitchildrenset(b''), {b'dir'})
self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/foo'), set()) self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
self.assertEqual(um.visitchildrenset(b'folder'), set()) self.assertEqual(um.visitchildrenset(b'folder'), set())
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
# OPT: this should probably be 'all' not 'this'. # OPT: this should probably be 'all' not 'this'.
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this')
# We're using includematcher instead of patterns because it behaves slightly # We're using includematcher instead of patterns because it behaves slightly
# better (giving narrower results) than patternmatcher. # better (giving narrower results) than patternmatcher.
def testVisitdirIncludeInclude4(self): def testVisitdirIncludeInclude4(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/z']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir/x']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir/z']
)
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
# OPT: these next three could probably be False as well. # OPT: these next three could probably be False as well.
self.assertEqual(um.visitdir(b''), True) self.assertEqual(um.visitdir(b''), True)
self.assertEqual(um.visitdir(b'dir'), True) self.assertEqual(um.visitdir(b'dir'), True)
self.assertEqual(um.visitdir(b'dir/subdir'), True) self.assertEqual(um.visitdir(b'dir/subdir'), True)
self.assertFalse(um.visitdir(b'dir/foo')) self.assertFalse(um.visitdir(b'dir/foo'))
self.assertFalse(um.visitdir(b'folder')) self.assertFalse(um.visitdir(b'folder'))
self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all') self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
def testVisitchildrensetIncludeInclude4(self): def testVisitchildrensetIncludeInclude4(self):
m1 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/x']) m1 = matchmod.match(
m2 = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir/z']) util.localpath(b'/repo'), b'', include=[b'path:dir/subdir/x']
)
m2 = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir/z']
)
um = matchmod.unionmatcher([m1, m2]) um = matchmod.unionmatcher([m1, m2])
self.assertEqual(um.visitchildrenset(b''), {b'dir'}) self.assertEqual(um.visitchildrenset(b''), {b'dir'})
self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'}) self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
self.assertEqual(um.visitchildrenset(b'dir/subdir'), {b'x', b'z'}) self.assertEqual(um.visitchildrenset(b'dir/subdir'), {b'x', b'z'})
self.assertEqual(um.visitchildrenset(b'dir/foo'), set()) self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
self.assertEqual(um.visitchildrenset(b'folder'), set()) self.assertEqual(um.visitchildrenset(b'folder'), set())
self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'all')
self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all') self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
class SubdirMatcherTests(unittest.TestCase): class SubdirMatcherTests(unittest.TestCase):
def testVisitdir(self): def testVisitdir(self):
m = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
sm = matchmod.subdirmatcher(b'dir', m) sm = matchmod.subdirmatcher(b'dir', m)
self.assertEqual(sm.visitdir(b''), True) self.assertEqual(sm.visitdir(b''), True)
self.assertEqual(sm.visitdir(b'subdir'), b'all') self.assertEqual(sm.visitdir(b'subdir'), b'all')
# OPT: These next two should probably be 'all' not True. # OPT: These next two should probably be 'all' not True.
self.assertEqual(sm.visitdir(b'subdir/x'), True) self.assertEqual(sm.visitdir(b'subdir/x'), True)
self.assertEqual(sm.visitdir(b'subdir/z'), True) self.assertEqual(sm.visitdir(b'subdir/z'), True)
self.assertFalse(sm.visitdir(b'foo')) self.assertFalse(sm.visitdir(b'foo'))
def testVisitchildrenset(self): def testVisitchildrenset(self):
m = matchmod.match(b'/repo', b'', include=[b'path:dir/subdir']) m = matchmod.match(
util.localpath(b'/repo'), b'', include=[b'path:dir/subdir']
)
sm = matchmod.subdirmatcher(b'dir', m) sm = matchmod.subdirmatcher(b'dir', m)
self.assertEqual(sm.visitchildrenset(b''), {b'subdir'}) self.assertEqual(sm.visitchildrenset(b''), {b'subdir'})
self.assertEqual(sm.visitchildrenset(b'subdir'), b'all') self.assertEqual(sm.visitchildrenset(b'subdir'), b'all')
# OPT: These next two should probably be 'all' not 'this'. # OPT: These next two should probably be 'all' not 'this'.
self.assertEqual(sm.visitchildrenset(b'subdir/x'), b'this') self.assertEqual(sm.visitchildrenset(b'subdir/x'), b'this')
self.assertEqual(sm.visitchildrenset(b'subdir/z'), b'this') self.assertEqual(sm.visitchildrenset(b'subdir/z'), b'this')
self.assertEqual(sm.visitchildrenset(b'foo'), set()) self.assertEqual(sm.visitchildrenset(b'foo'), set())