// Copyright 2014 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package pathtools

import (
 "os"
 "path/filepath"
 "reflect"
 "strings"
 "testing"
)

var pwd, _ = os.Getwd()

type globTestCase struct {
 pattern  string
 matches  []string
 excludes []string
 deps     []string
 err      error
}

var globTestCases = []globTestCase{
 // Current directory tests
 {
  pattern: "*",
  matches: []string{"a/", "b/", "c/", "d.ext", "e.ext"},
  deps:    []string{"."},
 },
 {
  pattern: "*.ext",
  matches: []string{"d.ext", "e.ext"},
  deps:    []string{"."},
 },
 {
  pattern: "*/a",
  matches: []string{"a/a/", "b/a"},
  deps:    []string{".", "a", "b", "c"},
 },
 {
  pattern: "*/*/a",
  matches: []string{"a/a/a"},
  deps:    []string{".", "a", "b", "c", "a/a", "a/b", "c/f", "c/g", "c/h"},
 },
 {
  pattern: "*/a/a",
  matches: []string{"a/a/a"},
  deps:    []string{".", "a", "b", "c", "a/a"},
 },
 {
  pattern: "c/*/?",
  matches: []string{"c/h/h"},
  deps:    []string{"c", "c/f", "c/g", "c/h"},
 },
 {
  pattern: "c/*/[gh]*",
  matches: []string{"c/g/g.ext", "c/h/h"},
  deps:    []string{"c", "c/f", "c/g", "c/h"},
 },
 {
  pattern: "c/*/[fgh]*",
  matches: []string{"c/f/f.ext", "c/g/g.ext", "c/h/h"},
  deps:    []string{"c", "c/f", "c/g", "c/h"},
 },
 {
  pattern: "c/*/[f-h]*",
  matches: []string{"c/f/f.ext", "c/g/g.ext", "c/h/h"},
  deps:    []string{"c", "c/f", "c/g", "c/h"},
 },
 // ./ directory tests
 {
  pattern: "./*",
  matches: []string{"a/", "b/", "c/", "d.ext", "e.ext"},
  deps:    []string{"."},
 },
 {
  pattern: "./*.ext",
  matches: []string{"d.ext", "e.ext"},
  deps:    []string{"."},
 },
 {
  pattern: "./*/a",
  matches: []string{"a/a/", "b/a"},
  deps:    []string{".", "a", "b", "c"},
 },
 {
  pattern: "./[ac]/a",
  matches: []string{"a/a/"},
  deps:    []string{".", "a", "c"},
 },

 // subdirectory tests
 {
  pattern: "c/*/*.ext",
  matches: []string{"c/f/f.ext", "c/g/g.ext"},
  deps:    []string{"c", "c/f", "c/g", "c/h"},
 },
 {
  pattern: "a/*/a",
  matches: []string{"a/a/a"},
  deps:    []string{"a", "a/a", "a/b"},
 },

 // absolute tests
 {
  pattern: filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
  matches: []string{
   filepath.Join(pwd, "testdata/glob/c/f/f.ext"),
   filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
  },
  deps: []string{
   filepath.Join(pwd, "testdata/glob/c"),
   filepath.Join(pwd, "testdata/glob/c/f"),
   filepath.Join(pwd, "testdata/glob/c/g"),
   filepath.Join(pwd, "testdata/glob/c/h"),
  },
 },

 // no-wild tests
 {
  pattern: "a",
  matches: []string{"a/"},
  deps:    []string{"a"},
 },
 {
  pattern: "a/a",
  matches: []string{"a/a/"},
  deps:    []string{"a/a"},
 },

 // clean tests
 {
  pattern: "./c/*/*.ext",
  matches: []string{"c/f/f.ext", "c/g/g.ext"},
  deps:    []string{"c", "c/f", "c/g", "c/h"},
 },
 {
  pattern: "c/../c/*/*.ext",
  matches: []string{"c/f/f.ext", "c/g/g.ext"},
  deps:    []string{"c", "c/f", "c/g", "c/h"},
 },

 // recursive tests
 {
  pattern: "**/a",
  matches: []string{"a/", "a/a/", "a/a/a", "b/a"},
  deps:    []string{".", "a", "a/a", "a/b", "b", "c", "c/f", "c/g", "c/h"},
 },
 {
  pattern: "a/**/a",
  matches: []string{"a/a/", "a/a/a"},
  deps:    []string{"a", "a/a", "a/b"},
 },
 {
  pattern: "a/**/*",
  matches: []string{"a/a/", "a/b/", "a/a/a", "a/b/b"},
  deps:    []string{"a", "a/a", "a/b"},
 },

 // absolute recursive tests
 {
  pattern: filepath.Join(pwd, "testdata/glob/**/*.ext"),
  matches: []string{
   filepath.Join(pwd, "testdata/glob/d.ext"),
   filepath.Join(pwd, "testdata/glob/e.ext"),
   filepath.Join(pwd, "testdata/glob/c/f/f.ext"),
   filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
  },
  deps: []string{
   filepath.Join(pwd, "testdata/glob"),
   filepath.Join(pwd, "testdata/glob/a"),
   filepath.Join(pwd, "testdata/glob/a/a"),
   filepath.Join(pwd, "testdata/glob/a/b"),
   filepath.Join(pwd, "testdata/glob/b"),
   filepath.Join(pwd, "testdata/glob/c"),
   filepath.Join(pwd, "testdata/glob/c/f"),
   filepath.Join(pwd, "testdata/glob/c/g"),
   filepath.Join(pwd, "testdata/glob/c/h"),
  },
 },

 // recursive error tests
 {
  pattern: "**/**/*",
  err:     GlobMultipleRecursiveErr,
 },
 {
  pattern: "a/**/**/*",
  err:     GlobMultipleRecursiveErr,
 },
 {
  pattern: "**/a/**/*",
  err:     GlobMultipleRecursiveErr,
 },
 {
  pattern: "**/**/a/*",
  err:     GlobMultipleRecursiveErr,
 },
 {
  pattern: "a/**",
  err:     GlobLastRecursiveErr,
 },
 {
  pattern: "**/**",
  err:     GlobLastRecursiveErr,
 },
 {
  pattern: "a**/",
  err:     GlobInvalidRecursiveErr,
 },
 {
  pattern: "**a/",
  err:     GlobInvalidRecursiveErr,
 },

 // exclude tests
 {
  pattern:  "*.ext",
  excludes: []string{"d.ext"},
  matches:  []string{"e.ext"},
  deps:     []string{"."},
 },
 {
  pattern:  "*/*",
  excludes: []string{"a/b"},
  matches:  []string{"a/a/", "b/a", "c/c", "c/f/", "c/g/", "c/h/"},
  deps:     []string{".", "a", "b", "c"},
 },
 {
  pattern:  "*/*",
  excludes: []string{"a/b", "c/c"},
  matches:  []string{"a/a/", "b/a", "c/f/", "c/g/", "c/h/"},
  deps:     []string{".", "a", "b", "c"},
 },
 {
  pattern:  "*/*",
  excludes: []string{"c/*", "*/a"},
  matches:  []string{"a/b/"},
  deps:     []string{".", "a", "b", "c"},
 },
 {
  pattern:  "*/*",
  excludes: []string{"*/*"},
  matches:  nil,
  deps:     []string{".", "a", "b", "c"},
 },

 // absolute exclude tests
 {
  pattern:  filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
  excludes: []string{filepath.Join(pwd, "testdata/glob/c/*/f.ext")},
  matches: []string{
   filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
  },
  deps: []string{
   filepath.Join(pwd, "testdata/glob/c"),
   filepath.Join(pwd, "testdata/glob/c/f"),
   filepath.Join(pwd, "testdata/glob/c/g"),
   filepath.Join(pwd, "testdata/glob/c/h"),
  },
 },
 {
  pattern:  filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
  excludes: []string{filepath.Join(pwd, "testdata/glob/c/f/*.ext")},
  matches: []string{
   filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
  },
  deps: []string{
   filepath.Join(pwd, "testdata/glob/c"),
   filepath.Join(pwd, "testdata/glob/c/f"),
   filepath.Join(pwd, "testdata/glob/c/g"),
   filepath.Join(pwd, "testdata/glob/c/h"),
  },
 },

 // recursive exclude tests
 {
  pattern:  "*.ext",
  excludes: []string{"**/*.ext"},
  matches:  nil,
  deps:     []string{"."},
 },
 {
  pattern:  "*/*",
  excludes: []string{"**/b"},
  matches:  []string{"a/a/", "b/a", "c/c", "c/f/", "c/g/", "c/h/"},
  deps:     []string{".", "a", "b", "c"},
 },
 {
  pattern:  "*/*",
  excludes: []string{"a/**/*"},
  matches:  []string{"b/a", "c/c", "c/f/", "c/g/", "c/h/"},
  deps:     []string{".", "a", "b", "c"},
 },
 {
  pattern:  "**/*",
  excludes: []string{"**/*"},
  matches:  nil,
  deps:     []string{".", "a", "a/a", "a/b", "b", "c", "c/f", "c/g", "c/h"},
 },
 {
  pattern:  "*/*/*",
  excludes: []string{"a/**/a"},
  matches:  []string{"a/b/b", "c/f/f.ext", "c/g/g.ext", "c/h/h"},
  deps:     []string{".", "a", "b", "c", "a/a", "a/b", "c/f", "c/g", "c/h"},
 },
 {
  pattern:  "*/*/*",
  excludes: []string{"**/a"},
  matches:  []string{"a/b/b", "c/f/f.ext", "c/g/g.ext", "c/h/h"},
  deps:     []string{".", "a", "b", "c", "a/a", "a/b", "c/f", "c/g", "c/h"},
 },
 {
  pattern:  "c/*/*.ext",
  excludes: []string{"c/**/f.ext"},
  matches:  []string{"c/g/g.ext"},
  deps:     []string{"c", "c/f", "c/g", "c/h"},
 },

 // absoulte recursive exclude tests
 {
  pattern:  filepath.Join(pwd, "testdata/glob/c/*/*.ext"),
  excludes: []string{filepath.Join(pwd, "testdata/glob/**/f.ext")},
  matches: []string{
   filepath.Join(pwd, "testdata/glob/c/g/g.ext"),
  },
  deps: []string{
   filepath.Join(pwd, "testdata/glob/c"),
   filepath.Join(pwd, "testdata/glob/c/f"),
   filepath.Join(pwd, "testdata/glob/c/g"),
   filepath.Join(pwd, "testdata/glob/c/h"),
  },
 },

 // clean exclude tests
 {
  pattern:  "./c/*/*.ext",
  excludes: []string{"./c/*/f.ext"},
  matches:  []string{"c/g/g.ext"},
  deps:     []string{"c", "c/f", "c/g", "c/h"},
 },
 {
  pattern:  "c/*/*.ext",
  excludes: []string{"./c/*/f.ext"},
  matches:  []string{"c/g/g.ext"},
  deps:     []string{"c", "c/f", "c/g", "c/h"},
 },
 {
  pattern:  "./c/*/*.ext",
  excludes: []string{"c/*/f.ext"},
  matches:  []string{"c/g/g.ext"},
  deps:     []string{"c", "c/f", "c/g", "c/h"},
 },

 // non-existant non-wild path tests
 {
  pattern: "d/*",
  matches: nil,
  deps:    []string{"."},
 },
 {
  pattern: "d",
  matches: nil,
  deps:    []string{"."},
 },
 {
  pattern: "a/d/*",
  matches: nil,
  deps:    []string{"a"},
 },
 {
  pattern: "a/d",
  matches: nil,
  deps:    []string{"a"},
 },
 {
  pattern: "a/a/d/*",
  matches: nil,
  deps:    []string{"a/a"},
 },
 {
  pattern: "a/a/d",
  matches: nil,
  deps:    []string{"a/a"},
 },
 {
  pattern: "a/d/a/*",
  matches: nil,
  deps:    []string{"a"},
 },
 {
  pattern: "a/d/a",
  matches: nil,
  deps:    []string{"a"},
 },
 {
  pattern: "a/d/a/*/a",
  matches: nil,
  deps:    []string{"a"},
 },
 {
  pattern: "a/d/a/**/a",
  matches: nil,
  deps:    []string{"a"},
 },

 // recursive exclude error tests
 {
  pattern:  "**/*",
  excludes: []string{"**/**/*"},
  err:      GlobMultipleRecursiveErr,
 },
 {
  pattern:  "**/*",
  excludes: []string{"a/**/**/*"},
  err:      GlobMultipleRecursiveErr,
 },
 {
  pattern:  "**/*",
  excludes: []string{"**/a/**/*"},
  err:      GlobMultipleRecursiveErr,
 },
 {
  pattern:  "**/*",
  excludes: []string{"**/**/a/*"},
  err:      GlobMultipleRecursiveErr,
 },
 {
  pattern:  "**/*",
  excludes: []string{"a/**"},
  err:      GlobLastRecursiveErr,
 },
 {
  pattern:  "**/*",
  excludes: []string{"**/**"},
  err:      GlobLastRecursiveErr,
 },

 // If names are excluded by default, but referenced explicitly, they should return results
 {
  pattern: ".test/*",
  matches: []string{".test/a"},
  deps:    []string{".test"},
 },
 {
  pattern: ".t*/a",
  matches: []string{".test/a"},
  deps:    []string{".", ".test"},
 },
 {
  pattern: ".*/.*",
  matches: []string{".test/.ing"},
  deps:    []string{".", ".test"},
 },
 {
  pattern: ".t*",
  matches: []string{".test/", ".testing"},
  deps:    []string{"."},
 },
}

