match_test.go

Documentation: testing

		 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
View as plain text