1 // Copyright 2015 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 package testing 6 7 import ( 8 "reflect" 9 "regexp" 10 "unicode" 11 ) 12 13 // Verify that our IsSpace agrees with unicode.IsSpace. 14 func TestIsSpace(t *T) { 15 n := 0 16 for r := rune(0); r <= unicode.MaxRune; r++ { 17 if isSpace(r) != unicode.IsSpace(r) { 18 t.Errorf("IsSpace(%U)=%t incorrect", r, isSpace(r)) 19 n++ 20 if n > 10 { 21 return 22 } 23 } 24 } 25 } 26 27 func TestSplitRegexp(t *T) { 28 res := func(s ...string) []string { return s } 29 testCases := []struct { 30 pattern string 31 result []string 32 }{ 33 // Correct patterns 34 // If a regexp pattern is correct, all split regexps need to be correct 35 // as well. 36 {"", res("")}, 37 {"/", res("", "")}, 38 {"//", res("", "", "")}, 39 {"A", res("A")}, 40 {"A/B", res("A", "B")}, 41 {"A/B/", res("A", "B", "")}, 42 {"/A/B/", res("", "A", "B", "")}, 43 {"[A]/(B)", res("[A]", "(B)")}, 44 {"[/]/[/]", res("[/]", "[/]")}, 45 {"[/]/[:/]", res("[/]", "[:/]")}, 46 {"/]", res("", "]")}, 47 {"]/", res("]", "")}, 48 {"]/[/]", res("]", "[/]")}, 49 {`([)/][(])`, res(`([)/][(])`)}, 50 {"[(]/[)]", res("[(]", "[)]")}, 51 52 // Faulty patterns 53 // Errors in original should produce at least one faulty regexp in results. 54 {")/", res(")/")}, 55 {")/(/)", res(")/(", ")")}, 56 {"a[/)b", res("a[/)b")}, 57 {"(/]", res("(/]")}, 58 {"(/", res("(/")}, 59 {"[/]/[/", res("[/]", "[/")}, 60 {`\p{/}`, res(`\p{`, "}")}, 61 {`\p/`, res(`\p`, "")}, 62 {`[[:/:]]`, res(`[[:/:]]`)}, 63 } 64 for _, tc := range testCases { 65 a := splitRegexp(tc.pattern) 66 if !reflect.DeepEqual(a, tc.result) { 67 t.Errorf("splitRegexp(%q) = %#v; want %#v", tc.pattern, a, tc.result) 68 } 69 70 // If there is any error in the pattern, one of the returned subpatterns 71 // needs to have an error as well. 72 if _, err := regexp.Compile(tc.pattern); err != nil { 73 ok := true 74 for _, re := range a { 75 if _, err := regexp.Compile(re); err != nil { 76 ok = false 77 } 78 } 79 if ok { 80 t.Errorf("%s: expected error in any of %q", tc.pattern, a) 81 } 82 } 83 } 84 } 85 86 func TestMatcher(t *T) { 87 testCases := []struct { 88 pattern string 89 parent, sub string 90 ok bool 91 partial bool 92 }{ 93 // Behavior without subtests. 94 {"", "", "TestFoo", true, false}, 95 {"TestFoo", "", "TestFoo", true, false}, 96 {"TestFoo/", "", "TestFoo", true, true}, 97 {"TestFoo/bar/baz", "", "TestFoo", true, true}, 98 {"TestFoo", "", "TestBar", false, false}, 99 {"TestFoo/", "", "TestBar", false, false}, 100 {"TestFoo/bar/baz", "", "TestBar/bar/baz", false, false}, 101 102 // with subtests 103 {"", "TestFoo", "x", true, false}, 104 {"TestFoo", "TestFoo", "x", true, false}, 105 {"TestFoo/", "TestFoo", "x", true, false}, 106 {"TestFoo/bar/baz", "TestFoo", "bar", true, true}, 107 // Subtest with a '/' in its name still allows for copy and pasted names 108 // to match. 109 {"TestFoo/bar/baz", "TestFoo", "bar/baz", true, false}, 110 {"TestFoo/bar/baz", "TestFoo/bar", "baz", true, false}, 111 {"TestFoo/bar/baz", "TestFoo", "x", false, false}, 112 {"TestFoo", "TestBar", "x", false, false}, 113 {"TestFoo/", "TestBar", "x", false, false}, 114 {"TestFoo/bar/baz", "TestBar", "x/bar/baz", false, false}, 115 116 // subtests only 117 {"", "TestFoo", "x", true, false}, 118 {"/", "TestFoo", "x", true, false}, 119 {"./", "TestFoo", "x", true, false}, 120 {"./.", "TestFoo", "x", true, false}, 121 {"/bar/baz", "TestFoo", "bar", true, true}, 122 {"/bar/baz", "TestFoo", "bar/baz", true, false}, 123 {"//baz", "TestFoo", "bar/baz", true, false}, 124 {"//", "TestFoo", "bar/baz", true, false}, 125 {"/bar/baz", "TestFoo/bar", "baz", true, false}, 126 {"//foo", "TestFoo", "bar/baz", false, false}, 127 {"/bar/baz", "TestFoo", "x", false, false}, 128 {"/bar/baz", "TestBar", "x/bar/baz", false, false}, 129 } 130 131 for _, tc := range testCases { 132 m := newMatcher(regexp.MatchString, tc.pattern, "-test.run") 133 134 parent := &common{name: tc.parent} 135 if tc.parent != "" { 136 parent.level = 1 137 } 138 if n, ok, partial := m.fullName(parent, tc.sub); ok != tc.ok || partial != tc.partial { 139 t.Errorf("for pattern %q, fullName(parent=%q, sub=%q) = %q, ok %v partial %v; want ok %v partial %v", 140 tc.pattern, tc.parent, tc.sub, n, ok, partial, tc.ok, tc.partial) 141 } 142 } 143 } 144 145 func TestNaming(t *T) { 146 m := newMatcher(regexp.MatchString, "", "") 147 148 parent := &common{name: "x", level: 1} // top-level test. 149 150 // Rig the matcher with some preloaded values. 151 m.subNames["x/b"] = 1000 152 153 testCases := []struct { 154 name, want string 155 }{ 156 // Uniqueness 157 {"", "x/#00"}, 158 {"", "x/#01"}, 159 160 {"t", "x/t"}, 161 {"t", "x/t#01"}, 162 {"t", "x/t#02"}, 163 164 {"a#01", "x/a#01"}, // user has subtest with this name. 165 {"a", "x/a"}, // doesn't conflict with this name. 166 {"a", "x/a#01#01"}, // conflict, add disambiguating string. 167 {"a", "x/a#02"}, // This string is claimed now, so resume 168 {"a", "x/a#03"}, // with counting. 169 {"a#02", "x/a#02#01"}, 170 171 {"b", "x/b#1000"}, // rigged, see above 172 {"b", "x/b#1001"}, 173 174 // // Sanitizing 175 {"A:1 B:2", "x/A:1_B:2"}, 176 {"s\t\r\u00a0", "x/s___"}, 177 {"\x01", `x/\x01`}, 178 {"\U0010ffff", `x/\U0010ffff`}, 179 } 180 181 for i, tc := range testCases { 182 if got, _, _ := m.fullName(parent, tc.name); got != tc.want { 183 t.Errorf("%d:%s: got %q; want %q", i, tc.name, got, tc.want) 184 } 185 } 186 } 187