func TestMockGlob(t *testing.T) {
 files := []string{
  "a/a/a",
  "a/b/b",
  "b/a",
  "c/c",
  "c/f/f.ext",
  "c/g/g.ext",
  "c/h/h",
  "d.ext",
  "e.ext",
  ".test/a",
  ".testing",
  ".test/.ing",
 }

 mockFiles := make(map[string][]byte)

 for _, f := range files {
  mockFiles[f] = nil
  mockFiles[filepath.Join(pwd, "testdata/glob", f)] = nil
 }

 mock := MockFs(mockFiles)

 for _, testCase := range globTestCases {
  t.Run(testCase.pattern, func(t *testing.T) {
   testGlob(t, mock, testCase, FollowSymlinks)
  })
 }
}

func TestGlob(t *testing.T) {
 os.Chdir("testdata/glob")
 defer os.Chdir("../..")
 for _, testCase := range globTestCases {
  t.Run(testCase.pattern, func(t *testing.T) {
   testGlob(t, OsFs, testCase, FollowSymlinks)
  })
 }
}

var globEscapeTestCases = []globTestCase{
 {
  pattern: `**/*`,
  matches: []string{`*`, `**/`, `?`, `a/`, `b`, `**/*`, `**/a`, `**/b/`, `**/b/b`, `a/a`},
  deps:    []string{`.`, `**`, `**/b`, `a`},
 },
 {
  pattern: `**/\*`,
  matches: []string{`*`, `**/*`},
  deps:    []string{`.`, `**`, `**/b`, `a`},
 },
 {
  pattern: `\*\*/*`,
  matches: []string{`**/*`, `**/a`, `**/b/`},
  deps:    []string{`.`, `**`},
 },
 {
  pattern: `\*\*/**/*`,
  matches: []string{`**/*`, `**/a`, `**/b/`, `**/b/b`},
  deps:    []string{`.`, `**`, `**/b`},
 },
}

