Пример #1
0
        public void FilterDirectory_enumerate_rooted_directory()
        {
            // When a root directory is used, it is checked directly
            var e = Fixture1Enumerator();

            string[] results = Glob.FilterDirectory(Glob.Parse("/a/e/.k"),
                                                    "/anywhere/s",
                                                    e.FileExists,
                                                    e).ToArray();

            Assert.Equal(new [] { "/a/e/.k", }, results, FileNameComparison);
        }
Пример #2
0
        public void FilterDirectory_enumerate_root_from_arbitrary_other_directory()
        {
            var e = Fixture1Enumerator();

            string[] results = Glob.FilterDirectory(Glob.Parse("/*"),
                                                    "/a", // some directory
                                                    e.DirectoryExists,
                                                    e).ToArray();

            Assert.Equal(new [] {
                "/a",
            }, results, FileNameComparison);
        }
Пример #3
0
        public void FilterDirectory_should_enumerate_with_current_working_directory()
        {
            var e = Fixture2Enumerator();

            string[] results = Glob.FilterDirectory(Glob.Parse("./././ca/./*.txt"),
                                                    "/src",
                                                    e.FileExists,
                                                    e).ToArray();
            Assert.Equal(new [] {
                "/src/ca/bon.txt",
                "/src/ca/bot.txt",
            }, results, FileNameComparison);
        }
Пример #4
0
        public void FilterDirectory_enumerate_top_level_directories()
        {
            var e = Fixture1Enumerator();

            string[] results = Glob.FilterDirectory(Glob.Parse("*"),
                                                    "/",
                                                    e.DirectoryExists,
                                                    e).ToArray();

            Assert.Equal(new [] {
                "/a",
            }, results, FileNameComparison);
        }
Пример #5
0
        public void FilterDirectory_enumerate_by_wildcard_recursive_similar_names()
        {
            var e = Fixture2Enumerator();

            // Should exclude the ~a dire
            string[] results = Glob.FilterDirectory(Glob.Parse("src/**/a/*.txt"),
                                                    "/",
                                                    e.FileExists,
                                                    e).ToArray();
            Assert.Equal(new [] {
                "/src/a/bon.txt",
                "/src/a/bot.txt",
            }, results, FileNameComparison);
        }
Пример #6
0
        public void FilterDirectory_enumerate_root_directory_child_by_name()
        {
            var e = Fixture1Enumerator();

            string[] results = Glob.FilterDirectory(Glob.Parse("a/*.txt"),
                                                    "/",
                                                    e.FileExists,
                                                    e).ToArray();

            Assert.Equal(new [] {
                "/a/b.txt",
                "/a/d.txt",
            }, results, FileNameComparison);
        }
Пример #7
0
        public void FilterDirectory_enumerate_files_by_extension()
        {
            var e = Fixture1Enumerator();

            string[] results = Glob.FilterDirectory(Glob.Parse("**/*.csv"),
                                                    "/",
                                                    e.FileExists,
                                                    e).ToArray();

            Assert.Equal(new [] {
                "/a/c.csv",
                "/a/e/l.csv",
            }, results, FileNameComparison);
        }
Пример #8
0
        public void FilterDirectory_enumerate_literal_directory()
        {
            var e    = Fixture1Enumerator();
            var glob = Glob.Parse("a/e/**/*.txt");

            string[] results = Glob.FilterDirectory(Glob.Parse("a/e/**/*.txt"),
                                                    "/",
                                                    e.FileExists,
                                                    e).ToArray();

            Assert.Equal(new [] {
                "/a/e/f/g/h.txt",
                "/a/e/f/g/i.txt",
            }, results, FileNameComparison);
        }
Пример #9
0
        public void FilterDirectory_Regex_enumerate_top_level_files()
        {
            var e = Fixture1Enumerator();

            string[] results = Glob.FilterDirectory(Glob.Parse("*.*"),
                                                    "/a",
                                                    e.FileExists,
                                                    e).ToArray();

            Assert.True(Glob.Parse("*.*").ToRegex().IsMatch("/a/b.txt"));
            Assert.Equal(new [] {
                "/a/b.txt",
                "/a/c.csv",
                "/a/d.txt",
            }, results, FileNameComparison);
        }
Пример #10
0
        public void FilterDirectory_enumerate_by_bracket_choice_recursive()
        {
            // TODO [a-z].txt could be used
            var e = Fixture1Enumerator();

            string[] results = Glob.FilterDirectory(Glob.Parse("**/[bhi].txt"),
                                                    "/",
                                                    e.FileExists,
                                                    e).ToArray();
            Assert.Equal("([^/\\:]+/)*/(b|h|i)\\.txt$", Glob.Parse("**/[bhi].txt").ToRegex().ToString());
            Assert.True(Glob.Parse("**/[bhi].txt").IsMatch("/a/e/f/g/h.txt"));
            Assert.Equal(new [] {
                "/a/b.txt",
                "/a/e/f/g/h.txt",
                "/a/e/f/g/i.txt",
            }, results, FileNameComparison);
        }
Пример #11
0
        public void FilterDirectory_enumerate_files_in_multiglob()
        {
            var e = Fixture1Enumerator();

            string[] results = Glob.FilterDirectory(Glob.Parse("**/*.csv;**/*.txt"),
                                                    "/",
                                                    e.FileExists,
                                                    e).ToArray();

            Assert.SetEqual(new [] {
                "/a/b.txt",
                "/a/c.csv",
                "/a/d.txt",
                "/a/e/f/g/h.txt",
                "/a/e/f/g/i.txt",
                "/a/e/l.csv",
            }, results, FileNameComparison);
        }
Пример #12
0
        public void Glob_assumptions_for_fileobject()
        {
            // Sanity checks on the implementation of FileObject

            var e = Fixture1Enumerator();
            var f = Fixture1();

            string[] results = Glob.FilterDirectory(Glob.Anything,
                                                    "\\",
                                                    e.FileExists,
                                                    e).ToArray();
            Assume.Equal(new [] {
                "/",
                "/a",
                "/a/b.txt",
                "/a/c.csv",
                "/a/d.txt",
                "/a/e",
                "/a/e/f",
                "/a/e/f/g",
                "/a/e/f/g/h.txt",
                "/a/e/f/g/i.txt",
                "/a/e/f/j",
                "/a/e/.k",
                "/a/e/l.csv",
            }.Sorted(), f.Visit().Keys.Sorted().ToArray(), FileNameComparison);

            Assume.Equal(new [] {
                "/a"
            },
                         e.EnumerateDirectories("/").ToArray(), FileNameComparison);

            Assume.Equal(new [] {
                "/a/e"
            },
                         e.EnumerateDirectories("/a").ToArray(),
                         FileNameComparison);
            Assume.Equal(new [] {
                "/a/b.txt",
                "/a/c.csv",
                "/a/d.txt"
            }, e.EnumerateFiles("/a").ToArray(), FileNameComparison);
        }
Пример #13
0
        public void FilterDirectory_enumerate_every_file()
        {
            var e = Fixture1Enumerator();

            string[] results = Glob.FilterDirectory(Glob.Anything,
                                                    "/",
                                                    e.FileExists,
                                                    e).ToArray();

            Assert.SetEqual(new [] {
                "/a/b.txt",
                "/a/c.csv",
                "/a/d.txt",
                "/a/e/f/g/h.txt",
                "/a/e/f/g/i.txt",
                "/a/e/.k",
                "/a/e/l.csv",
            }, results, FileNameComparison);
        }