Patchwork D4171: tests: make all the string constants in test-match.py be bytes

login
register
mail settings
Submitter phabricator
Date Aug. 9, 2018, 2:55 p.m.
Message ID <2f45d58434826552eccaa9d8fa875a39@localhost.localdomain>
Download mbox | patch
Permalink /patch/33453/
State Not Applicable
Headers show

Comments

phabricator - Aug. 9, 2018, 2:55 p.m.
This revision was automatically updated to reflect the committed changes.
Closed by commit rHG467b5c1df72d: tests: make all the string constants in test-match.py be bytes (authored by durin42, committed by ).

CHANGED PRIOR TO COMMIT
  https://phab.mercurial-scm.org/D4171?vs=10101&id=10103#toc

REPOSITORY
  rHG Mercurial

CHANGES SINCE LAST UPDATE
  https://phab.mercurial-scm.org/D4171?vs=10101&id=10103

REVISION DETAIL
  https://phab.mercurial-scm.org/D4171

AFFECTED FILES
  tests/test-match.py

CHANGE DETAILS




To: durin42, #hg-reviewers
Cc: yuja, mercurial-devel

Patch

diff --git a/tests/test-match.py b/tests/test-match.py
--- a/tests/test-match.py
+++ b/tests/test-match.py
@@ -12,808 +12,810 @@ 
 class BaseMatcherTests(unittest.TestCase):
 
     def testVisitdir(self):
-        m = matchmod.basematcher('', '')
-        self.assertTrue(m.visitdir('.'))
-        self.assertTrue(m.visitdir('dir'))
+        m = matchmod.basematcher(b'', b'')
+        self.assertTrue(m.visitdir(b'.'))
+        self.assertTrue(m.visitdir(b'dir'))
 
     def testVisitchildrenset(self):
-        m = matchmod.basematcher('', '')
-        self.assertEqual(m.visitchildrenset('.'), 'this')
-        self.assertEqual(m.visitchildrenset('dir'), 'this')
+        m = matchmod.basematcher(b'', b'')
+        self.assertEqual(m.visitchildrenset(b'.'), b'this')
+        self.assertEqual(m.visitchildrenset(b'dir'), b'this')
 
 class AlwaysMatcherTests(unittest.TestCase):
 
     def testVisitdir(self):
-        m = matchmod.alwaysmatcher('', '')
-        self.assertEqual(m.visitdir('.'), 'all')
-        self.assertEqual(m.visitdir('dir'), 'all')
+        m = matchmod.alwaysmatcher(b'', b'')
+        self.assertEqual(m.visitdir(b'.'), b'all')
+        self.assertEqual(m.visitdir(b'dir'), b'all')
 
     def testVisitchildrenset(self):
-        m = matchmod.alwaysmatcher('', '')
-        self.assertEqual(m.visitchildrenset('.'), 'all')
-        self.assertEqual(m.visitchildrenset('dir'), 'all')
+        m = matchmod.alwaysmatcher(b'', b'')
+        self.assertEqual(m.visitchildrenset(b'.'), b'all')
+        self.assertEqual(m.visitchildrenset(b'dir'), b'all')
 
 class NeverMatcherTests(unittest.TestCase):
 
     def testVisitdir(self):
-        m = matchmod.nevermatcher('', '')
-        self.assertFalse(m.visitdir('.'))
-        self.assertFalse(m.visitdir('dir'))
+        m = matchmod.nevermatcher(b'', b'')
+        self.assertFalse(m.visitdir(b'.'))
+        self.assertFalse(m.visitdir(b'dir'))
 
     def testVisitchildrenset(self):
-        m = matchmod.nevermatcher('', '')
-        self.assertEqual(m.visitchildrenset('.'), set())
-        self.assertEqual(m.visitchildrenset('dir'), set())
+        m = matchmod.nevermatcher(b'', b'')
+        self.assertEqual(m.visitchildrenset(b'.'), set())
+        self.assertEqual(m.visitchildrenset(b'dir'), set())
 
 class PredicateMatcherTests(unittest.TestCase):
     # predicatematcher does not currently define either of these methods, so
     # this is equivalent to BaseMatcherTests.
 
     def testVisitdir(self):
-        m = matchmod.predicatematcher('', '', lambda *a: False)
-        self.assertTrue(m.visitdir('.'))
-        self.assertTrue(m.visitdir('dir'))
+        m = matchmod.predicatematcher(b'', b'', lambda *a: False)
+        self.assertTrue(m.visitdir(b'.'))
+        self.assertTrue(m.visitdir(b'dir'))
 
     def testVisitchildrenset(self):
-        m = matchmod.predicatematcher('', '', lambda *a: False)
-        self.assertEqual(m.visitchildrenset('.'), 'this')
-        self.assertEqual(m.visitchildrenset('dir'), 'this')
+        m = matchmod.predicatematcher(b'', b'', lambda *a: False)
+        self.assertEqual(m.visitchildrenset(b'.'), b'this')
+        self.assertEqual(m.visitchildrenset(b'dir'), b'this')
 
 class PatternMatcherTests(unittest.TestCase):
 
     def testVisitdirPrefix(self):
-        m = matchmod.match('x', '', patterns=['path:dir/subdir'])
+        m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir'])
         assert isinstance(m, matchmod.patternmatcher)
-        self.assertTrue(m.visitdir('.'))
-        self.assertTrue(m.visitdir('dir'))
-        self.assertEqual(m.visitdir('dir/subdir'), 'all')
+        self.assertTrue(m.visitdir(b'.'))
+        self.assertTrue(m.visitdir(b'dir'))
+        self.assertEqual(m.visitdir(b'dir/subdir'), b'all')
         # OPT: This should probably be 'all' if its parent is?
-        self.assertTrue(m.visitdir('dir/subdir/x'))
-        self.assertFalse(m.visitdir('folder'))
+        self.assertTrue(m.visitdir(b'dir/subdir/x'))
+        self.assertFalse(m.visitdir(b'folder'))
 
     def testVisitchildrensetPrefix(self):
-        m = matchmod.match('x', '', patterns=['path:dir/subdir'])
+        m = matchmod.match(b'x', b'', patterns=[b'path:dir/subdir'])
         assert isinstance(m, matchmod.patternmatcher)
-        self.assertEqual(m.visitchildrenset('.'), 'this')
-        self.assertEqual(m.visitchildrenset('dir'), 'this')
-        self.assertEqual(m.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(m.visitchildrenset(b'.'), b'this')
+        self.assertEqual(m.visitchildrenset(b'dir'), b'this')
+        self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')
         # OPT: This should probably be 'all' if its parent is?
-        self.assertEqual(m.visitchildrenset('dir/subdir/x'), 'this')
-        self.assertEqual(m.visitchildrenset('folder'), set())
+        self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
+        self.assertEqual(m.visitchildrenset(b'folder'), set())
 
     def testVisitdirRootfilesin(self):
-        m = matchmod.match('x', '', patterns=['rootfilesin:dir/subdir'])
+        m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir'])
         assert isinstance(m, matchmod.patternmatcher)
-        self.assertTrue(m.visitdir('.'))
-        self.assertFalse(m.visitdir('dir/subdir/x'))
-        self.assertFalse(m.visitdir('folder'))
+        self.assertTrue(m.visitdir(b'.'))
+        self.assertFalse(m.visitdir(b'dir/subdir/x'))
+        self.assertFalse(m.visitdir(b'folder'))
         # FIXME: These should probably be True.
-        self.assertFalse(m.visitdir('dir'))
-        self.assertFalse(m.visitdir('dir/subdir'))
+        self.assertFalse(m.visitdir(b'dir'))
+        self.assertFalse(m.visitdir(b'dir/subdir'))
 
     def testVisitchildrensetRootfilesin(self):
-        m = matchmod.match('x', '', patterns=['rootfilesin:dir/subdir'])
+        m = matchmod.match(b'x', b'', patterns=[b'rootfilesin:dir/subdir'])
         assert isinstance(m, matchmod.patternmatcher)
-        self.assertEqual(m.visitchildrenset('.'), 'this')
-        self.assertEqual(m.visitchildrenset('dir/subdir/x'), set())
-        self.assertEqual(m.visitchildrenset('folder'), set())
+        self.assertEqual(m.visitchildrenset(b'.'), b'this')
+        self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())
+        self.assertEqual(m.visitchildrenset(b'folder'), set())
         # FIXME: These should probably be {'subdir'} and 'this', respectively,
         # or at least 'this' and 'this'.