func TestMockGlobEscapes(t *testing.T) {
 files := []string{
  `*`,
  `**/*`,
  `**/a`,
  `**/b/b`,
  `?`,
  `a/a`,
  `b`,
 }

 mockFiles := make(map[string][]byte)

 for _, f := range files {
  mockFiles[f] = nil
 }

 mock := MockFs(mockFiles)

 for _, testCase := range globEscapeTestCases {
  t.Run(testCase.pattern, func(t *testing.T) {
   testGlob(t, mock, testCase, FollowSymlinks)
  })
 }

}

func TestGlobEscapes(t *testing.T) {
 os.Chdir("testdata/escapes")
 defer os.Chdir("../..")
 for _, testCase := range globEscapeTestCases {
  t.Run(testCase.pattern, func(t *testing.T) {
   testGlob(t, OsFs, testCase, FollowSymlinks)
  })
 }

}

var globSymlinkTestCases = []globTestCase{
 {
  pattern: `**/*`,
  matches: []string{"a/", "b/", "c/", "d/", "e", "a/a/", "a/a/a", "b/a/", "b/a/a", "c/a", "d/a"},
  deps:    []string{".", "a", "a/a", "b", "b/a", "c", "d"},
 },
 {
  pattern: `b/**/*`,
  matches: []string{"b/a/", "b/a/a"},
  deps:    []string{"b", "b/a"},
 },
}

