github.com/tardisgo/tardisgo@v0.0.0-20161119180838-e0dd9a7e46b5/goroot/haxe/go1.4/src/path/filepath/match_replaced_test.go (about) 1 // Copyright 2009 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 // +build !haxe 6 7 package filepath_test 8 9 import ( 10 "io/ioutil" 11 "os" 12 . "path/filepath" 13 "runtime" 14 "strings" 15 "testing" 16 ) 17 18 type MatchTest struct { 19 pattern, s string 20 match bool 21 err error 22 } 23 24 var matchTests = []MatchTest{ 25 {"abc", "abc", true, nil}, 26 {"*", "abc", true, nil}, 27 {"*c", "abc", true, nil}, 28 {"a*", "a", true, nil}, 29 {"a*", "abc", true, nil}, 30 {"a*", "ab/c", false, nil}, 31 {"a*/b", "abc/b", true, nil}, 32 {"a*/b", "a/c/b", false, nil}, 33 {"a*b*c*d*e*/f", "axbxcxdxe/f", true, nil}, 34 {"a*b*c*d*e*/f", "axbxcxdxexxx/f", true, nil}, 35 {"a*b*c*d*e*/f", "axbxcxdxe/xxx/f", false, nil}, 36 {"a*b*c*d*e*/f", "axbxcxdxexxx/fff", false, nil}, 37 {"a*b?c*x", "abxbbxdbxebxczzx", true, nil}, 38 {"a*b?c*x", "abxbbxdbxebxczzy", false, nil}, 39 {"ab[c]", "abc", true, nil}, 40 {"ab[b-d]", "abc", true, nil}, 41 {"ab[e-g]", "abc", false, nil}, 42 {"ab[^c]", "abc", false, nil}, 43 {"ab[^b-d]", "abc", false, nil}, 44 {"ab[^e-g]", "abc", true, nil}, 45 {"a\\*b", "a*b", true, nil}, 46 {"a\\*b", "ab", false, nil}, 47 {"a?b", "a☺b", true, nil}, 48 {"a[^a]b", "a☺b", true, nil}, 49 {"a???b", "a☺b", false, nil}, 50 {"a[^a][^a][^a]b", "a☺b", false, nil}, 51 {"[a-ζ]*", "α", true, nil}, 52 {"*[a-ζ]", "A", false, nil}, 53 {"a?b", "a/b", false, nil}, 54 {"a*b", "a/b", false, nil}, 55 {"[\\]a]", "]", true, nil}, 56 {"[\\-]", "-", true, nil}, 57 {"[x\\-]", "x", true, nil}, 58 {"[x\\-]", "-", true, nil}, 59 {"[x\\-]", "z", false, nil}, 60 {"[\\-x]", "x", true, nil}, 61 {"[\\-x]", "-", true, nil}, 62 {"[\\-x]", "a", false, nil}, 63 {"[]a]", "]", false, ErrBadPattern}, 64 {"[-]", "-", false, ErrBadPattern}, 65 {"[x-]", "x", false, ErrBadPattern}, 66 {"[x-]", "-", false, ErrBadPattern}, 67 {"[x-]", "z", false, ErrBadPattern}, 68 {"[-x]", "x", false, ErrBadPattern}, 69 {"[-x]", "-", false, ErrBadPattern}, 70 {"[-x]", "a", false, ErrBadPattern}, 71 {"\\", "a", false, ErrBadPattern}, 72 {"[a-b-c]", "a", false, ErrBadPattern}, 73 {"[", "a", false, ErrBadPattern}, 74 {"[^", "a", false, ErrBadPattern}, 75 {"[^bc", "a", false, ErrBadPattern}, 76 {"a[", "a", false, nil}, 77 {"a[", "ab", false, ErrBadPattern}, 78 {"*x", "xxx", true, nil}, 79 } 80 81 func errp(e error) string { 82 if e == nil { 83 return "<nil>" 84 } 85 return e.Error() 86 } 87 88 func TestMatch(t *testing.T) { 89 for _, tt := range matchTests { 90 pattern := tt.pattern 91 s := tt.s 92 if runtime.GOOS == "windows" { 93 if strings.Index(pattern, "\\") >= 0 { 94 // no escape allowed on windows. 95 continue 96 } 97 pattern = Clean(pattern) 98 s = Clean(s) 99 } 100 ok, err := Match(pattern, s) 101 if ok != tt.match || err != tt.err { 102 t.Errorf("Match(%#q, %#q) = %v, %q want %v, %q", pattern, s, ok, errp(err), tt.match, errp(tt.err)) 103 } 104 } 105 } 106 107 // contains returns true if vector contains the string s. 108 func contains(vector []string, s string) bool { 109 for _, elem := range vector { 110 if elem == s { 111 return true 112 } 113 } 114 return false 115 } 116 117 var globTests = []struct { 118 pattern, result string 119 }{ 120 {"match.go", "match.go"}, 121 {"mat?h.go", "match.go"}, 122 {"*", "match.go"}, 123 {"../*/match.go", "../filepath/match.go"}, 124 } 125 126 func TestGlob(t *testing.T) { 127 for _, tt := range globTests { 128 pattern := tt.pattern 129 result := tt.result 130 if runtime.GOOS == "windows" { 131 pattern = Clean(pattern) 132 result = Clean(result) 133 } 134 matches, err := Glob(pattern) 135 if err != nil { 136 t.Errorf("Glob error for %q: %s", pattern, err) 137 continue 138 } 139 if !contains(matches, result) { 140 t.Errorf("Glob(%#q) = %#v want %v", pattern, matches, result) 141 } 142 } 143 for _, pattern := range []string{"no_match", "../*/no_match"} { 144 matches, err := Glob(pattern) 145 if err != nil { 146 t.Errorf("Glob error for %q: %s", pattern, err) 147 continue 148 } 149 if len(matches) != 0 { 150 t.Errorf("Glob(%#q) = %#v want []", pattern, matches) 151 } 152 } 153 } 154 155 func TestGlobError(t *testing.T) { 156 _, err := Glob("[7]") 157 if err != nil { 158 t.Error("expected error for bad pattern; got none") 159 } 160 } 161 162 var globSymlinkTests = []struct { 163 path, dest string 164 brokenLink bool 165 }{ 166 {"test1", "link1", false}, 167 {"test2", "link2", true}, 168 } 169 170 func TestGlobSymlink(t *testing.T) { 171 switch runtime.GOOS { 172 case "nacl", "plan9": 173 t.Skipf("skipping on %s", runtime.GOOS) 174 case "windows": 175 if !supportsSymlinks { 176 t.Skipf("skipping on %s", runtime.GOOS) 177 } 178 179 } 180 181 tmpDir, err := ioutil.TempDir("", "globsymlink") 182 if err != nil { 183 t.Fatal("creating temp dir:", err) 184 } 185 defer os.RemoveAll(tmpDir) 186 187 for _, tt := range globSymlinkTests { 188 path := Join(tmpDir, tt.path) 189 dest := Join(tmpDir, tt.dest) 190 f, err := os.Create(path) 191 if err != nil { 192 t.Fatal(err) 193 } 194 if err := f.Close(); err != nil { 195 t.Fatal(err) 196 } 197 err = os.Symlink(path, dest) 198 if err != nil { 199 t.Fatal(err) 200 } 201 if tt.brokenLink { 202 // Break the symlink. 203 os.Remove(path) 204 } 205 matches, err := Glob(dest) 206 if err != nil { 207 t.Errorf("GlobSymlink error for %q: %s", dest, err) 208 } 209 if !contains(matches, dest) { 210 t.Errorf("Glob(%#q) = %#v want %v", dest, matches, dest) 211 } 212 } 213 }