-        self.assertEqual(m.visitchildrenset('dir'), set())
-        self.assertEqual(m.visitchildrenset('dir/subdir'), set())
+        self.assertEqual(m.visitchildrenset(b'dir'), set())
+        self.assertEqual(m.visitchildrenset(b'dir/subdir'), set())
 
     def testVisitdirGlob(self):
-        m = matchmod.match('x', '', patterns=['glob:dir/z*'])
+        m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*'])
         assert isinstance(m, matchmod.patternmatcher)
-        self.assertTrue(m.visitdir('.'))
-        self.assertTrue(m.visitdir('dir'))
-        self.assertFalse(m.visitdir('folder'))
+        self.assertTrue(m.visitdir(b'.'))
+        self.assertTrue(m.visitdir(b'dir'))
+        self.assertFalse(m.visitdir(b'folder'))
         # OPT: these should probably be False.
-        self.assertTrue(m.visitdir('dir/subdir'))
-        self.assertTrue(m.visitdir('dir/subdir/x'))
+        self.assertTrue(m.visitdir(b'dir/subdir'))
+        self.assertTrue(m.visitdir(b'dir/subdir/x'))
 
     def testVisitchildrensetGlob(self):
-        m = matchmod.match('x', '', patterns=['glob:dir/z*'])
+        m = matchmod.match(b'x', b'', patterns=[b'glob:dir/z*'])
         assert isinstance(m, matchmod.patternmatcher)
-        self.assertEqual(m.visitchildrenset('.'), 'this')
-        self.assertEqual(m.visitchildrenset('folder'), set())
-        self.assertEqual(m.visitchildrenset('dir'), 'this')
+        self.assertEqual(m.visitchildrenset(b'.'), b'this')
+        self.assertEqual(m.visitchildrenset(b'folder'), set())
+        self.assertEqual(m.visitchildrenset(b'dir'), b'this')
         # OPT: these should probably be set().
-        self.assertEqual(m.visitchildrenset('dir/subdir'), 'this')
-        self.assertEqual(m.visitchildrenset('dir/subdir/x'), 'this')
+        self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')
+        self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
 
 class IncludeMatcherTests(unittest.TestCase):
 
     def testVisitdirPrefix(self):
-        m = matchmod.match('x', '', include=['path:dir/subdir'])
+        m = matchmod.match(b'x', b'', include=[b'path:dir/subdir'])
         assert isinstance(m, matchmod.includematcher)
-        self.assertTrue(m.visitdir('.'))
-        self.assertTrue(m.visitdir('dir'))
-        self.assertEqual(m.visitdir('dir/subdir'), 'all')
+        self.assertTrue(m.visitdir(b'.'))
+        self.assertTrue(m.visitdir(b'dir'))
+        self.assertEqual(m.visitdir(b'dir/subdir'), b'all')
         # OPT: This should probably be 'all' if its parent is?
-        self.assertTrue(m.visitdir('dir/subdir/x'))
-        self.assertFalse(m.visitdir('folder'))
+        self.assertTrue(m.visitdir(b'dir/subdir/x'))
+        self.assertFalse(m.visitdir(b'folder'))
 
     def testVisitchildrensetPrefix(self):
-        m = matchmod.match('x', '', include=['path:dir/subdir'])
+        m = matchmod.match(b'x', b'', include=[b'path:dir/subdir'])
         assert isinstance(m, matchmod.includematcher)
-        self.assertEqual(m.visitchildrenset('.'), {'dir'})
-        self.assertEqual(m.visitchildrenset('dir'), {'subdir'})
-        self.assertEqual(m.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(m.visitchildrenset(b'.'), {b'dir'})
+        self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})
+        self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'all')
         # OPT: This should probably be 'all' if its parent is?
-        self.assertEqual(m.visitchildrenset('dir/subdir/x'), 'this')
-        self.assertEqual(m.visitchildrenset('folder'), set())
+        self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
+        self.assertEqual(m.visitchildrenset(b'folder'), set())
 
     def testVisitdirRootfilesin(self):
-        m = matchmod.match('x', '', include=['rootfilesin:dir/subdir'])
+        m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir'])
         assert isinstance(m, matchmod.includematcher)
-        self.assertTrue(m.visitdir('.'))
-        self.assertTrue(m.visitdir('dir'))
-        self.assertTrue(m.visitdir('dir/subdir'))
-        self.assertFalse(m.visitdir('dir/subdir/x'))
-        self.assertFalse(m.visitdir('folder'))
+        self.assertTrue(m.visitdir(b'.'))
+        self.assertTrue(m.visitdir(b'dir'))
+        self.assertTrue(m.visitdir(b'dir/subdir'))
+        self.assertFalse(m.visitdir(b'dir/subdir/x'))
+        self.assertFalse(m.visitdir(b'folder'))
 
     def testVisitchildrensetRootfilesin(self):
-        m = matchmod.match('x', '', include=['rootfilesin:dir/subdir'])
+        m = matchmod.match(b'x', b'', include=[b'rootfilesin:dir/subdir'])
         assert isinstance(m, matchmod.includematcher)
-        self.assertEqual(m.visitchildrenset('.'), {'dir'})
-        self.assertEqual(m.visitchildrenset('dir'), {'subdir'})
-        self.assertEqual(m.visitchildrenset('dir/subdir'), 'this')
-        self.assertEqual(m.visitchildrenset('dir/subdir/x'), set())
-        self.assertEqual(m.visitchildrenset('folder'), set())
+        self.assertEqual(m.visitchildrenset(b'.'), {b'dir'})
+        self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})
+        self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')
+        self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set())
+        self.assertEqual(m.visitchildrenset(b'folder'), set())
 
     def testVisitdirGlob(self):
-        m = matchmod.match('x', '', include=['glob:dir/z*'])
+        m = matchmod.match(b'x', b'', include=[b'glob:dir/z*'])
         assert isinstance(m, matchmod.includematcher)
-        self.assertTrue(m.visitdir('.'))
-        self.assertTrue(m.visitdir('dir'))
-        self.assertFalse(m.visitdir('folder'))
+        self.assertTrue(m.visitdir(b'.'))
+        self.assertTrue(m.visitdir(b'dir'))
+        self.assertFalse(m.visitdir(b'folder'))
         # OPT: these should probably be False.
-        self.assertTrue(m.visitdir('dir/subdir'))
-        self.assertTrue(m.visitdir('dir/subdir/x'))
+        self.assertTrue(m.visitdir(b'dir/subdir'))
+        self.assertTrue(m.visitdir(b'dir/subdir/x'))
 
     def testVisitchildrensetGlob(self):
-        m = matchmod.match('x', '', include=['glob:dir/z*'])
+        m = matchmod.match(b'x', b'', include=[b'glob:dir/z*'])
         assert isinstance(m, matchmod.includematcher)
-        self.assertEqual(m.visitchildrenset('.'), {'dir'})
-        self.assertEqual(m.visitchildrenset('folder'), set())
-        self.assertEqual(m.visitchildrenset('dir'), 'this')
+        self.assertEqual(m.visitchildrenset(b'.'), {b'dir'})
+        self.assertEqual(m.visitchildrenset(b'folder'), set())
+        self.assertEqual(m.visitchildrenset(b'dir'), b'this')
         # OPT: these should probably be set().
-        self.assertEqual(m.visitchildrenset('dir/subdir'), 'this')
-        self.assertEqual(m.visitchildrenset('dir/subdir/x'), 'this')
+        self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this')
+        self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this')
 
 class ExactMatcherTests(unittest.TestCase):
 
     def testVisitdir(self):
-        m = matchmod.match('x', '', patterns=['dir/subdir/foo.txt'], exact=True)
+        m = matchmod.match(b'x', b'', patterns=[b'dir/subdir/foo.txt'],
+                           exact=True)
         assert isinstance(m, matchmod.exactmatcher)