func TestMockGlobSymlinks(t *testing.T) {
 files := []string{
  "a/a/a",
  "b -> a",
  "c -> a/a",
  "d -> c",
  "e -> a/a/a",
 }

 mockFiles := make(map[string][]byte)

 for _, f := range files {
  mockFiles[f] = nil
 }

 mock := MockFs(mockFiles)

 for _, testCase := range globSymlinkTestCases {
  t.Run(testCase.pattern, func(t *testing.T) {
   testGlob(t, mock, testCase, FollowSymlinks)
  })
 }
}

func TestGlobSymlinks(t *testing.T) {
 os.Chdir("testdata/symlinks")
 defer os.Chdir("../..")

 for _, testCase := range globSymlinkTestCases {
  t.Run(testCase.pattern, func(t *testing.T) {
   testGlob(t, OsFs, testCase, FollowSymlinks)
  })
 }
}

var globDontFollowSymlinkTestCases = []globTestCase{
 {
  pattern: `**/*`,
  matches: []string{"a/", "b", "c", "d", "e", "a/a/", "a/a/a"},
  deps:    []string{".", "a", "a/a"},
 },
 {
  pattern: `b/**/*`,
  matches: []string{"b/a/", "b/a/a"},
  deps:    []string{"b", "b/a"},
 },
}

