From 4fb5883253e36d6ec6b93b08c68052c19103c3bd Mon Sep 17 00:00:00 2001 From: Rob Pike Date: Thu, 12 Aug 2010 16:47:52 +1000 Subject: [PATCH] testing: delete the less useful methods in the testing regexp package We can add them back using the new naming scheme should it become important. R=rsc CC=golang-dev https://golang.org/cl/1968042 --- src/pkg/testing/regexp.go | 61 +----------- src/pkg/testing/regexp_test.go | 164 --------------------------------- 2 files changed, 1 insertion(+), 224 deletions(-) diff --git a/src/pkg/testing/regexp.go b/src/pkg/testing/regexp.go index 78d801d51be..76baf1ec06e 100644 --- a/src/pkg/testing/regexp.go +++ b/src/pkg/testing/regexp.go @@ -738,28 +738,6 @@ func (re *Regexp) doExecute(str string, bytes []byte, pos int) []int { } -// ExecuteString matches the Regexp against the string s. -// The return value is an array of integers, in pairs, identifying the positions of -// substrings matched by the expression. -// s[a[0]:a[1]] is the substring matched by the entire expression. -// s[a[2*i]:a[2*i+1]] for i > 0 is the substring matched by the ith parenthesized subexpression. -// A negative value means the subexpression did not match any element of the string. -// An empty array means "no match". -func (re *Regexp) ExecuteString(s string) (a []int) { - return re.doExecute(s, nil, 0) -} - - -// Execute matches the Regexp against the byte slice b. -// The return value is an array of integers, in pairs, identifying the positions of -// subslices matched by the expression. -// b[a[0]:a[1]] is the subslice matched by the entire expression. -// b[a[2*i]:a[2*i+1]] for i > 0 is the subslice matched by the ith parenthesized subexpression. -// A negative value means the subexpression did not match any element of the slice. -// An empty array means "no match". -func (re *Regexp) Execute(b []byte) (a []int) { return re.doExecute("", b, 0) } - - // MatchString returns whether the Regexp matches the string s. // The return value is a boolean: true for match, false for no match. func (re *Regexp) MatchString(s string) bool { return len(re.doExecute(s, nil, 0)) > 0 } @@ -770,44 +748,6 @@ func (re *Regexp) MatchString(s string) bool { return len(re.doExecute(s, nil, 0 func (re *Regexp) Match(b []byte) bool { return len(re.doExecute("", b, 0)) > 0 } -// MatchStrings matches the Regexp against the string s. -// The return value is an array of strings matched by the expression. -// a[0] is the substring matched by the entire expression. -// a[i] for i > 0 is the substring matched by the ith parenthesized subexpression. -// An empty array means ``no match''. -func (re *Regexp) MatchStrings(s string) (a []string) { - r := re.doExecute(s, nil, 0) - if r == nil { - return nil - } - a = make([]string, len(r)/2) - for i := 0; i < len(r); i += 2 { - if r[i] != -1 { // -1 means no match for this subexpression - a[i/2] = s[r[i]:r[i+1]] - } - } - return -} - -// MatchSlices matches the Regexp against the byte slice b. -// The return value is an array of subslices matched by the expression. -// a[0] is the subslice matched by the entire expression. -// a[i] for i > 0 is the subslice matched by the ith parenthesized subexpression. -// An empty array means ``no match''. -func (re *Regexp) MatchSlices(b []byte) (a [][]byte) { - r := re.doExecute("", b, 0) - if r == nil { - return nil - } - a = make([][]byte, len(r)/2) - for i := 0; i < len(r); i += 2 { - if r[i] != -1 { // -1 means no match for this subexpression - a[i/2] = b[r[i]:r[i+1]] - } - } - return -} - // MatchString checks whether a textual regular expression // matches a string. More complicated queries need // to use Compile and the full Regexp interface. @@ -819,6 +759,7 @@ func MatchString(pattern string, s string) (matched bool, error string) { return re.MatchString(s), "" } + // Match checks whether a textual regular expression // matches a byte slice. More complicated queries need // to use Compile and the full Regexp interface. diff --git a/src/pkg/testing/regexp_test.go b/src/pkg/testing/regexp_test.go index ffeb62b5bb4..de75733db2b 100644 --- a/src/pkg/testing/regexp_test.go +++ b/src/pkg/testing/regexp_test.go @@ -90,100 +90,6 @@ func compileTest(t *T, expr string, error string) *Regexp { return re } -func printVec(t *T, m []int) { - l := len(m) - if l == 0 { - t.Log("\t") - } else { - for i := 0; i < l; i = i + 2 { - t.Log("\t", m[i], ",", m[i+1]) - } - } -} - -func printStrings(t *T, m []string) { - l := len(m) - if l == 0 { - t.Log("\t") - } else { - for i := 0; i < l; i = i + 2 { - t.Logf("\t%q", m[i]) - } - } -} - -func printBytes(t *T, b [][]byte) { - l := len(b) - if l == 0 { - t.Log("\t") - } else { - for i := 0; i < l; i = i + 2 { - t.Logf("\t%q", b[i]) - } - } -} - -func equal(m1, m2 []int) bool { - l := len(m1) - if l != len(m2) { - return false - } - for i := 0; i < l; i++ { - if m1[i] != m2[i] { - return false - } - } - return true -} - -func equalStrings(m1, m2 []string) bool { - l := len(m1) - if l != len(m2) { - return false - } - for i := 0; i < l; i++ { - if m1[i] != m2[i] { - return false - } - } - return true -} - -func equalBytes(m1 [][]byte, m2 []string) bool { - l := len(m1) - if l != len(m2) { - return false - } - for i := 0; i < l; i++ { - if string(m1[i]) != m2[i] { - return false - } - } - return true -} - -func executeTest(t *T, expr string, str string, match []int) { - re := compileTest(t, expr, "") - if re == nil { - return - } - m := re.ExecuteString(str) - if !equal(m, match) { - t.Error("ExecuteString failure on `", expr, "` matching `", str, "`:") - printVec(t, m) - t.Log("should be:") - printVec(t, match) - } - // now try bytes - m = re.Execute([]byte(str)) - if !equal(m, match) { - t.Error("Execute failure on `", expr, "` matching `", str, "`:") - printVec(t, m) - t.Log("should be:") - printVec(t, match) - } -} - func TestGoodCompile(t *T) { for i := 0; i < len(good_re); i++ { compileTest(t, good_re[i], "") @@ -196,13 +102,6 @@ func TestBadCompile(t *T) { } } -func TestExecute(t *T) { - for i := 0; i < len(matches); i++ { - test := &matches[i] - executeTest(t, test.re, test.text, test.match) - } -} - func matchTest(t *T, expr string, str string, match []int) { re := compileTest(t, expr, "") if re == nil { @@ -226,39 +125,6 @@ func TestMatch(t *T) { } } -func matchStringsTest(t *T, expr string, str string, match []int) { - re := compileTest(t, expr, "") - if re == nil { - return - } - strs := make([]string, len(match)/2) - for i := 0; i < len(match); i++ { - strs[i/2] = str[match[i]:match[i+1]] - } - m := re.MatchStrings(str) - if !equalStrings(m, strs) { - t.Error("MatchStrings failure on `", expr, "` matching `", str, "`:") - printStrings(t, m) - t.Log("should be:") - printStrings(t, strs) - } - // now try bytes - s := re.MatchSlices([]byte(str)) - if !equalBytes(s, strs) { - t.Error("MatchSlices failure on `", expr, "` matching `", str, "`:") - printBytes(t, s) - t.Log("should be:") - printStrings(t, strs) - } -} - -func TestMatchStrings(t *T) { - for i := 0; i < len(matches); i++ { - test := &matches[i] - matchTest(t, test.re, test.text, test.match) - } -} - func matchFunctionTest(t *T, expr string, str string, match []int) { m, err := MatchString(expr, str) if err == "" { @@ -275,33 +141,3 @@ func TestMatchFunction(t *T) { matchFunctionTest(t, test.re, test.text, test.match) } } - -func BenchmarkSimpleMatch(b *B) { - b.StopTimer() - re, _ := CompileRegexp("a") - b.StartTimer() - - for i := 0; i < b.N; i++ { - re.MatchString("a") - } -} - -func BenchmarkUngroupedMatch(b *B) { - b.StopTimer() - re, _ := CompileRegexp("[a-z]+ [0-9]+ [a-z]+") - b.StartTimer() - - for i := 0; i < b.N; i++ { - re.MatchString("word 123 other") - } -} - -func BenchmarkGroupedMatch(b *B) { - b.StopTimer() - re, _ := CompileRegexp("([a-z]+) ([0-9]+) ([a-z]+)") - b.StartTimer() - - for i := 0; i < b.N; i++ { - re.MatchString("word 123 other") - } -}