github.com/tardisgo/tardisgo@v0.0.0-20161119180838-e0dd9a7e46b5/goroot/haxe/go1.4/src/path/filepath/match_haxe_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 if err := os.Chdir("/filepath"); err != nil { 128 panic(err) 129 } 130 for _, tt := range globTests { 131 pattern := tt.pattern 132 result := tt.result 133 if runtime.GOOS == "windows" { 134 pattern = Clean(pattern) 135 result = Clean(result) 136 } 137 matches, err := Glob(pattern) 138 if err != nil { 139 t.Errorf("Glob error for %q: %s", pattern, err) 140 continue 141 } 142 if !contains(matches, result) { 143 t.Errorf("Glob(%#q) = %#v want %v", pattern, matches, result) 144 } 145 } 146 for _, pattern := range []string{"no_match", "../*/no_match"} { 147 matches, err := Glob(pattern) 148 if err != nil { 149 t.Errorf("Glob error for %q: %s", pattern, err) 150 continue 151 } 152 if len(matches) != 0 { 153 t.Errorf("Glob(%#q) = %#v want []", pattern, matches) 154 } 155 } 156 } 157 158 func TestGlobError(t *testing.T) { 159 _, err := Glob("[7]") 160 if err != nil { 161 t.Error("expected error for bad pattern; got none") 162 } 163 } 164 165 var globSymlinkTests = []struct { 166 path, dest string 167 brokenLink bool 168 }{ 169 {"test1", "link1", false}, 170 {"test2", "link2", true}, 171 } 172 173 func TestGlobSymlink(t *testing.T) { 174 switch runtime.GOOS { 175 case "nacl", "plan9": 176 t.Skipf("skipping on %s", runtime.GOOS) 177 return 178 case "windows": 179 if !supportsSymlinks { 180 t.Skipf("skipping on %s", runtime.GOOS) 181 } 182 183 } 184 185 tmpDir, err := ioutil.TempDir("", "globsymlink") 186 if err != nil { 187 t.Fatal("creating temp dir:", err) 188 } 189 defer os.RemoveAll(tmpDir) 190 191 for _, tt := range globSymlinkTests { 192 path := Join(tmpDir, tt.path) 193 dest := Join(tmpDir, tt.dest) 194 f, err := os.Create(path) 195 if err != nil { 196 t.Fatal(err) 197 } 198 if err := f.Close(); err != nil { 199 t.Fatal(err) 200 } 201 err = os.Symlink(path, dest) 202 if err != nil { 203 t.Fatal(err) 204 } 205 if tt.brokenLink { 206 // Break the symlink. 207 os.Remove(path) 208 } 209 matches, err := Glob(dest) 210 if err != nil { 211 t.Errorf("GlobSymlink error for %q: %s", dest, err) 212 } 213 if !contains(matches, dest) { 214 t.Errorf("Glob(%#q) = %#v want %v", dest, matches, dest) 215 } 216 } 217 }