func TestMockGlobDontFollowSymlinks(t *testing.T) {
 files := []string{
  "a/a/a",
  "b -> a",
  "c -> a/a",
  "d -> c",
  "e -> a/a/a",
 }

 mockFiles := make(map[string][]byte)

 for _, f := range files {
  mockFiles[f] = nil
 }

 mock := MockFs(mockFiles)

 for _, testCase := range globDontFollowSymlinkTestCases {
  t.Run(testCase.pattern, func(t *testing.T) {
   testGlob(t, mock, testCase, DontFollowSymlinks)
  })
 }
}

func TestGlobDontFollowSymlinks(t *testing.T) {
 os.Chdir("testdata/symlinks")
 defer os.Chdir("../..")

 for _, testCase := range globDontFollowSymlinkTestCases {
  t.Run(testCase.pattern, func(t *testing.T) {
   testGlob(t, OsFs, testCase, DontFollowSymlinks)
  })
 }
}

var globDontFollowDanglingSymlinkTestCases = []globTestCase{
 {
  pattern: `**/*`,
  matches: []string{"a/", "b", "c", "d", "dangling", "e", "f", "a/a/", "a/a/a", "a/a/f"},
  deps:    []string{".", "a", "a/a"},
 },
 {
  pattern: `dangling`,
  matches: []string{"dangling"},
  deps:    []string{"dangling"},
 },
}

func TestMockGlobDontFollowDanglingSymlinks(t *testing.T) {
 files := []string{
  "a/a/a",
  "a/a/f -> ../../f",
  "b -> a",
  "c -> a/a",
  "d -> c",
  "e -> a/a/a",
  "f",
  "dangling -> missing",
 }

 mockFiles := make(map[string][]byte)

 for _, f := range files {
  mockFiles[f] = nil
 }

 mock := MockFs(mockFiles)

 for _, testCase := range globDontFollowDanglingSymlinkTestCases {
  t.Run(testCase.pattern, func(t *testing.T) {
   testGlob(t, mock, testCase, DontFollowSymlinks)
  })
 }
}

func TestGlobDontFollowDanglingSymlinks(t *testing.T) {
 os.Chdir("testdata/dangling")
 defer os.Chdir("../..")

 for _, testCase := range globDontFollowDanglingSymlinkTestCases {
  t.Run(testCase.pattern, func(t *testing.T) {
   testGlob(t, OsFs, testCase, DontFollowSymlinks)
  })
 }
}

