summaryrefslogtreecommitdiff
path: root/src/pkg/testing/regexp_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/testing/regexp_test.go')
-rw-r--r--src/pkg/testing/regexp_test.go307
1 files changed, 0 insertions, 307 deletions
diff --git a/src/pkg/testing/regexp_test.go b/src/pkg/testing/regexp_test.go
deleted file mode 100644
index ffeb62b5b..000000000
--- a/src/pkg/testing/regexp_test.go
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package testing
-
-var good_re = []string{
- ``,
- `.`,
- `^.$`,
- `a`,
- `a*`,
- `a+`,
- `a?`,
- `a|b`,
- `a*|b*`,
- `(a*|b)(c*|d)`,
- `[a-z]`,
- `[a-abc-c\-\]\[]`,
- `[a-z]+`,
- `[]`,
- `[abc]`,
- `[^1234]`,
- `[^\n]`,
-}
-
-// TODO: nice to do this with a map
-type stringError struct {
- re string
- err string
-}
-
-var bad_re = []stringError{
- stringError{`*`, ErrBareClosure},
- stringError{`(abc`, ErrUnmatchedLpar},
- stringError{`abc)`, ErrUnmatchedRpar},
- stringError{`x[a-z`, ErrUnmatchedLbkt},
- stringError{`abc]`, ErrUnmatchedRbkt},
- stringError{`[z-a]`, ErrBadRange},
- stringError{`abc\`, ErrExtraneousBackslash},
- stringError{`a**`, ErrBadClosure},
- stringError{`a*+`, ErrBadClosure},
- stringError{`a??`, ErrBadClosure},
- stringError{`*`, ErrBareClosure},
- stringError{`\x`, ErrBadBackslash},
-}
-
-type vec []int
-
-type tester struct {
- re string
- text string
- match vec
-}
-
-var matches = []tester{
- tester{``, "", vec{0, 0}},
- tester{`a`, "a", vec{0, 1}},
- tester{`x`, "y", vec{}},
- tester{`b`, "abc", vec{1, 2}},
- tester{`.`, "a", vec{0, 1}},
- tester{`.*`, "abcdef", vec{0, 6}},
- tester{`^abcd$`, "abcd", vec{0, 4}},
- tester{`^bcd'`, "abcdef", vec{}},
- tester{`^abcd$`, "abcde", vec{}},
- tester{`a+`, "baaab", vec{1, 4}},
- tester{`a*`, "baaab", vec{0, 0}},
- tester{`[a-z]+`, "abcd", vec{0, 4}},
- tester{`[^a-z]+`, "ab1234cd", vec{2, 6}},
- tester{`[a\-\]z]+`, "az]-bcz", vec{0, 4}},
- tester{`[^\n]+`, "abcd\n", vec{0, 4}},
- tester{`[日本語]+`, "日本語日本語", vec{0, 18}},
- tester{`()`, "", vec{0, 0, 0, 0}},
- tester{`(a)`, "a", vec{0, 1, 0, 1}},
- tester{`(.)(.)`, "日a", vec{0, 4, 0, 3, 3, 4}},
- tester{`(.*)`, "", vec{0, 0, 0, 0}},
- tester{`(.*)`, "abcd", vec{0, 4, 0, 4}},
- tester{`(..)(..)`, "abcd", vec{0, 4, 0, 2, 2, 4}},
- tester{`(([^xyz]*)(d))`, "abcd", vec{0, 4, 0, 4, 0, 3, 3, 4}},
- tester{`((a|b|c)*(d))`, "abcd", vec{0, 4, 0, 4, 2, 3, 3, 4}},
- tester{`(((a|b|c)*)(d))`, "abcd", vec{0, 4, 0, 4, 0, 3, 2, 3, 3, 4}},
- tester{`a*(|(b))c*`, "aacc", vec{0, 4, 2, 2, -1, -1}},
-}
-
-func compileTest(t *T, expr string, error string) *Regexp {
- re, err := CompileRegexp(expr)
- if err != error {
- t.Error("compiling `", expr, "`; unexpected error: ", err)
- }
- return re
-}
-
-func printVec(t *T, m []int) {
- l := len(m)
- if l == 0 {
- t.Log("\t<no match>")
- } 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<no match>")
- } 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<no match>")
- } 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], "")
- }
-}
-
-func TestBadCompile(t *T) {
- for i := 0; i < len(bad_re); i++ {
- compileTest(t, bad_re[i].re, bad_re[i].err)
- }
-}
-
-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 {
- return
- }
- m := re.MatchString(str)
- if m != (len(match) > 0) {
- t.Error("MatchString failure on `", expr, "` matching `", str, "`:", m, "should be", len(match) > 0)
- }
- // now try bytes
- m = re.Match([]byte(str))
- if m != (len(match) > 0) {
- t.Error("Match failure on `", expr, "` matching `", str, "`:", m, "should be", len(match) > 0)
- }
-}
-
-func TestMatch(t *T) {
- for i := 0; i < len(matches); i++ {
- test := &matches[i]
- matchTest(t, test.re, test.text, test.match)
- }
-}
-
-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 == "" {
- return
- }
- if m != (len(match) > 0) {
- t.Error("function Match failure on `", expr, "` matching `", str, "`:", m, "should be", len(match) > 0)
- }
-}
-
-func TestMatchFunction(t *T) {
- for i := 0; i < len(matches); i++ {
- test := &matches[i]
- 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")
- }
-}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-15 10:54:26 +0000