-        self.assertTrue(m.visitdir('.'))
-        self.assertTrue(m.visitdir('dir'))
-        self.assertTrue(m.visitdir('dir/subdir'))
-        self.assertFalse(m.visitdir('dir/subdir/foo.txt'))
-        self.assertFalse(m.visitdir('dir/foo'))
-        self.assertFalse(m.visitdir('dir/subdir/x'))
-        self.assertFalse(m.visitdir('folder'))
+        self.assertTrue(m.visitdir(b'.'))
+        self.assertTrue(m.visitdir(b'dir'))
+        self.assertTrue(m.visitdir(b'dir/subdir'))
+        self.assertFalse(m.visitdir(b'dir/subdir/foo.txt'))
+        self.assertFalse(m.visitdir(b'dir/foo'))
+        self.assertFalse(m.visitdir(b'dir/subdir/x'))
+        self.assertFalse(m.visitdir(b'folder'))
 
     def testVisitchildrenset(self):
-        m = matchmod.match('x', '', patterns=['dir/subdir/foo.txt'], exact=True)
+        m = matchmod.match(b'x', b'', patterns=[b'dir/subdir/foo.txt'],
+                           exact=True)
         assert isinstance(m, matchmod.exactmatcher)
-        self.assertEqual(m.visitchildrenset('.'), {'dir'})
-        self.assertEqual(m.visitchildrenset('dir'), {'subdir'})
-        self.assertEqual(m.visitchildrenset('dir/subdir'), 'this')
-        self.assertEqual(m.visitchildrenset('dir/subdir/x'), set())
-        self.assertEqual(m.visitchildrenset('dir/subdir/foo.txt'), set())
-        self.assertEqual(m.visitchildrenset('folder'), set())
+        self.assertEqual(m.visitchildrenset(b'.'), {b'dir'})
+        self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'})
+        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/foo.txt'), set())
+        self.assertEqual(m.visitchildrenset(b'folder'), set())
 
 class DifferenceMatcherTests(unittest.TestCase):
 
     def testVisitdirM2always(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.alwaysmatcher('', '')
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.alwaysmatcher(b'', b'')
         dm = matchmod.differencematcher(m1, m2)
         # dm should be equivalent to a nevermatcher.
-        self.assertFalse(dm.visitdir('.'))
-        self.assertFalse(dm.visitdir('dir'))
-        self.assertFalse(dm.visitdir('dir/subdir'))
-        self.assertFalse(dm.visitdir('dir/subdir/z'))
-        self.assertFalse(dm.visitdir('dir/foo'))
-        self.assertFalse(dm.visitdir('dir/subdir/x'))
-        self.assertFalse(dm.visitdir('folder'))
+        self.assertFalse(dm.visitdir(b'.'))
+        self.assertFalse(dm.visitdir(b'dir'))
+        self.assertFalse(dm.visitdir(b'dir/subdir'))
+        self.assertFalse(dm.visitdir(b'dir/subdir/z'))
+        self.assertFalse(dm.visitdir(b'dir/foo'))
+        self.assertFalse(dm.visitdir(b'dir/subdir/x'))
+        self.assertFalse(dm.visitdir(b'folder'))
 
     def testVisitchildrensetM2always(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.alwaysmatcher('', '')
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.alwaysmatcher(b'', b'')
         dm = matchmod.differencematcher(m1, m2)
         # dm should be equivalent to a nevermatcher.
-        self.assertEqual(dm.visitchildrenset('.'), set())
-        self.assertEqual(dm.visitchildrenset('dir'), set())
-        self.assertEqual(dm.visitchildrenset('dir/subdir'), set())
-        self.assertEqual(dm.visitchildrenset('dir/subdir/z'), set())
-        self.assertEqual(dm.visitchildrenset('dir/foo'), set())
-        self.assertEqual(dm.visitchildrenset('dir/subdir/x'), set())
-        self.assertEqual(dm.visitchildrenset('folder'), set())
+        self.assertEqual(dm.visitchildrenset(b'.'), set())
+        self.assertEqual(dm.visitchildrenset(b'dir'), set())
+        self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set())
+        self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), set())
+        self.assertEqual(dm.visitchildrenset(b'dir/foo'), set())
+        self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), set())
+        self.assertEqual(dm.visitchildrenset(b'folder'), set())
 
     def testVisitdirM2never(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.nevermatcher('', '')
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.nevermatcher(b'', b'')
         dm = matchmod.differencematcher(m1, m2)
         # dm should be equivalent to a alwaysmatcher. OPT: if m2 is a
         # nevermatcher, we could return 'all' for these.
         #
         # We're testing Equal-to-True instead of just 'assertTrue' since
         # assertTrue does NOT verify that it's a bool, just that it's truthy.
         # While we may want to eventually make these return 'all', they should
         # not currently do so.
-        self.assertEqual(dm.visitdir('.'), True)
-        self.assertEqual(dm.visitdir('dir'), True)
-        self.assertEqual(dm.visitdir('dir/subdir'), True)
-        self.assertEqual(dm.visitdir('dir/subdir/z'), True)
-        self.assertEqual(dm.visitdir('dir/foo'), True)
-        self.assertEqual(dm.visitdir('dir/subdir/x'), True)
-        self.assertEqual(dm.visitdir('folder'), True)
+        self.assertEqual(dm.visitdir(b'.'), True)
+        self.assertEqual(dm.visitdir(b'dir'), True)
+        self.assertEqual(dm.visitdir(b'dir/subdir'), True)
+        self.assertEqual(dm.visitdir(b'dir/subdir/z'), True)
+        self.assertEqual(dm.visitdir(b'dir/foo'), True)
+        self.assertEqual(dm.visitdir(b'dir/subdir/x'), True)
+        self.assertEqual(dm.visitdir(b'folder'), True)
 
     def testVisitchildrensetM2never(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.nevermatcher('', '')
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.nevermatcher(b'', b'')
         dm = matchmod.differencematcher(m1, m2)
         # dm should be equivalent to a alwaysmatcher.
-        self.assertEqual(dm.visitchildrenset('.'), 'all')
-        self.assertEqual(dm.visitchildrenset('dir'), 'all')
-        self.assertEqual(dm.visitchildrenset('dir/subdir'), 'all')
-        self.assertEqual(dm.visitchildrenset('dir/subdir/z'), 'all')
-        self.assertEqual(dm.visitchildrenset('dir/foo'), 'all')
-        self.assertEqual(dm.visitchildrenset('dir/subdir/x'), 'all')
-        self.assertEqual(dm.visitchildrenset('folder'), 'all')
+        self.assertEqual(dm.visitchildrenset(b'.'), b'all')
+        self.assertEqual(dm.visitchildrenset(b'dir'), 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/foo'), b'all')
+        self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'all')
+        self.assertEqual(dm.visitchildrenset(b'folder'), b'all')
 
     def testVisitdirM2SubdirPrefix(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.match('', '', patterns=['path:dir/subdir'])
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])
         dm = matchmod.differencematcher(m1, m2)
-        self.assertEqual(dm.visitdir('.'), True)
-        self.assertEqual(dm.visitdir('dir'), True)
-        self.assertFalse(dm.visitdir('dir/subdir'))
+        self.assertEqual(dm.visitdir(b'.'), True)
+        self.assertEqual(dm.visitdir(b'dir'), True)
+        self.assertFalse(dm.visitdir(b'dir/subdir'))
         # OPT: We should probably return False for these; we don't because
         # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
         # an 'all' pattern, just True.
-        self.assertEqual(dm.visitdir('dir/subdir/z'), True)
-        self.assertEqual(dm.visitdir('dir/subdir/x'), True)
+        self.assertEqual(dm.visitdir(b'dir/subdir/z'), True)
+        self.assertEqual(dm.visitdir(b'dir/subdir/x'), True)
         # OPT: We could return 'all' for these.
-        self.assertEqual(dm.visitdir('dir/foo'), True)
-        self.assertEqual(dm.visitdir('folder'), True)
+        self.assertEqual(dm.visitdir(b'dir/foo'), True)
+        self.assertEqual(dm.visitdir(b'folder'), True)
 
     def testVisitchildrensetM2SubdirPrefix(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.match('', '', patterns=['path:dir/subdir'])
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])
         dm = matchmod.differencematcher(m1, m2)