var globFollowDanglingSymlinkTestCases = []globTestCase{
 {
  pattern: `**/*`,
  matches: []string{"a/", "b/", "c/", "d/", "dangling", "e", "f", "a/a/", "a/a/a", "a/a/f", "b/a/", "b/a/a", "b/a/f", "c/a", "c/f", "d/a", "d/f"},
  deps:    []string{".", "a", "a/a", "b", "b/a", "c", "d"},
 },
 {
  pattern: `dangling`,
  matches: []string{"dangling"},
  deps:    []string{"dangling"},
 },
}

func TestMockGlobFollowDanglingSymlinks(t *testing.T) {
 files := []string{
  "a/a/a",
  "a/a/f -> ../../f",
  "b -> a",
  "c -> a/a",
  "d -> c",
  "e -> a/a/a",
  "f",
  "dangling -> missing",
 }

 mockFiles := make(map[string][]byte)

 for _, f := range files {
  mockFiles[f] = nil
 }

 mock := MockFs(mockFiles)

 for _, testCase := range globFollowDanglingSymlinkTestCases {
  t.Run(testCase.pattern, func(t *testing.T) {
   testGlob(t, mock, testCase, FollowSymlinks)
  })
 }
}

func TestGlobFollowDanglingSymlinks(t *testing.T) {
 os.Chdir("testdata/dangling")
 defer os.Chdir("../..")

 for _, testCase := range globFollowDanglingSymlinkTestCases {
  t.Run(testCase.pattern, func(t *testing.T) {
   testGlob(t, OsFs, testCase, FollowSymlinks)
  })
 }
}

func testGlob(t *testing.T, fs FileSystem, testCase globTestCase, follow ShouldFollowSymlinks) {
 t.Helper()
 result, err := fs.Glob(testCase.pattern, testCase.excludes, follow)
 if err != testCase.err {
  if err == nil {
   t.Fatalf("missing error: %s", testCase.err)
  } else {
   t.Fatalf("error: %s", err)
  }
  return
 }

 if !reflect.DeepEqual(result.Matches, testCase.matches) {
  t.Errorf("incorrect matches list:")
  t.Errorf(" pattern: %q", testCase.pattern)
  if testCase.excludes != nil {
   t.Errorf("excludes: %q", testCase.excludes)
  }
  t.Errorf("     got: %#v", result.Matches)
  t.Errorf("expected: %#v", testCase.matches)
 }
 if !reflect.DeepEqual(result.Deps, testCase.deps) {
  t.Errorf("incorrect deps list:")
  t.Errorf(" pattern: %q", testCase.pattern)
  if testCase.excludes != nil {
   t.Errorf("excludes: %q", testCase.excludes)
  }
  t.Errorf("     got: %#v", result.Deps)
  t.Errorf("expected: %#v", testCase.deps)
 }
}

