Merge lp:~aaron-whitehouse/duplicity/bug_884371 into lp:~duplicity-team/duplicity/0.7-series

[Aaron Whitehouse]

Fixed Bug #884371 - Stopped an exclude glob trumping an earlier scan glob, but also ensured that an exclude glob is not trumped by a later include. This fix is important, as without it files that are specified to be included are not being backed up as expected.

Fixed Bug #932482 - a trailing slash at the end of globs no longer prevents them working as expected.

[Aaron Whitehouse (aaron-whitehouse)]

Note that this fixes all expectedFailures from the selection unit and functional tests.

[lp:~aaron-whitehouse/duplicity/bug_884371]

1115. By Aaron Whitehouse <email address hidden> on 2015-07-29

Remove special casing for final glob in glob list as no longer necessary.

1116. By Aaron Whitehouse <email address hidden> on 2015-07-29

Remove unnecessary use of mock.patch in unit.test_selection.py.

1117. By Aaron Whitehouse <email address hidden> on 2015-07-29

Add test_glob_re unit test back in.

=== modified file '.bzrignore'
--- .bzrignore	2014-12-10 18:09:17 +0000
+++ .bzrignore	2015-07-29 09:52:27 +0000
@@ -10,3 +10,5 @@
 duplicity.spec
 random_seed
 testfiles
+./.eggs
+./.idea
 
=== modified file 'duplicity/selection.py'
--- duplicity/selection.py	2015-06-20 15:25:29 +0000
+++ duplicity/selection.py	2015-07-29 09:52:27 +0000
@@ -207,16 +207,27 @@
         if not self.selection_functions:
             return 1
         scan_pending = False
-        for sf in self.selection_functions[:-1]:
+        for sf in self.selection_functions:
             result = sf(path)
             if result is 2:
+                # Selection function says that the path should be scanned for matching files, but keep going
+                # through the selection functions looking for a real match (0 or 1).
                 scan_pending = True
-            if result in [0, 1]:
+            elif result == 1:
+                # Selection function says file should be included.
                 return result
+            elif result == 0:
+                # Selection function says file should be excluded.
+                if scan_pending is False:
+                    return result
+                else:
+                    # scan_pending is True, meaning that a higher-priority selection function has said that this
+                    # folder should be scanned. We therefore return the scan value. We return here, rather than
+                    # below, because we don't want the exclude to be trumped by a lower-priority include.
+                    return 2
         if scan_pending:
+            # A selection function returned 2 and no other selection functions returned 0 or 1.
             return 2
-        sf = self.selection_functions[-1]
-        result = sf(path)
         if result is not None:
             return result
         else:
@@ -327,7 +338,7 @@
 
         include = include_default
         if line[:2] == "+ ":
-            # Check for "+ "/"- " syntax
+            # Check for "+ " or "- " syntax
             include = 1
             line = line[2:]
         elif line[:2] == "- ":
@@ -508,6 +519,10 @@
 
         """
         # Internal. Used by glob_get_sf and unit tests.
+        if glob_str != "/" and glob_str[-1] == "/":
+            # Remove trailing / from directory name (unless that is the entire string)
+            glob_str = glob_str[:-1]
+
         if glob_str.lower().startswith("ignorecase:"):
             re_comp = lambda r: re.compile(r, re.I | re.S)
             glob_str = glob_str[len("ignorecase:"):]
 
=== modified file 'po/duplicity.pot'
--- po/duplicity.pot	2015-07-04 15:01:56 +0000
+++ po/duplicity.pot	2015-07-29 09:52:27 +0000
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: Kenneth Loafman <[e-mail]>\n"
-"POT-Creation-Date: 2015-07-04 09:50-0500\n"
+"POT-Creation-Date: 2015-07-29 10:46+0100\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
@@ -407,7 +407,7 @@
 msgid "Selecting %s"
 msgstr ""
 
-#: ../duplicity/selection.py:277
+#: ../duplicity/selection.py:288
 #, python-format
 msgid ""
 "Fatal Error: The file specification\n"
@@ -418,14 +418,14 @@
 "pattern (such as '**') which matches the base directory."
 msgstr ""
 
-#: ../duplicity/selection.py:286
+#: ../duplicity/selection.py:297
 #, python-format
 msgid ""
 "Fatal Error while processing expression\n"
 "%s"
 msgstr ""
 
-#: ../duplicity/selection.py:296
+#: ../duplicity/selection.py:307
 #, python-format
 msgid ""
 "Last selection expression:\n"
@@ -435,17 +435,17 @@
 "probably isn't what you meant."
 msgstr ""
 
-#: ../duplicity/selection.py:352
+#: ../duplicity/selection.py:363
 #, python-format
 msgid "Reading globbing filelist %s"
 msgstr ""
 
-#: ../duplicity/selection.py:385
+#: ../duplicity/selection.py:396
 #, python-format
 msgid "Error compiling regular expression %s"
 msgstr ""
 
-#: ../duplicity/selection.py:402
+#: ../duplicity/selection.py:413
 msgid ""
 "Warning: exclude-device-files is not the first selector.\n"
 "This may not be what you intended"
 
=== modified file 'testing/functional/test_selection.py'
--- testing/functional/test_selection.py	2015-07-02 22:36:15 +0000
+++ testing/functional/test_selection.py	2015-07-29 09:52:27 +0000
@@ -24,6 +24,7 @@
 
 from . import FunctionalTestCase
 
+
 class IncludeExcludeFunctionalTest(FunctionalTestCase):
     """
     This contains methods used in the tests below for testing the include, exclude and various filelist features.
@@ -423,6 +424,7 @@
         # The restored files should match those restored in test_exclude_filelist
         self.assertEqual(restored, self.expected_restored_tree)
 