-        self.assertEqual(dm.visitchildrenset('.'), 'this')
-        self.assertEqual(dm.visitchildrenset('dir'), 'this')
-        self.assertEqual(dm.visitchildrenset('dir/subdir'), set())
-        self.assertEqual(dm.visitchildrenset('dir/foo'), 'all')
-        self.assertEqual(dm.visitchildrenset('folder'), 'all')
+        self.assertEqual(dm.visitchildrenset(b'.'), b'this')
+        self.assertEqual(dm.visitchildrenset(b'dir'), b'this')
+        self.assertEqual(dm.visitchildrenset(b'dir/subdir'), set())
+        self.assertEqual(dm.visitchildrenset(b'dir/foo'), b'all')
+        self.assertEqual(dm.visitchildrenset(b'folder'), b'all')
         # OPT: We should probably return set() for these; we don't because
         # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
         # an 'all' pattern, just 'this'.
-        self.assertEqual(dm.visitchildrenset('dir/subdir/z'), 'this')
-        self.assertEqual(dm.visitchildrenset('dir/subdir/x'), 'this')
+        self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'this')
+        self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'this')
 
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeIncludfe(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir'])
-        m2 = matchmod.match('', '', include=['rootfilesin:dir'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
+        m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
         dm = matchmod.differencematcher(m1, m2)
-        self.assertEqual(dm.visitdir('.'), True)
-        self.assertEqual(dm.visitdir('dir'), True)
-        self.assertEqual(dm.visitdir('dir/subdir'), True)
-        self.assertFalse(dm.visitdir('dir/foo'))
-        self.assertFalse(dm.visitdir('folder'))
+        self.assertEqual(dm.visitdir(b'.'), True)
+        self.assertEqual(dm.visitdir(b'dir'), True)
+        self.assertEqual(dm.visitdir(b'dir/subdir'), True)
+        self.assertFalse(dm.visitdir(b'dir/foo'))
+        self.assertFalse(dm.visitdir(b'folder'))
         # OPT: We should probably return False for these; we don't because
         # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
         # an 'all' pattern, just True.
-        self.assertEqual(dm.visitdir('dir/subdir/z'), True)
-        self.assertEqual(dm.visitdir('dir/subdir/x'), True)
+        self.assertEqual(dm.visitdir(b'dir/subdir/z'), True)
+        self.assertEqual(dm.visitdir(b'dir/subdir/x'), True)
 
     def testVisitchildrensetIncludeInclude(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir'])
-        m2 = matchmod.match('', '', include=['rootfilesin:dir'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
+        m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
         dm = matchmod.differencematcher(m1, m2)
-        self.assertEqual(dm.visitchildrenset('.'), {'dir'})
-        self.assertEqual(dm.visitchildrenset('dir'), {'subdir'})
-        self.assertEqual(dm.visitchildrenset('dir/subdir'), 'all')
-        self.assertEqual(dm.visitchildrenset('dir/foo'), set())
-        self.assertEqual(dm.visitchildrenset('folder'), set())
+        self.assertEqual(dm.visitchildrenset(b'.'), {b'dir'})
+        self.assertEqual(dm.visitchildrenset(b'dir'), {b'subdir'})
+        self.assertEqual(dm.visitchildrenset(b'dir/subdir'), b'all')
+        self.assertEqual(dm.visitchildrenset(b'dir/foo'), set())
+        self.assertEqual(dm.visitchildrenset(b'folder'), set())
         # OPT: We should probably return set() for these; we don't because
         # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
         # an 'all' pattern, just 'this'.
-        self.assertEqual(dm.visitchildrenset('dir/subdir/z'), 'this')
-        self.assertEqual(dm.visitchildrenset('dir/subdir/x'), 'this')
+        self.assertEqual(dm.visitchildrenset(b'dir/subdir/z'), b'this')
+        self.assertEqual(dm.visitchildrenset(b'dir/subdir/x'), b'this')
 
 class IntersectionMatcherTests(unittest.TestCase):
 
     def testVisitdirM2always(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.alwaysmatcher('', '')
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.alwaysmatcher(b'', b'')
         im = matchmod.intersectmatchers(m1, m2)
         # im should be equivalent to a alwaysmatcher.
-        self.assertEqual(im.visitdir('.'), 'all')
-        self.assertEqual(im.visitdir('dir'), 'all')
-        self.assertEqual(im.visitdir('dir/subdir'), 'all')
-        self.assertEqual(im.visitdir('dir/subdir/z'), 'all')
-        self.assertEqual(im.visitdir('dir/foo'), 'all')
-        self.assertEqual(im.visitdir('dir/subdir/x'), 'all')
-        self.assertEqual(im.visitdir('folder'), 'all')
+        self.assertEqual(im.visitdir(b'.'), b'all')
+        self.assertEqual(im.visitdir(b'dir'), b'all')
+        self.assertEqual(im.visitdir(b'dir/subdir'), b'all')
+        self.assertEqual(im.visitdir(b'dir/subdir/z'), b'all')
+        self.assertEqual(im.visitdir(b'dir/foo'), b'all')
+        self.assertEqual(im.visitdir(b'dir/subdir/x'), b'all')
+        self.assertEqual(im.visitdir(b'folder'), b'all')
 
     def testVisitchildrensetM2always(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.alwaysmatcher('', '')
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.alwaysmatcher(b'', b'')
         im = matchmod.intersectmatchers(m1, m2)
         # im should be equivalent to a alwaysmatcher.
-        self.assertEqual(im.visitchildrenset('.'), 'all')
-        self.assertEqual(im.visitchildrenset('dir'), 'all')
-        self.assertEqual(im.visitchildrenset('dir/subdir'), 'all')
-        self.assertEqual(im.visitchildrenset('dir/subdir/z'), 'all')
-        self.assertEqual(im.visitchildrenset('dir/foo'), 'all')
-        self.assertEqual(im.visitchildrenset('dir/subdir/x'), 'all')
-        self.assertEqual(im.visitchildrenset('folder'), 'all')
+        self.assertEqual(im.visitchildrenset(b'.'), b'all')
+        self.assertEqual(im.visitchildrenset(b'dir'), b'all')
+        self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all')
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), b'all')
+        self.assertEqual(im.visitchildrenset(b'dir/foo'), b'all')
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'all')
+        self.assertEqual(im.visitchildrenset(b'folder'), b'all')
 
     def testVisitdirM2never(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.nevermatcher('', '')
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.nevermatcher(b'', b'')
         im = matchmod.intersectmatchers(m1, m2)
         # im should be equivalent to a nevermatcher.
-        self.assertFalse(im.visitdir('.'))
-        self.assertFalse(im.visitdir('dir'))
-        self.assertFalse(im.visitdir('dir/subdir'))
-        self.assertFalse(im.visitdir('dir/subdir/z'))
-        self.assertFalse(im.visitdir('dir/foo'))
-        self.assertFalse(im.visitdir('dir/subdir/x'))
-        self.assertFalse(im.visitdir('folder'))
+        self.assertFalse(im.visitdir(b'.'))
+        self.assertFalse(im.visitdir(b'dir'))
+        self.assertFalse(im.visitdir(b'dir/subdir'))
+        self.assertFalse(im.visitdir(b'dir/subdir/z'))
+        self.assertFalse(im.visitdir(b'dir/foo'))
+        self.assertFalse(im.visitdir(b'dir/subdir/x'))
+        self.assertFalse(im.visitdir(b'folder'))
 
     def testVisitchildrensetM2never(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.nevermatcher('', '')
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.nevermatcher(b'', b'')
         im = matchmod.intersectmatchers(m1, m2)
         # im should be equivalent to a nevermqtcher.
-        self.assertEqual(im.visitchildrenset('.'), set())
-        self.assertEqual(im.visitchildrenset('dir'), set())
-        self.assertEqual(im.visitchildrenset('dir/subdir'), set())
-        self.assertEqual(im.visitchildrenset('dir/subdir/z'), set())
-        self.assertEqual(im.visitchildrenset('dir/foo'), set())
-        self.assertEqual(im.visitchildrenset('dir/subdir/x'), set())
-        self.assertEqual(im.visitchildrenset('folder'), set())
+        self.assertEqual(im.visitchildrenset(b'.'), set())
+        self.assertEqual(im.visitchildrenset(b'dir'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
+        self.assertEqual(im.visitchildrenset(b'folder'), set())
 
     def testVisitdirM2SubdirPrefix(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.match('', '', patterns=['path:dir/subdir'])
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])
         im = matchmod.intersectmatchers(m1, m2)
-        self.assertEqual(im.visitdir('.'), True)
-        self.assertEqual(im.visitdir('dir'), True)
-        self.assertEqual(im.visitdir('dir/subdir'), 'all')
-        self.assertFalse(im.visitdir('dir/foo'))
-        self.assertFalse(im.visitdir('folder'))
+        self.assertEqual(im.visitdir(b'.'), True)
+        self.assertEqual(im.visitdir(b'dir'), True)
+        self.assertEqual(im.visitdir(b'dir/subdir'), b'all')
+        self.assertFalse(im.visitdir(b'dir/foo'))
+        self.assertFalse(im.visitdir(b'folder'))
         # OPT: We should probably return 'all' for these; we don't because
         # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
         # an 'all' pattern, just True.
-        self.assertEqual(im.visitdir('dir/subdir/z'), True)
-        self.assertEqual(im.visitdir('dir/subdir/x'), True)
+        self.assertEqual(im.visitdir(b'dir/subdir/z'), True)
+        self.assertEqual(im.visitdir(b'dir/subdir/x'), True)
 
     def testVisitchildrensetM2SubdirPrefix(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.match('', '', include=['path:dir/subdir'])
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
         im = matchmod.intersectmatchers(m1, m2)
-        self.assertEqual(im.visitchildrenset('.'), {'dir'})
-        self.assertEqual(im.visitchildrenset('dir'), {'subdir'})
-        self.assertEqual(im.visitchildrenset('dir/subdir'), 'all')
-        self.assertEqual(im.visitchildrenset('dir/foo'), set())
-        self.assertEqual(im.visitchildrenset('folder'), set())
+        self.assertEqual(im.visitchildrenset(b'.'), {b'dir'})
+        self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
+        self.assertEqual(im.visitchildrenset(b'dir/subdir'), b'all')
+        self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
+        self.assertEqual(im.visitchildrenset(b'folder'), set())
         # OPT: We should probably return 'all' for these
-        self.assertEqual(im.visitchildrenset('dir/subdir/z'), 'this')
-        self.assertEqual(im.visitchildrenset('dir/subdir/x'), 'this')
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), b'this')
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this')
 
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeIncludfe(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir'])
-        m2 = matchmod.match('', '', include=['rootfilesin:dir'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
+        m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
         im = matchmod.intersectmatchers(m1, m2)
-        self.assertEqual(im.visitdir('.'), True)
-        self.assertEqual(im.visitdir('dir'), True)
-        self.assertFalse(im.visitdir('dir/subdir'))
-        self.assertFalse(im.visitdir('dir/foo'))
-        self.assertFalse(im.visitdir('folder'))
-        self.assertFalse(im.visitdir('dir/subdir/z'))
-        self.assertFalse(im.visitdir('dir/subdir/x'))
+        self.assertEqual(im.visitdir(b'.'), True)
+        self.assertEqual(im.visitdir(b'dir'), True)
+        self.assertFalse(im.visitdir(b'dir/subdir'))
+        self.assertFalse(im.visitdir(b'dir/foo'))
+        self.assertFalse(im.visitdir(b'folder'))
+        self.assertFalse(im.visitdir(b'dir/subdir/z'))
+        self.assertFalse(im.visitdir(b'dir/subdir/x'))
 
     def testVisitchildrensetIncludeInclude(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir'])
-        m2 = matchmod.match('', '', include=['rootfilesin:dir'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
+        m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
         im = matchmod.intersectmatchers(m1, m2)
-        self.assertEqual(im.visitchildrenset('.'), {'dir'})
-        self.assertEqual(im.visitchildrenset('dir'), 'this')
-        self.assertEqual(im.visitchildrenset('dir/subdir'), set())
-        self.assertEqual(im.visitchildrenset('dir/foo'), set())
-        self.assertEqual(im.visitchildrenset('folder'), set())
-        self.assertEqual(im.visitchildrenset('dir/subdir/z'), set())
-        self.assertEqual(im.visitchildrenset('dir/subdir/x'), set())
+        self.assertEqual(im.visitchildrenset(b'.'), {b'dir'})
+        self.assertEqual(im.visitchildrenset(b'dir'), b'this')
+        self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
+        self.assertEqual(im.visitchildrenset(b'folder'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
 
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeInclude2(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir'])
-        m2 = matchmod.match('', '', include=['path:folder'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
+        m2 = matchmod.match(b'', b'', include=[b'path:folder'])
         im = matchmod.intersectmatchers(m1, m2)
         # FIXME: is True correct here?
-        self.assertEqual(im.visitdir('.'), True)
-        self.assertFalse(im.visitdir('dir'))
-        self.assertFalse(im.visitdir('dir/subdir'))
-        self.assertFalse(im.visitdir('dir/foo'))
-        self.assertFalse(im.visitdir('folder'))
-        self.assertFalse(im.visitdir('dir/subdir/z'))
-        self.assertFalse(im.visitdir('dir/subdir/x'))
+        self.assertEqual(im.visitdir(b'.'), True)
+        self.assertFalse(im.visitdir(b'dir'))
+        self.assertFalse(im.visitdir(b'dir/subdir'))
+        self.assertFalse(im.visitdir(b'dir/foo'))
+        self.assertFalse(im.visitdir(b'folder'))
+        self.assertFalse(im.visitdir(b'dir/subdir/z'))
+        self.assertFalse(im.visitdir(b'dir/subdir/x'))
 
     def testVisitchildrensetIncludeInclude2(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir'])
-        m2 = matchmod.match('', '', include=['path:folder'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
+        m2 = matchmod.match(b'', b'', include=[b'path:folder'])
         im = matchmod.intersectmatchers(m1, m2)
         # FIXME: is set() correct here?
-        self.assertEqual(im.visitchildrenset('.'), set())
-        self.assertEqual(im.visitchildrenset('dir'), set())
-        self.assertEqual(im.visitchildrenset('dir/subdir'), set())
-        self.assertEqual(im.visitchildrenset('dir/foo'), set())
-        self.assertEqual(im.visitchildrenset('folder'), set())
-        self.assertEqual(im.visitchildrenset('dir/subdir/z'), set())
-        self.assertEqual(im.visitchildrenset('dir/subdir/x'), set())
+        self.assertEqual(im.visitchildrenset(b'.'), set())
+        self.assertEqual(im.visitchildrenset(b'dir'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
+        self.assertEqual(im.visitchildrenset(b'folder'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
 
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeInclude3(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir/x'])
-        m2 = matchmod.match('', '', include=['path:dir/subdir'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
+        m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
         im = matchmod.intersectmatchers(m1, m2)
-        self.assertEqual(im.visitdir('.'), True)
-        self.assertEqual(im.visitdir('dir'), True)
-        self.assertEqual(im.visitdir('dir/subdir'), True)
-        self.assertFalse(im.visitdir('dir/foo'))
-        self.assertFalse(im.visitdir('folder'))
-        self.assertFalse(im.visitdir('dir/subdir/z'))
+        self.assertEqual(im.visitdir(b'.'), True)
+        self.assertEqual(im.visitdir(b'dir'), True)
+        self.assertEqual(im.visitdir(b'dir/subdir'), True)
+        self.assertFalse(im.visitdir(b'dir/foo'))
+        self.assertFalse(im.visitdir(b'folder'))
+        self.assertFalse(im.visitdir(b'dir/subdir/z'))
         # OPT: this should probably be 'all' not True.
-        self.assertEqual(im.visitdir('dir/subdir/x'), True)
+        self.assertEqual(im.visitdir(b'dir/subdir/x'), True)
 
     def testVisitchildrensetIncludeInclude3(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir/x'])
-        m2 = matchmod.match('', '', include=['path:dir/subdir'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
+        m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
         im = matchmod.intersectmatchers(m1, m2)
-        self.assertEqual(im.visitchildrenset('.'), {'dir'})
-        self.assertEqual(im.visitchildrenset('dir'), {'subdir'})
-        self.assertEqual(im.visitchildrenset('dir/subdir'), {'x'})
-        self.assertEqual(im.visitchildrenset('dir/foo'), set())
-        self.assertEqual(im.visitchildrenset('folder'), set())
-        self.assertEqual(im.visitchildrenset('dir/subdir/z'), set())
+        self.assertEqual(im.visitchildrenset(b'.'), {b'dir'})
+        self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
+        self.assertEqual(im.visitchildrenset(b'dir/subdir'), {b'x'})
+        self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
+        self.assertEqual(im.visitchildrenset(b'folder'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
         # OPT: this should probably be 'all' not 'this'.
-        self.assertEqual(im.visitchildrenset('dir/subdir/x'), 'this')
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), b'this')
 
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeInclude4(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir/x'])
-        m2 = matchmod.match('', '', include=['path:dir/subdir/z'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
+        m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])
         im = matchmod.intersectmatchers(m1, m2)
         # OPT: these next three could probably be False as well.
-        self.assertEqual(im.visitdir('.'), True)
-        self.assertEqual(im.visitdir('dir'), True)
-        self.assertEqual(im.visitdir('dir/subdir'), True)
-        self.assertFalse(im.visitdir('dir/foo'))
-        self.assertFalse(im.visitdir('folder'))
-        self.assertFalse(im.visitdir('dir/subdir/z'))
-        self.assertFalse(im.visitdir('dir/subdir/x'))
+        self.assertEqual(im.visitdir(b'.'), True)
+        self.assertEqual(im.visitdir(b'dir'), True)
+        self.assertEqual(im.visitdir(b'dir/subdir'), True)
+        self.assertFalse(im.visitdir(b'dir/foo'))
+        self.assertFalse(im.visitdir(b'folder'))
+        self.assertFalse(im.visitdir(b'dir/subdir/z'))
+        self.assertFalse(im.visitdir(b'dir/subdir/x'))
 
     def testVisitchildrensetIncludeInclude4(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir/x'])
-        m2 = matchmod.match('', '', include=['path:dir/subdir/z'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
+        m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])
         im = matchmod.intersectmatchers(m1, m2)
         # OPT: these next two could probably be set() as well.
-        self.assertEqual(im.visitchildrenset('.'), {'dir'})
-        self.assertEqual(im.visitchildrenset('dir'), {'subdir'})
-        self.assertEqual(im.visitchildrenset('dir/subdir'), set())
-        self.assertEqual(im.visitchildrenset('dir/foo'), set())
-        self.assertEqual(im.visitchildrenset('folder'), set())
-        self.assertEqual(im.visitchildrenset('dir/subdir/z'), set())
-        self.assertEqual(im.visitchildrenset('dir/subdir/x'), set())
+        self.assertEqual(im.visitchildrenset(b'.'), {b'dir'})
+        self.assertEqual(im.visitchildrenset(b'dir'), {b'subdir'})
+        self.assertEqual(im.visitchildrenset(b'dir/subdir'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/foo'), set())
+        self.assertEqual(im.visitchildrenset(b'folder'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/z'), set())
+        self.assertEqual(im.visitchildrenset(b'dir/subdir/x'), set())
 
 class UnionMatcherTests(unittest.TestCase):
 
     def testVisitdirM2always(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.alwaysmatcher('', '')
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.alwaysmatcher(b'', b'')
         um = matchmod.unionmatcher([m1, m2])
         # um should be equivalent to a alwaysmatcher.
-        self.assertEqual(um.visitdir('.'), 'all')
-        self.assertEqual(um.visitdir('dir'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir/z'), 'all')
-        self.assertEqual(um.visitdir('dir/foo'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir/x'), 'all')
-        self.assertEqual(um.visitdir('folder'), 'all')
+        self.assertEqual(um.visitdir(b'.'), 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/z'), b'all')
+        self.assertEqual(um.visitdir(b'dir/foo'), b'all')
+        self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
+        self.assertEqual(um.visitdir(b'folder'), b'all')
 
     def testVisitchildrensetM2always(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.alwaysmatcher('', '')
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.alwaysmatcher(b'', b'')
         um = matchmod.unionmatcher([m1, m2])
         # um should be equivalent to a alwaysmatcher.
-        self.assertEqual(um.visitchildrenset('.'), 'all')
-        self.assertEqual(um.visitchildrenset('dir'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/foo'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all')
-        self.assertEqual(um.visitchildrenset('folder'), 'all')
+        self.assertEqual(um.visitchildrenset(b'.'), 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/z'), 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'folder'), b'all')
 
     def testVisitdirM1never(self):
-        m1 = matchmod.nevermatcher('', '')
-        m2 = matchmod.alwaysmatcher('', '')
+        m1 = matchmod.nevermatcher(b'', b'')
+        m2 = matchmod.alwaysmatcher(b'', b'')
         um = matchmod.unionmatcher([m1, m2])
         # um should be equivalent to a alwaysmatcher.
-        self.assertEqual(um.visitdir('.'), 'all')
-        self.assertEqual(um.visitdir('dir'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir/z'), 'all')
-        self.assertEqual(um.visitdir('dir/foo'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir/x'), 'all')
-        self.assertEqual(um.visitdir('folder'), 'all')
+        self.assertEqual(um.visitdir(b'.'), 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/z'), b'all')
+        self.assertEqual(um.visitdir(b'dir/foo'), b'all')
+        self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
+        self.assertEqual(um.visitdir(b'folder'), b'all')
 
     def testVisitchildrensetM1never(self):
-        m1 = matchmod.nevermatcher('', '')
-        m2 = matchmod.alwaysmatcher('', '')
+        m1 = matchmod.nevermatcher(b'', b'')
+        m2 = matchmod.alwaysmatcher(b'', b'')
         um = matchmod.unionmatcher([m1, m2])
         # um should be equivalent to a alwaysmatcher.
-        self.assertEqual(um.visitchildrenset('.'), 'all')
-        self.assertEqual(um.visitchildrenset('dir'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/foo'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all')
-        self.assertEqual(um.visitchildrenset('folder'), 'all')
+        self.assertEqual(um.visitchildrenset(b'.'), 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/z'), 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'folder'), b'all')
 
     def testVisitdirM2never(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.nevermatcher('', '')
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.nevermatcher(b'', b'')
         um = matchmod.unionmatcher([m1, m2])
         # um should be equivalent to a alwaysmatcher.
-        self.assertEqual(um.visitdir('.'), 'all')
-        self.assertEqual(um.visitdir('dir'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir/z'), 'all')
-        self.assertEqual(um.visitdir('dir/foo'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir/x'), 'all')
-        self.assertEqual(um.visitdir('folder'), 'all')
+        self.assertEqual(um.visitdir(b'.'), 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/z'), b'all')
+        self.assertEqual(um.visitdir(b'dir/foo'), b'all')
+        self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
+        self.assertEqual(um.visitdir(b'folder'), b'all')
 
     def testVisitchildrensetM2never(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.nevermatcher('', '')
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.nevermatcher(b'', b'')
         um = matchmod.unionmatcher([m1, m2])
         # um should be equivalent to a alwaysmatcher.
-        self.assertEqual(um.visitchildrenset('.'), 'all')
-        self.assertEqual(um.visitchildrenset('dir'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/foo'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all')
-        self.assertEqual(um.visitchildrenset('folder'), 'all')
+        self.assertEqual(um.visitchildrenset(b'.'), 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/z'), 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'folder'), b'all')
 
     def testVisitdirM2SubdirPrefix(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.match('', '', patterns=['path:dir/subdir'])
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.match(b'', b'', patterns=[b'path:dir/subdir'])
         um = matchmod.unionmatcher([m1, m2])
-        self.assertEqual(um.visitdir('.'), 'all')
-        self.assertEqual(um.visitdir('dir'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir'), 'all')
-        self.assertEqual(um.visitdir('dir/foo'), 'all')
-        self.assertEqual(um.visitdir('folder'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir/z'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir/x'), 'all')
+        self.assertEqual(um.visitdir(b'.'), 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/foo'), 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/x'), b'all')
 
     def testVisitchildrensetM2SubdirPrefix(self):
-        m1 = matchmod.alwaysmatcher('', '')
-        m2 = matchmod.match('', '', include=['path:dir/subdir'])
+        m1 = matchmod.alwaysmatcher(b'', b'')
+        m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
         um = matchmod.unionmatcher([m1, m2])
-        self.assertEqual(um.visitchildrenset('.'), 'all')
-        self.assertEqual(um.visitchildrenset('dir'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/foo'), 'all')
-        self.assertEqual(um.visitchildrenset('folder'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all')
+        self.assertEqual(um.visitchildrenset(b'.'), 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/foo'), 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/x'), b'all')
 
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeIncludfe(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir'])
-        m2 = matchmod.match('', '', include=['rootfilesin:dir'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
+        m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
         um = matchmod.unionmatcher([m1, m2])
-        self.assertEqual(um.visitdir('.'), True)
-        self.assertEqual(um.visitdir('dir'), True)
-        self.assertEqual(um.visitdir('dir/subdir'), 'all')
-        self.assertFalse(um.visitdir('dir/foo'))
-        self.assertFalse(um.visitdir('folder'))
+        self.assertEqual(um.visitdir(b'.'), True)
+        self.assertEqual(um.visitdir(b'dir'), True)
+        self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
+        self.assertFalse(um.visitdir(b'dir/foo'))
+        self.assertFalse(um.visitdir(b'folder'))
         # OPT: These two should probably be 'all' not True.
-        self.assertEqual(um.visitdir('dir/subdir/z'), True)
-        self.assertEqual(um.visitdir('dir/subdir/x'), True)
+        self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
+        self.assertEqual(um.visitdir(b'dir/subdir/x'), True)
 
     def testVisitchildrensetIncludeInclude(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir'])
-        m2 = matchmod.match('', '', include=['rootfilesin:dir'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
+        m2 = matchmod.match(b'', b'', include=[b'rootfilesin:dir'])
         um = matchmod.unionmatcher([m1, m2])
-        self.assertEqual(um.visitchildrenset('.'), {'dir'})
-        self.assertEqual(um.visitchildrenset('dir'), 'this')
-        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/foo'), set())
-        self.assertEqual(um.visitchildrenset('folder'), set())
+        self.assertEqual(um.visitchildrenset(b'.'), {b'dir'})
+        self.assertEqual(um.visitchildrenset(b'dir'), b'this')
+        self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
+        self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
+        self.assertEqual(um.visitchildrenset(b'folder'), set())
         # OPT: These next two could be 'all' instead of 'this'.
-        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'this')
-        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'this')
+        self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this')
+        self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this')
 
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeInclude2(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir'])
-        m2 = matchmod.match('', '', include=['path:folder'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
+        m2 = matchmod.match(b'', b'', include=[b'path:folder'])
         um = matchmod.unionmatcher([m1, m2])
-        self.assertEqual(um.visitdir('.'), True)
-        self.assertEqual(um.visitdir('dir'), True)
-        self.assertEqual(um.visitdir('dir/subdir'), 'all')
-        self.assertFalse(um.visitdir('dir/foo'))
-        self.assertEqual(um.visitdir('folder'), 'all')
+        self.assertEqual(um.visitdir(b'.'), True)
+        self.assertEqual(um.visitdir(b'dir'), True)
+        self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
+        self.assertFalse(um.visitdir(b'dir/foo'))
+        self.assertEqual(um.visitdir(b'folder'), b'all')
         # OPT: These should probably be 'all' not True.
-        self.assertEqual(um.visitdir('dir/subdir/z'), True)
-        self.assertEqual(um.visitdir('dir/subdir/x'), True)
+        self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
+        self.assertEqual(um.visitdir(b'dir/subdir/x'), True)
 
     def testVisitchildrensetIncludeInclude2(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir'])
-        m2 = matchmod.match('', '', include=['path:folder'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
+        m2 = matchmod.match(b'', b'', include=[b'path:folder'])
         um = matchmod.unionmatcher([m1, m2])
-        self.assertEqual(um.visitchildrenset('.'), {'folder', 'dir'})
-        self.assertEqual(um.visitchildrenset('dir'), {'subdir'})
-        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/foo'), set())
-        self.assertEqual(um.visitchildrenset('folder'), 'all')
+        self.assertEqual(um.visitchildrenset(b'.'), {b'folder', b'dir'})
+        self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
+        self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
+        self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
+        self.assertEqual(um.visitchildrenset(b'folder'), b'all')
         # OPT: These next two could be 'all' instead of 'this'.
-        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'this')
-        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'this')
+        self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this')
+        self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'this')
 
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeInclude3(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir/x'])
-        m2 = matchmod.match('', '', include=['path:dir/subdir'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
+        m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
         um = matchmod.unionmatcher([m1, m2])
-        self.assertEqual(um.visitdir('.'), True)
-        self.assertEqual(um.visitdir('dir'), True)
-        self.assertEqual(um.visitdir('dir/subdir'), 'all')
-        self.assertFalse(um.visitdir('dir/foo'))
-        self.assertFalse(um.visitdir('folder'))
-        self.assertEqual(um.visitdir('dir/subdir/x'), 'all')
+        self.assertEqual(um.visitdir(b'.'), True)
+        self.assertEqual(um.visitdir(b'dir'), True)
+        self.assertEqual(um.visitdir(b'dir/subdir'), b'all')
+        self.assertFalse(um.visitdir(b'dir/foo'))
+        self.assertFalse(um.visitdir(b'folder'))
+        self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
         # OPT: this should probably be 'all' not True.
-        self.assertEqual(um.visitdir('dir/subdir/z'), True)
+        self.assertEqual(um.visitdir(b'dir/subdir/z'), True)
 
     def testVisitchildrensetIncludeInclude3(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir/x'])
-        m2 = matchmod.match('', '', include=['path:dir/subdir'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
+        m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
         um = matchmod.unionmatcher([m1, m2])
-        self.assertEqual(um.visitchildrenset('.'), {'dir'})
-        self.assertEqual(um.visitchildrenset('dir'), {'subdir'})
-        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/foo'), set())
-        self.assertEqual(um.visitchildrenset('folder'), set())
-        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all')
+        self.assertEqual(um.visitchildrenset(b'.'), {b'dir'})
+        self.assertEqual(um.visitchildrenset(b'dir'), {b'subdir'})
+        self.assertEqual(um.visitchildrenset(b'dir/subdir'), b'all')
+        self.assertEqual(um.visitchildrenset(b'dir/foo'), set())
+        self.assertEqual(um.visitchildrenset(b'folder'), set())
+        self.assertEqual(um.visitchildrenset(b'dir/subdir/x'), b'all')
         # OPT: this should probably be 'all' not 'this'.
-        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'this')
+        self.assertEqual(um.visitchildrenset(b'dir/subdir/z'), b'this')
 
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeInclude4(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir/x'])
-        m2 = matchmod.match('', '', include=['path:dir/subdir/z'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
+        m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])
         um = matchmod.unionmatcher([m1, m2])
         # OPT: these next three could probably be False as well.
-        self.assertEqual(um.visitdir('.'), True)
-        self.assertEqual(um.visitdir('dir'), True)
-        self.assertEqual(um.visitdir('dir/subdir'), True)
-        self.assertFalse(um.visitdir('dir/foo'))
-        self.assertFalse(um.visitdir('folder'))
-        self.assertEqual(um.visitdir('dir/subdir/z'), 'all')
-        self.assertEqual(um.visitdir('dir/subdir/x'), 'all')
+        self.assertEqual(um.visitdir(b'.'), True)
+        self.assertEqual(um.visitdir(b'dir'), True)
+        self.assertEqual(um.visitdir(b'dir/subdir'), True)
+        self.assertFalse(um.visitdir(b'dir/foo'))
+        self.assertFalse(um.visitdir(b'folder'))
+        self.assertEqual(um.visitdir(b'dir/subdir/z'), b'all')
+        self.assertEqual(um.visitdir(b'dir/subdir/x'), b'all')
 
     def testVisitchildrensetIncludeInclude4(self):
-        m1 = matchmod.match('', '', include=['path:dir/subdir/x'])
-        m2 = matchmod.match('', '', include=['path:dir/subdir/z'])
+        m1 = matchmod.match(b'', b'', include=[b'path:dir/subdir/x'])
+        m2 = matchmod.match(b'', b'', include=[b'path:dir/subdir/z'])
         um = matchmod.unionmatcher([m1, m2])
-        self.assertEqual(um.visitchildrenset('.'), {'dir'})
-        self.assertEqual(um.visitchildrenset('dir'), {'subdir'})
-        self.assertEqual(um.visitchildrenset('dir/subdir'), {'x', 'z'})
-        self.assertEqual(um.visitchildrenset('dir/foo'), set())
-        self.assertEqual(um.visitchildrenset('folder'), set())
-        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all')
-        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all')
+        self.assertEqual(um.visitchildrenset(b'.'), {b'dir'})
+        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/foo'), 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/x'), b'all')
 
 class SubdirMatcherTests(unittest.TestCase):
 
     def testVisitdir(self):
-        m = matchmod.match('', '', include=['path:dir/subdir'])
-        sm = matchmod.subdirmatcher('dir', m)
+        m = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
+        sm = matchmod.subdirmatcher(b'dir', m)
 
-        self.assertEqual(sm.visitdir('.'), True)
-        self.assertEqual(sm.visitdir('subdir'), 'all')
+        self.assertEqual(sm.visitdir(b'.'), True)
+        self.assertEqual(sm.visitdir(b'subdir'), b'all')
         # OPT: These next two should probably be 'all' not True.
-        self.assertEqual(sm.visitdir('subdir/x'), True)
-        self.assertEqual(sm.visitdir('subdir/z'), True)
-        self.assertFalse(sm.visitdir('foo'))
+        self.assertEqual(sm.visitdir(b'subdir/x'), True)
+        self.assertEqual(sm.visitdir(b'subdir/z'), True)
+        self.assertFalse(sm.visitdir(b'foo'))
 
     def testVisitchildrenset(self):
-        m = matchmod.match('', '', include=['path:dir/subdir'])
-        sm = matchmod.subdirmatcher('dir', m)
+        m = matchmod.match(b'', b'', include=[b'path:dir/subdir'])
+        sm = matchmod.subdirmatcher(b'dir', m)
 
-        self.assertEqual(sm.visitchildrenset('.'), {'subdir'})
-        self.assertEqual(sm.visitchildrenset('subdir'), 'all')
+        self.assertEqual(sm.visitchildrenset(b'.'), {b'subdir'})
+        self.assertEqual(sm.visitchildrenset(b'subdir'), b'all')
         # OPT: These next two should probably be 'all' not 'this'.
-        self.assertEqual(sm.visitchildrenset('subdir/x'), 'this')
-        self.assertEqual(sm.visitchildrenset('subdir/z'), 'this')
-        self.assertEqual(sm.visitchildrenset('foo'), set())
+        self.assertEqual(sm.visitchildrenset(b'subdir/x'), b'this')
+        self.assertEqual(sm.visitchildrenset(b'subdir/z'), b'this')
+        self.assertEqual(sm.visitchildrenset(b'foo'), set())
 
 class PrefixdirMatcherTests(unittest.TestCase):
 
     def testVisitdir(self):
-        m = matchmod.match(util.localpath('root/d'), 'e/f',
-                ['../a.txt', 'b.txt'])
-        pm = matchmod.prefixdirmatcher('root', 'd/e/f', 'd', m)
+        m = matchmod.match(util.localpath(b'root/d'), b'e/f',
+                [b'../a.txt', b'b.txt'])
+        pm = matchmod.prefixdirmatcher(b'root', b'd/e/f', b'd', m)
 
         # `m` elides 'd' because it's part of the root, and the rest of the
         # patterns are relative.
-        self.assertEqual(bool(m('a.txt')), False)
-        self.assertEqual(bool(m('b.txt')), False)
-        self.assertEqual(bool(m('e/a.txt')), True)
-        self.assertEqual(bool(m('e/b.txt')), False)
-        self.assertEqual(bool(m('e/f/b.txt')), True)
+        self.assertEqual(bool(m(b'a.txt')), False)
+        self.assertEqual(bool(m(b'b.txt')), False)
+        self.assertEqual(bool(m(b'e/a.txt')), True)
+        self.assertEqual(bool(m(b'e/b.txt')), False)
+        self.assertEqual(bool(m(b'e/f/b.txt')), True)
 
         # The prefix matcher re-adds 'd' to the paths, so they need to be
         # specified when using the prefixdirmatcher.
-        self.assertEqual(bool(pm('a.txt')), False)
-        self.assertEqual(bool(pm('b.txt')), False)
-        self.assertEqual(bool(pm('d/e/a.txt')), True)
-        self.assertEqual(bool(pm('d/e/b.txt')), False)
-        self.assertEqual(bool(pm('d/e/f/b.txt')), True)
+        self.assertEqual(bool(pm(b'a.txt')), False)
+        self.assertEqual(bool(pm(b'b.txt')), False)
+        self.assertEqual(bool(pm(b'd/e/a.txt')), True)
+        self.assertEqual(bool(pm(b'd/e/b.txt')), False)
+        self.assertEqual(bool(pm(b'd/e/f/b.txt')), True)
 
-        self.assertEqual(m.visitdir('.'), True)
-        self.assertEqual(m.visitdir('e'), True)
-        self.assertEqual(m.visitdir('e/f'), True)
-        self.assertEqual(m.visitdir('e/f/g'), False)
+        self.assertEqual(m.visitdir(b'.'), True)
+        self.assertEqual(m.visitdir(b'e'), True)
+        self.assertEqual(m.visitdir(b'e/f'), True)
+        self.assertEqual(m.visitdir(b'e/f/g'), False)
 
-        self.assertEqual(pm.visitdir('.'), True)
-        self.assertEqual(pm.visitdir('d'), True)
-        self.assertEqual(pm.visitdir('d/e'), True)
-        self.assertEqual(pm.visitdir('d/e/f'), True)
-        self.assertEqual(pm.visitdir('d/e/f/g'), False)
+        self.assertEqual(pm.visitdir(b'.'), True)
+        self.assertEqual(pm.visitdir(b'd'), True)
+        self.assertEqual(pm.visitdir(b'd/e'), True)
+        self.assertEqual(pm.visitdir(b'd/e/f'), True)
+        self.assertEqual(pm.visitdir(b'd/e/f/g'), False)
 
     def testVisitchildrenset(self):
-        m = matchmod.match(util.localpath('root/d'), 'e/f',
-                ['../a.txt', 'b.txt'])
-        pm = matchmod.prefixdirmatcher('root', 'd/e/f', 'd', m)
+        m = matchmod.match(util.localpath(b'root/d'), b'e/f',
+                [b'../a.txt', b'b.txt'])
+        pm = matchmod.prefixdirmatcher(b'root', b'd/e/f', b'd', m)
 
         # OPT: visitchildrenset could possibly return {'e'} and {'f'} for these
         # next two, respectively; patternmatcher does not have this
         # optimization.
-        self.assertEqual(m.visitchildrenset('.'), 'this')
-        self.assertEqual(m.visitchildrenset('e'), 'this')
-        self.assertEqual(m.visitchildrenset('e/f'), 'this')
-        self.assertEqual(m.visitchildrenset('e/f/g'), set())
+        self.assertEqual(m.visitchildrenset(b'.'), b'this')
+        self.assertEqual(m.visitchildrenset(b'e'), b'this')
+        self.assertEqual(m.visitchildrenset(b'e/f'), b'this')
+        self.assertEqual(m.visitchildrenset(b'e/f/g'), set())
 
         # OPT: visitchildrenset could possibly return {'d'}, {'e'}, and {'f'}
         # for these next three, respectively; patternmatcher does not have this
         # optimization.
-        self.assertEqual(pm.visitchildrenset('.'), 'this')
-        self.assertEqual(pm.visitchildrenset('d'), 'this')
-        self.assertEqual(pm.visitchildrenset('d/e'), 'this')
-        self.assertEqual(pm.visitchildrenset('d/e/f'), 'this')
-        self.assertEqual(pm.visitchildrenset('d/e/f/g'), set())
+        self.assertEqual(pm.visitchildrenset(b'.'), b'this')
+        self.assertEqual(pm.visitchildrenset(b'd'), b'this')
+        self.assertEqual(pm.visitchildrenset(b'd/e'), b'this')
+        self.assertEqual(pm.visitchildrenset(b'd/e/f'), b'this')
+        self.assertEqual(pm.visitchildrenset(b'd/e/f/g'), set())
 
 if __name__ == '__main__':
     silenttestrunner.main(__name__)