func TestMatch(t *testing.T) {
 testCases := []struct {
  pattern, name string
  match         bool
 }{
  {"a/*", "b/", false},
  {"a/*", "b/a", false},
  {"a/*", "b/b/", false},
  {"a/*", "b/b/c", false},
  {"a/**/*", "b/", false},
  {"a/**/*", "b/a", false},
  {"a/**/*", "b/b/", false},
  {"a/**/*", "b/b/c", false},

  {"a/*", "a/", false},
  {"a/*", "a/a", true},
  {"a/*", "a/b/", false},
  {"a/*", "a/b/c", false},

  {"a/*/", "a/", false},
  {"a/*/", "a/a", false},
  {"a/*/", "a/b/", true},
  {"a/*/", "a/b/c", false},

  {"a/**/*", "a/", false},
  {"a/**/*", "a/a", true},
  {"a/**/*", "a/b/", false},
  {"a/**/*", "a/b/c", true},

  {"a/**/*/", "a/", false},
  {"a/**/*/", "a/a", false},
  {"a/**/*/", "a/b/", true},
  {"a/**/*/", "a/b/c", false},

  {"**/*", "a/", false},
  {"**/*", "a/a", true},
  {"**/*", "a/b/", false},
  {"**/*", "a/b/c", true},

  {"**/*/", "a/", true},
  {"**/*/", "a/a", false},
  {"**/*/", "a/b/", true},
  {"**/*/", "a/b/c", false},

  {`a/\*\*/\*`, `a/**/*`, true},
  {`a/\*\*/\*`, `a/a/*`, false},
  {`a/\*\*/\*`, `a/**/a`, false},
  {`a/\*\*/\*`, `a/a/a`, false},

  {`a/**/\*`, `a/**/*`, true},
  {`a/**/\*`, `a/a/*`, true},
  {`a/**/\*`, `a/**/a`, false},
  {`a/**/\*`, `a/a/a`, false},

  {`a/\*\*/*`, `a/**/*`, true},
  {`a/\*\*/*`, `a/a/*`, false},
  {`a/\*\*/*`, `a/**/a`, true},
  {`a/\*\*/*`, `a/a/a`, false},

  {`*/**/a`, `a/a/a`, true},
  {`*/**/a`, `*/a/a`, true},
  {`*/**/a`, `a/**/a`, true},
  {`*/**/a`, `*/**/a`, true},

  {`\*/\*\*/a`, `a/a/a`, false},
  {`\*/\*\*/a`, `*/a/a`, false},
  {`\*/\*\*/a`, `a/**/a`, false},
  {`\*/\*\*/a`, `*/**/a`, true},

  {`a/?`, `a/?`, true},
  {`a/?`, `a/a`, true},
  {`a/\?`, `a/?`, true},
  {`a/\?`, `a/a`, false},

  {`a/?`, `a/?`, true},
  {`a/?`, `a/a`, true},
  {`a/\?`, `a/?`, true},
  {`a/\?`, `a/a`, false},

  {`a/[a-c]`, `a/b`, true},
  {`a/[abc]`, `a/b`, true},

  {`a/\[abc]`, `a/b`, false},
  {`a/\[abc]`, `a/[abc]`, true},

  {`a/\[abc\]`, `a/b`, false},
  {`a/\[abc\]`, `a/[abc]`, true},

  {`a/?`, `a/?`, true},
  {`a/?`, `a/a`, true},
  {`a/\?`, `a/?`, true},
  {`a/\?`, `a/a`, false},

  {"/a/*", "/a/", false},
  {"/a/*", "/a/a", true},
  {"/a/*", "/a/b/", false},
  {"/a/*", "/a/b/c", false},

  {"/a/*/", "/a/", false},
  {"/a/*/", "/a/a", false},
  {"/a/*/", "/a/b/", true},
  {"/a/*/", "/a/b/c", false},

  {"/a/**/*", "/a/", false},
  {"/a/**/*", "/a/a", true},
  {"/a/**/*", "/a/b/", false},
  {"/a/**/*", "/a/b/c", true},

  {"/**/*", "/a/", false},
  {"/**/*", "/a/a", true},
  {"/**/*", "/a/b/", false},
  {"/**/*", "/a/b/c", true},

  {"/**/*/", "/a/", true},
  {"/**/*/", "/a/a", false},
  {"/**/*/", "/a/b/", true},
  {"/**/*/", "/a/b/c", false},

  {`a`, `/a`, false},
  {`/a`, `a`, false},
  {`*`, `/a`, false},
  {`/*`, `a`, false},
  {`**/*`, `/a`, false},
  {`/**/*`, `a`, false},
 }

 for _, test := range testCases {
  t.Run(test.pattern+","+test.name, func(t *testing.T) {
   match, err := Match(test.pattern, test.name)
   if err != nil {
    t.Fatal(err)
   }
   if match != test.match {
    t.Errorf("want: %v, got %v", test.match, match)
   }
  })
 }

 // Run the same test cases through Glob
 for _, test := range testCases {
  // Glob and Match disagree on matching directories
  if strings.HasSuffix(test.name, "/") || strings.HasSuffix(test.pattern, "/") {
   continue
  }
  t.Run("glob:"+test.pattern+","+test.name, func(t *testing.T) {
   mockFiles := map[string][]byte{
    test.name: nil,
   }

   mock := MockFs(mockFiles)

   result, err := mock.Glob(test.pattern, nil, DontFollowSymlinks)
   t.Log(test.name, test.pattern, result.Matches)
   if err != nil {
    t.Fatal(err)
   }

   match := false
   for _, x := range result.Matches {
    if x == test.name {
     match = true
    }
   }

   if match != test.match {
    t.Errorf("want: %v, got %v", test.match, match)
   }
  })
 }
}