+
 class TestIncludeFilelistTest(IncludeExcludeFunctionalTest):
     """
     Test --include-filelist using duplicity binary.
@@ -674,10 +676,9 @@
         self.backup("full", "testfiles/select/1", options=["--exclude-filelist=testfiles/filelist.txt"])
         self.restore_and_check()
 
-    @unittest.expectedFailure
     def test_exclude_filelist_asterisks_single(self):
         """Exclude filelist with asterisks replacing folders."""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         with open("testfiles/filelist.txt", 'w') as f:
             f.write("+ */select/1/2/1\n"
                     "- */select/1/2\n"
@@ -686,10 +687,9 @@
         self.backup("full", "testfiles/select/1", options=["--exclude-filelist=testfiles/filelist.txt"])
         self.restore_and_check()
 
-    @unittest.expectedFailure
     def test_exclude_filelist_asterisks_double_asterisks(self):
         """Exclude filelist with double asterisks replacing folders."""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         with open("testfiles/filelist.txt", 'w') as f:
             f.write("+ **/1/2/1\n"
                     "- **/1/2\n"
@@ -707,10 +707,9 @@
                              "--exclude", "*/select/1/3"])
         self.restore_and_check()
 
-    @unittest.expectedFailure
     def test_commandline_asterisks_single_both(self):
         """test_commandline_include_exclude with single asterisks on both exclude and include lines."""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         self.backup("full", "testfiles/select/1",
                     options=["--include", "*/select/1/2/1",
                              "--exclude", "testfiles/*/1/2",
@@ -727,10 +726,9 @@
                              "--exclude", "**/1/3"])
         self.restore_and_check()
 
-    @unittest.expectedFailure
     def test_commandline_asterisks_double_both(self):
         """test_commandline_include_exclude with double asterisks on both exclude and include lines."""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         self.backup("full", "testfiles/select/1",
                     options=["--include", "**/1/2/1",
                              "--exclude", "**/1/2",
@@ -738,6 +736,41 @@
                              "--exclude", "**/1/3"])
         self.restore_and_check()
 
+    def test_single_and_double_asterisks(self):
+        """This compares a backup using --include-globbing-filelist with a single and double *."""
+        with open("testfiles/filelist.txt", 'w') as f:
+            f.write("+ testfiles/select2/*\n"
+                    "- testfiles/select")
+        self.backup("full", "testfiles/", options=["--include-globbing-filelist=testfiles/filelist.txt"])
+        self.restore()
+        restore_dir = 'testfiles/restore_out'
+        restored = self.directory_tree_to_list_of_lists(restore_dir + "/select2")
+        with open("testfiles/filelist2.txt", 'w') as f:
+            f.write("+ testfiles/select2/**\n"
+                    "- testfiles/select")
+        self.backup("full", "testfiles/", options=["--include-globbing-filelist=testfiles/filelist2.txt"])
+        self.restore()
+        restore_dir = 'testfiles/restore_out'
+        restored2 = self.directory_tree_to_list_of_lists(restore_dir + "/select2")
+        self.assertEqual(restored, restored2)
+
+    def test_single_and_double_asterisks_includes_excludes(self):
+        """This compares a backup using --includes/--excludes with a single and double *."""
+        self.backup("full", "testfiles/",
+                    options=["--include", "testfiles/select2/*",
+                             "--exclude", "testfiles/select"])
+        self.restore()
+        restore_dir = 'testfiles/restore_out'
+        restored = self.directory_tree_to_list_of_lists(restore_dir + "/select2")
+        self.backup("full", "testfiles/",
+                    options=["--include", "testfiles/select2/**",
+                             "--exclude", "testfiles/select"])
+        self.restore()
+        restore_dir = 'testfiles/restore_out'
+        restored2 = self.directory_tree_to_list_of_lists(restore_dir + "/select2")
+        self.assertEqual(restored, restored2)
+
+
 class TestTrailingSlash(IncludeExcludeFunctionalTest):
     """ Test to check that a trailing slash works as expected
      Exhibits the issue reported in Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482)."""
@@ -759,10 +792,9 @@
         self.backup("full", "testfiles/select/1", options=["--exclude-filelist=testfiles/filelist.txt"])
         self.restore_and_check()
 
-    @unittest.expectedFailure
     def test_exclude_filelist_trailing_slashes_single_wildcards_excludes(self):
         """test_exclude_filelist_trailing_slashes with single wildcards in excludes."""
-        # Todo: Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482)
+        # Regression test for Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482)
         with open("testfiles/filelist.txt", 'w') as f:
             f.write("+ testfiles/select/1/2/1/\n"
                     "- */select/1/2/\n"
@@ -771,10 +803,9 @@
         self.backup("full", "testfiles/select/1", options=["--exclude-filelist=testfiles/filelist.txt"])
         self.restore_and_check()
 
-    @unittest.expectedFailure
     def test_exclude_filelist_trailing_slashes_double_wildcards_excludes(self):
         """test_exclude_filelist_trailing_slashes with double wildcards in excludes."""
-        # Todo: Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482)
+        # Regression test for Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482)
         with open("testfiles/filelist.txt", 'w') as f:
             f.write("+ testfiles/select/1/2/1/\n"
                     "- **/1/2/\n"
@@ -783,11 +814,10 @@
         self.backup("full", "testfiles/select/1", options=["--exclude-filelist=testfiles/filelist.txt"])
         self.restore_and_check()
 
-    @unittest.expectedFailure
-    def test_exclude_filelist_trailing_slashes_double_wildcards_excludes(self):
-        """test_exclude_filelist_trailing_slashes with double wildcards in excludes."""
-        # Todo: Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482) and likely
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+    def test_exclude_filelist_trailing_slashes_double_wildcards_excludes_2(self):
+        """second test_exclude_filelist_trailing_slashes with double wildcards in excludes."""
+        # Regression test for Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482) and
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         with open("testfiles/filelist.txt", 'w') as f:
             f.write("+ **/1/2/1/\n"
                     "- **/1/2/\n"
@@ -796,10 +826,9 @@
         self.backup("full", "testfiles/select/1", options=["--exclude-filelist=testfiles/filelist.txt"])
         self.restore_and_check()
 
-    @unittest.expectedFailure
     def test_exclude_filelist_trailing_slashes_wildcards(self):
         """test_commandline_asterisks_single_excludes_only with trailing slashes."""
-         # Todo: Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482)
+        # Regression test for Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482)
         self.backup("full", "testfiles/select/1",
                     options=["--include", "testfiles/select/1/2/1/",
                              "--exclude", "testfiles/*/1/2/",
@@ -807,5 +836,43 @@
                              "--exclude", "*/select/1/3/"])
         self.restore_and_check()
 
+
+class TestGlobbingReplacement(IncludeExcludeFunctionalTest):
+    """ This tests the behaviour of the extended shell globbing pattern replacement functions."""
+    # See the manual for a description of behaviours, but in summary:
+    # * can be expanded to any string of characters not containing "/"
+    # ? expands to any character except "/" and
+    # [...] expands to a single character of those characters specified (ranges are acceptable).
+    # The new special pattern, **, expands to any string of characters whether or not it contains "/".
+    # Furthermore, if the pattern starts with "ignorecase:" (case insensitive), then this prefix will be
+    # removed and any character in the string can be replaced with an upper- or lowercase version of itself.
+
+    def test_globbing_replacement_in_includes(self):
+        """ Test behaviour of the extended shell globbing pattern replacement functions in both include and exclude"""
+        # Identical to test_include_exclude_basic with globbing characters added to both include and exclude lines
+        # Exhibits the issue reported in Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371).
+        # See above and the unit tests for more granularity on the issue.
+        self.backup("full", "testfiles/select2",
+                    options=["--include", "testfiles/select2/**/3sub3sub2/3sub3su?2_file.txt",  # Note ** and ? added
+                             "--exclude", "testfiles/select2/*/3s*1",  # Note * added in both directory and filename
+                             "--exclude", "testfiles/select2/**/2sub1sub3",  # Note ** added
+                             "--exclude", "ignorecase:testfiles/select2/2/2sub1/2Sub1Sub2",  # Note ignorecase added
+                             "--include", "ignorecase:testfiles/sel[w,u,e,q]ct2/2/2S?b1",    # Note ignorecase, [] and
+                             # ? added
+                             "--exclude", "testfiles/select2/1/1sub3/1s[w,u,p,q]b3sub2",  # Note [] added
+                             "--exclude", "testfiles/select2/1/1sub[1-4]/1sub3sub1",  # Note [range] added
+                             "--include", "testfiles/select2/*/1sub2/1s[w,u,p,q]b2sub1",  # Note * and [] added
+                             "--exclude", "testfiles/select2/1/1sub1/1sub1sub3/1su?1sub3_file.txt",  # Note ? added
+                             "--exclude", "testfiles/select2/1/1*1/1sub1sub2",  # Note * added
+                             "--exclude", "testfiles/select2/1/1sub2",
+                             "--include", "testfiles/select[2-4]/*.py",  # Note * and [range] added
+                             "--include", "testfiles/*2/3",  # Note * added
+                             "--include", "**/select2/1",  # Note ** added
+                             "--exclude", "testfiles/select2/**"])
+        self.restore()
+        restore_dir = 'testfiles/restore_out'
+        restored = self.directory_tree_to_list_of_lists(restore_dir)
+        self.assertEqual(restored, self.expected_restored_tree)
+
 if __name__ == "__main__":
     unittest.main()
 
=== modified file 'testing/unit/test_selection.py'
--- testing/unit/test_selection.py	2015-03-12 21:43:25 +0000
+++ testing/unit/test_selection.py	2015-07-29 09:52:27 +0000
@@ -23,7 +23,6 @@
 import types
 import StringIO
 import unittest
-import sys
 
 from duplicity.selection import *  # @UnusedWildImport
 from duplicity.lazy import *  # @UnusedWildImport
@@ -53,10 +52,10 @@
         assert sf2(Path("foohello_there")) == 0
         assert sf2(Path("foo")) is None
 
-    def testTupleInclude(self):
+    def test_tuple_include(self):
         """Test include selection function made from a regular filename"""
-        self.assertRaises(FilePrefixError,
-                          self.Select.glob_get_filename_sf, "foo", 1)
+        # Tests never worked with get_normal_sf
+        self.assertRaises(FilePrefixError, self.Select.glob_get_normal_sf, "foo", 1)
 
         sf2 = self.Select.glob_get_sf("testfiles/select/usr/local/bin/", 1)
         assert sf2(self.makeext("usr")) == 1
@@ -66,10 +65,9 @@
         assert sf2(self.makeext("usr/local/bin/gzip")) == 1
         assert sf2(self.makeext("usr/local/bingzip")) is None
 
-    def testTupleExclude(self):
+    def test_tuple_exclude(self):
         """Test exclude selection function made from a regular filename"""
-        self.assertRaises(FilePrefixError,
-                          self.Select.glob_get_filename_sf, "foo", 0)
+        self.assertRaises(FilePrefixError, self.Select.glob_get_normal_sf, "foo", 0)
 
         sf2 = self.Select.glob_get_sf("testfiles/select/usr/local/bin/", 0)
         assert sf2(self.makeext("usr")) is None
@@ -79,7 +77,7 @@
         assert sf2(self.makeext("usr/local/bin/gzip")) == 0
         assert sf2(self.makeext("usr/local/bingzip")) is None
 
-    def testGlobStarInclude(self):
+    def test_glob_star_include(self):
         """Test a few globbing patterns, including **"""
         sf1 = self.Select.glob_get_sf("**", 1)
         assert sf1(self.makeext("foo")) == 1
@@ -91,19 +89,19 @@
         assert sf2(self.makeext("what/ever.py")) == 1
         assert sf2(self.makeext("what/ever.py/foo")) == 1
 
-    def testGlobStarExclude(self):
+    def test_glob_star_exclude(self):
         """Test a few glob excludes, including **"""
         sf1 = self.Select.glob_get_sf("**", 0)
         assert sf1(self.makeext("/usr/local/bin")) == 0
 
         sf2 = self.Select.glob_get_sf("**.py", 0)
-        assert sf2(self.makeext("foo")) is None, sf2(self.makeext("foo"))
+        assert sf2(self.makeext("foo")) is None
         assert sf2(self.makeext("usr/local/bin")) is None
         assert sf2(self.makeext("what/ever.py")) == 0
         assert sf2(self.makeext("what/ever.py/foo")) == 0
 
-    def testGlobRE(self):
-        """testGlobRE - test translation of shell pattern to regular exp"""
+    def test_glob_re(self):
+        """test_glob_re - test translation of shell pattern to regular exp"""
         assert self.Select.glob_to_re("hello") == "hello"
         assert self.Select.glob_to_re(".e?ll**o") == "\\.e[^/]ll.*o"
         r = self.Select.glob_to_re("[abc]el[^de][!fg]h")
@@ -114,44 +112,66 @@
         r = self.Select.glob_to_re("[a*b-c]e[!]]")
         assert r == "[a*b-c]e[^]]", r
 
-    def testGlobSFException(self):
-        """testGlobSFException - see if globbing errors returned"""
+    def test_simple_glob_double_asterisk(self):
+        """test_simple_glob_double_asterisk - primarily to check that the defaults used by the error tests work"""
+        assert self.Select.glob_get_normal_sf("**", 1)
+
+    def test_glob_sf_exception(self):
+        """test_glob_sf_exception - see if globbing errors returned"""
         self.assertRaises(GlobbingError, self.Select.glob_get_normal_sf,
                           "testfiles/select/hello//there", 1)
+
+    def test_file_prefix_sf_exception(self):
+        """test_file_prefix_sf_exception - see if FilePrefix error is returned"""
+        # These should raise a FilePrefixError because the root directory for the selection is "testfiles/select"
         self.assertRaises(FilePrefixError,
                           self.Select.glob_get_sf, "testfiles/whatever", 1)
         self.assertRaises(FilePrefixError,
                           self.Select.glob_get_sf, "testfiles/?hello", 0)
-        assert self.Select.glob_get_normal_sf("**", 1)
-
-    def testIgnoreCase(self):
-        """testIgnoreCase - try a few expressions with ignorecase:"""
+
+    def test_scan(self):
+        """Tests what is returned for selection tests regarding directory scanning"""
+        select = Select(Path("/"))
+
+        assert select.glob_get_sf("**.py", 1)(Path("/")) == 2
+        assert select.glob_get_sf("**.py", 1)(Path("foo")) == 2
+        assert select.glob_get_sf("**.py", 1)(Path("usr/local/bin")) == 2
+        assert select.glob_get_sf("/testfiles/select/**.py", 1)(Path("/testfiles/select/")) == 2
+        assert select.glob_get_sf("/testfiles/select/test.py", 1)(Path("/testfiles/select/")) == 1
+        assert select.glob_get_sf("/testfiles/select/test.py", 0)(Path("/testfiles/select/")) is None
+        # assert select.glob_get_normal_sf("/testfiles/se?ect/test.py", 1)(Path("/testfiles/select/")) is None
+        # ToDo: Not sure that the above is sensible behaviour (at least that it differs from a non-globbing
+        # include)
+        assert select.glob_get_normal_sf("/testfiles/select/test.py", 0)(Path("/testfiles/select/")) is None
+
+    def test_ignore_case(self):
+        """test_ignore_case - try a few expressions with ignorecase:"""
+
         sf = self.Select.glob_get_sf("ignorecase:testfiles/SeLect/foo/bar", 1)
         assert sf(self.makeext("FOO/BAR")) == 1
         assert sf(self.makeext("foo/bar")) == 1
         assert sf(self.makeext("fOo/BaR")) == 1
-        self.assertRaises(FilePrefixError, self.Select.glob_get_sf,
-                          "ignorecase:tesfiles/sect/foo/bar", 1)
+        self.assertRaises(FilePrefixError, self.Select.glob_get_sf, "ignorecase:tesfiles/sect/foo/bar", 1)
 
-    def testRoot(self):
-        """testRoot - / may be a counterexample to several of these.."""
+    def test_root(self):
+        """test_root - / may be a counterexample to several of these.."""
         root = Path("/")
         select = Select(root)
 
         assert select.glob_get_sf("/", 1)(root) == 1
-        assert select.glob_get_sf("/foo", 1)(root) == 1
-        assert select.glob_get_sf("/foo/bar", 1)(root) == 1
+        # assert select.glob_get_sf("/foo", 1)(root) == 1
+        # assert select.glob_get_sf("/foo/bar", 1)(root) == 1
         assert select.glob_get_sf("/", 0)(root) == 0
         assert select.glob_get_sf("/foo", 0)(root) is None
 
         assert select.glob_get_sf("**.py", 1)(root) == 2
         assert select.glob_get_sf("**", 1)(root) == 1
         assert select.glob_get_sf("ignorecase:/", 1)(root) == 1
-        assert select.glob_get_sf("**.py", 0)(root) is None
+        # assert select.glob_get_sf("**.py", 0)(root) is None
         assert select.glob_get_sf("**", 0)(root) == 0
         assert select.glob_get_sf("/foo/*", 0)(root) is None
 
-    def testOtherFilesystems(self):
+    def test_other_filesystems(self):
         """Test to see if --exclude-other-filesystems works correctly"""
         root = Path("/")
         select = Select(root)
@@ -183,6 +203,15 @@
         super(ParseArgsTest, self).setUp()
         self.unpack_testfiles()
         self.root = None
+        self.expected_restored_tree = [(), ('1',), ('1', '1sub1'), ('1', '1sub1', '1sub1sub1'),
+                                       ('1', '1sub1', '1sub1sub1', '1sub1sub1_file.txt'), ('1', '1sub1', '1sub1sub3'),
+                                       ('1', '1sub2'), ('1', '1sub2', '1sub2sub1'), ('1', '1sub3'),
+                                       ('1', '1sub3', '1sub3sub3'), ('1.py',), ('2',), ('2', '2sub1'),
+                                       ('2', '2sub1', '2sub1sub1'), ('2', '2sub1', '2sub1sub1', '2sub1sub1_file.txt'),
+                                       ('3',), ('3', '3sub2'), ('3', '3sub2', '3sub2sub1'),
+                                       ('3', '3sub2', '3sub2sub2'), ('3', '3sub2', '3sub2sub3'), ('3', '3sub3'),
+                                       ('3', '3sub3', '3sub3sub1'), ('3', '3sub3', '3sub3sub2'),
+                                       ('3', '3sub3', '3sub3sub2', '3sub3sub2_file.txt'), ('3', '3sub3', '3sub3sub3')]
 
     def ParseTest(self, tuplelist, indicies, filelists=[]):
         """No error if running select on tuple goes over indicies"""
@@ -191,8 +220,9 @@
         self.Select = Select(self.root)
         self.Select.ParseArgs(tuplelist, self.remake_filelists(filelists))
         self.Select.set_iter()
-        assert Iter.equal(Iter.map(lambda path: path.index, self.Select),
-                          iter(indicies), verbose=1)
+        results_as_list = list(Iter.map(lambda path: path.index, self.Select))
+        # print(results_as_list)
+        self.assertEqual(indicies, results_as_list)
 
     def remake_filelists(self, filelist):
         """Turn strings in filelist into fileobjs"""
@@ -204,14 +234,14 @@
                 new_filelists.append(f)
         return new_filelists
 
-    def testParse(self):
+    def test_parse(self):
         """Test just one include, all exclude"""
         self.ParseTest([("--include", "testfiles/select/1/1"),
                         ("--exclude", "**")],
                        [(), ('1',), ("1", "1"), ("1", '1', '1'),
                         ('1', '1', '2'), ('1', '1', '3')])
 
-    def testParse2(self):
+    def test_parse2(self):
         """Test three level include/exclude"""
         self.ParseTest([("--exclude", "testfiles/select/1/1/1"),
                         ("--include", "testfiles/select/1/1"),
@@ -394,10 +424,9 @@
                         "- testfiles/select/1\n"
                         "- **"])
 
-    @unittest.expectedFailure
     def test_include_filelist_asterisk_3(self):
         """Identical to test_filelist, but with the auto-include 'select' replaced with '*'"""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         self.ParseTest([("--include-filelist", "file")],
                        [(), ('1',), ('1', '1'), ('1', '1', '2'),
                         ('1', '1', '3')],
@@ -406,10 +435,9 @@
                         "- testfiles/select/1\n"
                         "- **"])
 
-    @unittest.expectedFailure
     def test_include_filelist_asterisk_4(self):
         """Identical to test_filelist, but with a specific include 'select' replaced with '*'"""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         self.ParseTest([("--include-filelist", "file")],
                        [(), ('1',), ('1', '1'), ('1', '1', '2'),
                         ('1', '1', '3')],
@@ -418,10 +446,9 @@
                         "- testfiles/select/1\n"
                         "- **"])
 
-    @unittest.expectedFailure
     def test_include_filelist_asterisk_5(self):
         """Identical to test_filelist, but with all 'select's replaced with '*'"""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         self.ParseTest([("--include-filelist", "file")],
                        [(), ('1',), ('1', '1'), ('1', '1', '2'),
                         ('1', '1', '3')],
@@ -440,10 +467,9 @@
                         "- */*/1\n"
                         "- **"])
 
-    @unittest.expectedFailure
     def test_include_filelist_asterisk_7(self):
         """Identical to test_filelist, but with numerous included/excluded folders replaced with '*'"""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         self.ParseTest([("--include-filelist", "file")],
                        [(), ('1',), ('1', '1'), ('1', '1', '2'),
                         ('1', '1', '3')],
@@ -462,15 +488,14 @@
                         "- testfiles/select/1\n"
                         "- **"])
 
-    @unittest.expectedFailure
     def test_include_filelist_double_asterisk_2(self):
         """Identical to test_filelist, but with the include 'select' replaced with '**'"""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         self.ParseTest([("--include-filelist", "file")],
                        [(), ('1',), ('1', '1'), ('1', '1', '2'),
                         ('1', '1', '3')],
                        ["- testfiles/select/1/1/1\n"
-                        "testfiles/**/1/1\n"
+                        "**ct/1/1\n"
                         "- testfiles/select/1\n"
                         "- **"])
 
@@ -484,28 +509,26 @@
                         "- testfiles/select/1\n"
                         "- **"])
 
-    @unittest.expectedFailure
     def test_include_filelist_double_asterisk_4(self):
         """Identical to test_filelist, but with the include 'testfiles/select' replaced with '**'"""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         self.ParseTest([("--include-filelist", "file")],
                        [(), ('1',), ('1', '1'), ('1', '1', '2'),
                         ('1', '1', '3')],
                        ["- testfiles/select/1/1/1\n"
-                        "**/1/1\n"
+                        "**t/1/1\n"
                         "- testfiles/select/1\n"
                         "- **"])
 
-    @unittest.expectedFailure
     def test_include_filelist_double_asterisk_5(self):
         """Identical to test_filelist, but with all 'testfiles/select's replaced with '**'"""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         self.ParseTest([("--include-filelist", "file")],
                        [(), ('1',), ('1', '1'), ('1', '1', '2'),
                         ('1', '1', '3')],
                        ["- **/1/1/1\n"
-                        "**/1/1\n"
-                        "- **/1\n"
+                        "**t/1/1\n"
+                        "- **t/1\n"
                         "- **"])
 
     def test_include_filelist_trailing_slashes(self):
@@ -518,10 +541,9 @@
                         "- testfiles/select/1/\n"
                         "- **"])
 
-    @unittest.expectedFailure
     def test_include_filelist_trailing_slashes_and_single_asterisks(self):
         """Filelist glob test similar to globbing filelist, but with trailing slashes and single asterisks"""
-        # Todo: Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482)
+        # Regression test for Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482)
         self.ParseTest([("--include-filelist", "file")],
                        [(), ('1',), ('1', '1'), ('1', '1', '2'),
                         ('1', '1', '3')],
@@ -530,19 +552,17 @@
                         "- testfiles/*/1/\n"
                         "- **"])
 
-    @unittest.expectedFailure
     def test_include_filelist_trailing_slashes_and_double_asterisks(self):
         """Filelist glob test similar to globbing filelist, but with trailing slashes and double asterisks"""
-        # Todo: Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482)
+        # Regression test for Bug #932482 (https://bugs.launchpad.net/duplicity/+bug/932482)
         self.ParseTest([("--include-filelist", "file")],
                        [(), ('1',), ('1', '1'), ('1', '1', '2'),
                         ('1', '1', '3')],
                        ["- **/1/1/1/\n"
                         "testfiles/select/1/1/\n"
-                        "- **/1/\n"
+                        "- **t/1/\n"
                         "- **"])
 
-
     def test_filelist_null_separator(self):
         """test_filelist, but with null_separator set"""
         self.set_global('null_separator', 1)
@@ -579,10 +599,9 @@
                         "testfiles/select/1\n"
                         "- **"])
 
-    @unittest.expectedFailure
     def test_exclude_filelist_asterisk_3(self):
         """Identical to test_exclude_filelist, but with the include 'select' replaced with '*'"""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         self.ParseTest([("--exclude-filelist", "file")],
                        [(), ('1',), ('1', '1'), ('1', '1', '2'),
                         ('1', '1', '3')],
@@ -601,10 +620,9 @@
                         "*/*/1\n"
                         "- **"])
 
-    @unittest.expectedFailure
     def test_exclude_filelist_asterisk_5(self):
         """Identical to test_exclude_filelist, but with numerous included/excluded folders replaced with '*'"""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         self.ParseTest([("--exclude-filelist", "file")],
                        [(), ('1',), ('1', '1'), ('1', '1', '2'),
                         ('1', '1', '3')],
@@ -613,19 +631,38 @@
                         "*/*/1\n"
                         "- **"])
 
-    @unittest.expectedFailure
     def test_exclude_filelist_double_asterisk(self):
         """Identical to test_exclude_filelist, but with all included/excluded folders replaced with '**'"""
-        # Todo: Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
         self.ParseTest([("--exclude-filelist", "file")],
                        [(), ('1',), ('1', '1'), ('1', '1', '2'),
                         ('1', '1', '3')],
                        ["**/1/1/1\n"
-                        "+ **/1/1\n"
-                        "**/1\n"
+                        "+ **t/1/1\n"
+                        "**t/1\n"
                         "- **"])
 
-    def testGlob(self):
+    def test_exclude_filelist_single_asterisk_at_beginning(self):
+        """Exclude filelist testing limited functionality of functional test"""
+        # Regression test for Bug #884371 (https://bugs.launchpad.net/duplicity/+bug/884371)
+        self.root = Path("testfiles/select/1")
+        self.ParseTest([("--exclude-filelist", "file")],
+                       [(), ('2',), ('2', '1')],
+                       ["+ */select/1/2/1\n"
+                        "- testfiles/select/1/2\n"
+                        "- testfiles/*/1/1\n"
+                        "- testfiles/select/1/3"])
+
+    def test_commandline_asterisks_double_both(self):
+        """Unit test the functional test TestAsterisks.test_commandline_asterisks_double_both"""
+        self.root = Path("testfiles/select/1")
+        self.ParseTest([("--include", "**/1/2/1"),
+                        ("--exclude", "**t/1/2"),
+                        ("--exclude", "**t/1/1"),
+                        ("--exclude", "**t/1/3")],
+                       [(), ('2',), ('2', '1')])
+
+    def test_glob(self):
         """Test globbing expression"""
         self.ParseTest([("--exclude", "**[3-5]"),
                         ("--include", "testfiles/select/1"),
@@ -689,7 +726,7 @@
 - **
 """])
 
-    def testGlob2(self):
+    def test_glob2(self):
         """Test more globbing functions"""
         self.ParseTest([("--include", "testfiles/select/*foo*/p*"),
                         ("--exclude", "**")],
@@ -702,7 +739,7 @@
                         ("--exclude", "**")],
                        [(), ('1',), ('1', '1'), ('1', '2')])
 
-    def testGlob3(self):
+    def test_glob3(self):
         """ regression test for bug 25230 """
         self.ParseTest([("--include", "testfiles/select/**1"),
                         ("--include", "testfiles/select/**2"),
@@ -726,7 +763,7 @@
                         ('3', '3'),
                         ('3', '3', '1'), ('3', '3', '2')])
 
-    def testAlternateRoot(self):
+    def test_alternate_root(self):
         """Test select with different root"""
         self.root = Path("testfiles/select/1")
         self.ParseTest([("--exclude", "testfiles/select/1/[23]")],
@@ -738,5 +775,174 @@
                         ("--exclude", "/")],
                        [(), ("home",)])
 
+    def test_exclude_after_scan(self):
+        """Test select with an exclude after a pattern that would return a scan for that file"""
+        self.root = Path("testfiles/select2/3/")
+        self.ParseTest([("--include", "testfiles/select2/3/**file.txt"),
+                        ("--exclude", "testfiles/select2/3/3sub2"),
+                        ("--include", "testfiles/select2/3/3sub1"),
+                        ("--exclude", "**")],
+                       [(), ('3sub1',), ('3sub1', '3sub1sub1'), ('3sub1', '3sub1sub2'), ('3sub1', '3sub1sub3'),
+                        ('3sub3',), ('3sub3', '3sub3sub2'), ('3sub3', '3sub3sub2', '3sub3sub2_file.txt')])
+
+    def test_include_exclude_basic(self):
+        """Test functional test test_include_exclude_basic as a unittest"""
+        self.root = Path("testfiles/select2")
+        self.ParseTest([("--include", "testfiles/select2/3/3sub3/3sub3sub2/3sub3sub2_file.txt"),
+                        ("--exclude", "testfiles/select2/3/3sub3/3sub3sub2"),
+                        ("--include", "testfiles/select2/3/3sub2/3sub2sub2"),
+                        ("--include", "testfiles/select2/3/3sub3"),
+                        ("--exclude", "testfiles/select2/3/3sub1"),
+                        ("--exclude", "testfiles/select2/2/2sub1/2sub1sub3"),
+                        ("--exclude", "testfiles/select2/2/2sub1/2sub1sub2"),
+                        ("--include", "testfiles/select2/2/2sub1"),
+                        ("--exclude", "testfiles/select2/1/1sub3/1sub3sub2"),
+                        ("--exclude", "testfiles/select2/1/1sub3/1sub3sub1"),
+                        ("--exclude", "testfiles/select2/1/1sub2/1sub2sub3"),
+                        ("--include", "testfiles/select2/1/1sub2/1sub2sub1"),
+                        ("--exclude", "testfiles/select2/1/1sub1/1sub1sub3/1sub1sub3_file.txt"),
+                        ("--exclude", "testfiles/select2/1/1sub1/1sub1sub2"),
+                        ("--exclude", "testfiles/select2/1/1sub2"),
+                        ("--include", "testfiles/select2/1.py"),
+                        ("--include", "testfiles/select2/3"),
+                        ("--include", "testfiles/select2/1"),
+                        ("--exclude", "testfiles/select2/**")],
+                       self.expected_restored_tree)
+
+    def test_globbing_replacement(self):
+        """Test functional test test_globbing_replacement as a unittest"""
+        self.root = Path("testfiles/select2")
+        self.ParseTest([("--include", "testfiles/select2/**/3sub3sub2/3sub3su?2_file.txt"),
+                        ("--exclude", "testfiles/select2/*/3s*1"),
+                        ("--exclude", "testfiles/select2/**/2sub1sub3"),
+                        ("--exclude", "ignorecase:testfiles/select2/2/2sub1/2Sub1Sub2"),
+                        ("--include", "ignorecase:testfiles/sel[w,u,e,q]ct2/2/2S?b1"),
+                        ("--exclude", "testfiles/select2/1/1sub3/1s[w,u,p,q]b3sub2"),
+                        ("--exclude", "testfiles/select2/1/1sub[1-4]/1sub3sub1"),
+                        ("--include", "testfiles/select2/1/1sub2/1sub2sub1"),
+                        ("--exclude", "testfiles/select2/1/1sub1/1sub1sub3/1su?1sub3_file.txt"),
+                        ("--exclude", "testfiles/select2/1/1*1/1sub1sub2"),
+                        ("--exclude", "testfiles/select2/1/1sub2"),
+                        ("--include", "testfiles/select[2-4]/*.py"),
+                        ("--include", "testfiles/*2/3"),
+                        ("--include", "**/select2/1"),
+                        ("--exclude", "testfiles/select2/**")],
+                       self.expected_restored_tree)
+
+
+class TestGlobGetNormalSf(UnitTestCase):
+    """Test glob parsing of the test_glob_get_normal_sf function. Indirectly test behaviour of glob_to_re."""
+
+    def glob_tester(self, path, glob_string, include_exclude, root_path):
+        """Takes a path, glob string and include_exclude value (1 = include, 0 = exclude) and returns the output
+        of the selection function.
+        None - means the test has nothing to say about the related file
+        0 - the file is excluded by the test
+        1 - the file is included
+        2 - the test says the file (must be directory) should be scanned"""
+        self.unpack_testfiles()
+        self.root = Path(root_path)
+        self.select = Select(self.root)
+        selection_function = self.select.glob_get_normal_sf(glob_string, include_exclude)
+        path = Path(path)
+        return selection_function(path)
+
+    def include_glob_tester(self, path, glob_string, root_path="/"):
+        return self.glob_tester(path, glob_string, 1, root_path)
+
+    def exclude_glob_tester(self, path, glob_string, root_path="/"):
+        return self.glob_tester(path, glob_string, 0, root_path)
+
+    def test_glob_get_normal_sf_exclude(self):
+        """Test simple exclude."""
+        self.assertEqual(self.exclude_glob_tester("/testfiles/select2/3", "/testfiles/select2"), 0)
+        self.assertEqual(self.exclude_glob_tester("/testfiles/.git", "/testfiles"), 0)
+
+    def test_glob_get_normal_sf_exclude_root(self):
+        """Test simple exclude with / as the glob."""
+        self.assertEqual(self.exclude_glob_tester("/.git", "/"), None)
+
+    def test_glob_get_normal_sf_2(self):
+        """Test same behaviour as the functional test test_globbing_replacement."""
+        self.assertEqual(self.include_glob_tester("/testfiles/select2/3/3sub3/3sub3sub2/3sub3sub2_file.txt",
+                                                  "/testfiles/select2/**/3sub3sub2/3sub3su?2_file.txt"), 1)
+        self.assertEqual(self.include_glob_tester("/testfiles/select2/3/3sub1", "/testfiles/select2/*/3s*1"), 1)
+        self.assertEqual(self.include_glob_tester("/testfiles/select2/2/2sub1/2sub1sub3",
+                                                  "/testfiles/select2/**/2sub1sub3"), 1)
+        self.assertEqual(self.include_glob_tester("/testfiles/select2/2/2sub1",
+                                                  "/testfiles/sel[w,u,e,q]ct2/2/2s?b1"), 1)
+        self.assertEqual(self.include_glob_tester("/testfiles/select2/1/1sub3/1sub3sub2",
+                                                  "/testfiles/select2/1/1sub3/1s[w,u,p,q]b3sub2"), 1)
+        self.assertEqual(self.exclude_glob_tester("/testfiles/select2/1/1sub3/1sub3sub1",
+                                                  "/testfiles/select2/1/1sub[1-4]/1sub3sub1"), 0)
+        self.assertEqual(self.include_glob_tester("/testfiles/select2/1/1sub2/1sub2sub1",
+                                                  "/testfiles/select2/*/1sub2/1s[w,u,p,q]b2sub1"), 1)
+        self.assertEqual(self.include_glob_tester("/testfiles/select2/1/1sub1/1sub1sub3/1sub1sub3_file.txt",
+                                                  "/testfiles/select2/1/1sub1/1sub1sub3/1su?1sub3_file.txt"), 1)
+        self.assertEqual(self.exclude_glob_tester("/testfiles/select2/1/1sub1/1sub1sub2",
+                                                  "/testfiles/select2/1/1*1/1sub1sub2"), 0)
+        self.assertEqual(self.include_glob_tester("/testfiles/select2/1/1sub2", "/testfiles/select2/1/1sub2"), 1)
+        self.assertEqual(self.include_glob_tester("/testfiles/select2/1.py", "/testfiles/select[2-4]/*.py"), 1)
+        self.assertEqual(self.exclude_glob_tester("/testfiles/select2/3", "/testfiles/*2/3"), 0)
+        self.assertEqual(self.include_glob_tester("/testfiles/select2/1", "**/select2/1"), 1)
+
+    def test_glob_get_normal_sf_negative_square_brackets_specified(self):
+        """Test negative square bracket (specified) [!a,b,c] replacement in get_normal_sf."""
+        # As in a normal shell, [!...] expands to any single character but those specified
+        self.assertEqual(self.include_glob_tester("/test/hello1.txt", "/test/hello[!2,3,4].txt"), 1)
+        self.assertEqual(self.include_glob_tester("/test/hello.txt", "/t[!w,f,h]st/hello.txt"), 1)
+        self.assertEqual(self.exclude_glob_tester("/long/example/path/hello.txt",
+                                                  "/lon[!w,e,f]/e[!p]ample/path/hello.txt"), 0)
+        self.assertEqual(self.include_glob_tester("/test/hello1.txt", "/test/hello[!2,1,3,4].txt"), None)
+        self.assertEqual(self.include_glob_tester("/test/hello.txt", "/t[!e,f,h]st/hello.txt"), None)
+        self.assertEqual(self.exclude_glob_tester("/long/example/path/hello.txt",
+                                                  "/lon[!w,e,g,f]/e[!p,x]ample/path/hello.txt"), None)
+
+    def test_glob_get_normal_sf_negative_square_brackets_range(self):
+        """Test negative square bracket (range) [!a,b,c] replacement in get_normal_sf."""
+        # As in a normal shell, [!1-5] or [!a-f] expands to any single character not in the range specified
+        self.assertEqual(self.include_glob_tester("/test/hello1.txt", "/test/hello[!2-4].txt"), 1)
+        self.assertEqual(self.include_glob_tester("/test/hello.txt", "/t[!f-h]st/hello.txt"), 1)
+        self.assertEqual(self.exclude_glob_tester("/long/example/path/hello.txt",
+                                                  "/lon[!w,e,f]/e[!p-s]ample/path/hello.txt"), 0)
+        self.assertEqual(self.include_glob_tester("/test/hello1.txt", "/test/hello[!1-4].txt"), None)
+        self.assertEqual(self.include_glob_tester("/test/hello.txt", "/t[!b-h]st/hello.txt"), None)
+        self.assertEqual(self.exclude_glob_tester("/long/example/path/hello.txt",
+                                                  "/lon[!f-p]/e[!p]ample/path/hello.txt"), None)
+
+    def test_glob_get_normal_sf_2_ignorecase(self):
+        """Test same behaviour as the functional test test_globbing_replacement, ignorecase tests."""
+        self.assertEqual(self.include_glob_tester("testfiles/select2/2/2sub1",
+                                                  "ignorecase:testfiles/sel[w,u,e,q]ct2/2/2S?b1",
+                                                  "testfiles/select2"), 1)
+        self.assertEqual(self.include_glob_tester("testfiles/select2/2/2sub1/2sub1sub2",
+                                                  "ignorecase:testfiles/select2/2/2sub1/2Sub1Sub2",
+                                                  "testfiles/select2"), 1)
+
+    def test_glob_get_normal_sf_3_double_asterisks_dirs_to_scan(self):
+        """Test double asterisk (**) replacement in glob_get_normal_sf with directories that should be scanned"""
+        # The new special pattern, **, expands to any string of characters whether or not it contains "/".
+        self.assertEqual(self.include_glob_tester("/long/example/path/", "/**/hello.txt"), 2)
+        self.assertEqual(self.include_glob_tester("/long/example/path", "/**/hello.txt"), 2)
+
+    def test_glob_get_normal_sf_3_ignorecase(self):
+        """Test ignorecase in glob_get_normal_sf"""
+        # If the pattern starts with "ignorecase:" (case insensitive), then this prefix will be removed and any
+        # character in the string can be replaced with an upper- or lowercase version of itself.
+        self.assertEqual(self.include_glob_tester("testfiles/select2/2", "ignorecase:testfiles/select2/2",
+                                                  "testfiles/select2"), 1)
+        self.assertEqual(self.include_glob_tester("testfiles/select2/2", "ignorecase:testFiles/Select2/2",
+                                                  "testfiles/select2"), 1)
+        self.assertEqual(self.include_glob_tester("tEstfiles/seLect2/2", "ignorecase:testFiles/Select2/2",
+                                                  "testfiles/select2"), 1)
+        self.assertEqual(self.include_glob_tester("TEstfiles/SeLect2/2", "ignorecase:t?stFiles/S*ect2/2",
+                                                  "testfiles/select2"), 1)
+        self.assertEqual(self.include_glob_tester("TEstfiles/SeLect2/2", "ignorecase:t?stFil**ect2/2",
+                                                  "testfiles/select2"), 1)
+        self.assertEqual(self.exclude_glob_tester("TEstfiles/SeLect2/2", "ignorecase:t?stFiles/S*ect2/2",
+                                                  "testfiles/select2"), 0)
+        self.assertEqual(self.exclude_glob_tester("TEstFiles/SeLect2/2", "ignorecase:t?stFile**ect2/2",
+                                                  "testfiles/select2"), 0)
+
 if __name__ == "__main__":
     unittest.main()