github.com/mdempsky/go@v0.0.0-20151201204031-5dd372bd1e70/src/regexp/exec_test.go (about)

     1  // Copyright 2010 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 regexp
     6  
     7  import (
     8  	"bufio"
     9  	"compress/bzip2"
    10  	"fmt"
    11  	"io"
    12  	"os"
    13  	"path/filepath"
    14  	"regexp/syntax"
    15  	"strconv"
    16  	"strings"
    17  	"testing"
    18  	"unicode/utf8"
    19  )
    20  
    21  // TestRE2 tests this package's regexp API against test cases
    22  // considered during RE2's exhaustive tests, which run all possible
    23  // regexps over a given set of atoms and operators, up to a given
    24  // complexity, over all possible strings over a given alphabet,
    25  // up to a given size.  Rather than try to link with RE2, we read a
    26  // log file containing the test cases and the expected matches.
    27  // The log file, re2-exhaustive.txt, is generated by running 'make log'
    28  // in the open source RE2 distribution https://github.com/google/re2/.
    29  //
    30  // The test file format is a sequence of stanzas like:
    31  //
    32  //	strings
    33  //	"abc"
    34  //	"123x"
    35  //	regexps
    36  //	"[a-z]+"
    37  //	0-3;0-3
    38  //	-;-
    39  //	"([0-9])([0-9])([0-9])"
    40  //	-;-
    41  //	-;0-3 0-1 1-2 2-3
    42  //
    43  // The stanza begins by defining a set of strings, quoted
    44  // using Go double-quote syntax, one per line.  Then the
    45  // regexps section gives a sequence of regexps to run on
    46  // the strings.  In the block that follows a regexp, each line
    47  // gives the semicolon-separated match results of running
    48  // the regexp on the corresponding string.
    49  // Each match result is either a single -, meaning no match, or a
    50  // space-separated sequence of pairs giving the match and
    51  // submatch indices.  An unmatched subexpression formats
    52  // its pair as a single - (not illustrated above).  For now
    53  // each regexp run produces two match results, one for a
    54  // ``full match'' that restricts the regexp to matching the entire
    55  // string or nothing, and one for a ``partial match'' that gives
    56  // the leftmost first match found in the string.
    57  //
    58  // Lines beginning with # are comments.  Lines beginning with
    59  // a capital letter are test names printed during RE2's test suite
    60  // and are echoed into t but otherwise ignored.
    61  //
    62  // At time of writing, re2-exhaustive.txt is 59 MB but compresses to 385 kB,
    63  // so we store re2-exhaustive.txt.bz2 in the repository and decompress it on the fly.
    64  //
    65  func TestRE2Search(t *testing.T) {
    66  	testRE2(t, "testdata/re2-search.txt")
    67  }
    68  
    69  func testRE2(t *testing.T, file string) {
    70  	f, err := os.Open(file)
    71  	if err != nil {
    72  		t.Fatal(err)
    73  	}
    74  	defer f.Close()
    75  	var txt io.Reader
    76  	if strings.HasSuffix(file, ".bz2") {
    77  		z := bzip2.NewReader(f)
    78  		txt = z
    79  		file = file[:len(file)-len(".bz2")] // for error messages
    80  	} else {
    81  		txt = f
    82  	}
    83  	lineno := 0
    84  	scanner := bufio.NewScanner(txt)
    85  	var (
    86  		str       []string
    87  		input     []string
    88  		inStrings bool
    89  		re        *Regexp
    90  		refull    *Regexp
    91  		nfail     int
    92  		ncase     int
    93  	)
    94  	for lineno := 1; scanner.Scan(); lineno++ {
    95  		line := scanner.Text()
    96  		switch {
    97  		case line == "":
    98  			t.Fatalf("%s:%d: unexpected blank line", file, lineno)
    99  		case line[0] == '#':
   100  			continue
   101  		case 'A' <= line[0] && line[0] <= 'Z':
   102  			// Test name.
   103  			t.Logf("%s\n", line)
   104  			continue
   105  		case line == "strings":
   106  			str = str[:0]
   107  			inStrings = true
   108  		case line == "regexps":
   109  			inStrings = false
   110  		case line[0] == '"':
   111  			q, err := strconv.Unquote(line)
   112  			if err != nil {
   113  				// Fatal because we'll get out of sync.
   114  				t.Fatalf("%s:%d: unquote %s: %v", file, lineno, line, err)
   115  			}
   116  			if inStrings {
   117  				str = append(str, q)
   118  				continue
   119  			}
   120  			// Is a regexp.
   121  			if len(input) != 0 {
   122  				t.Fatalf("%s:%d: out of sync: have %d strings left before %#q", file, lineno, len(input), q)
   123  			}
   124  			re, err = tryCompile(q)
   125  			if err != nil {
   126  				if err.Error() == "error parsing regexp: invalid escape sequence: `\\C`" {
   127  					// We don't and likely never will support \C; keep going.
   128  					continue
   129  				}
   130  				t.Errorf("%s:%d: compile %#q: %v", file, lineno, q, err)
   131  				if nfail++; nfail >= 100 {
   132  					t.Fatalf("stopping after %d errors", nfail)
   133  				}
   134  				continue
   135  			}
   136  			full := `\A(?:` + q + `)\z`
   137  			refull, err = tryCompile(full)
   138  			if err != nil {
   139  				// Fatal because q worked, so this should always work.
   140  				t.Fatalf("%s:%d: compile full %#q: %v", file, lineno, full, err)
   141  			}
   142  			input = str
   143  		case line[0] == '-' || '0' <= line[0] && line[0] <= '9':
   144  			// A sequence of match results.
   145  			ncase++
   146  			if re == nil {
   147  				// Failed to compile: skip results.
   148  				continue
   149  			}
   150  			if len(input) == 0 {
   151  				t.Fatalf("%s:%d: out of sync: no input remaining", file, lineno)
   152  			}
   153  			var text string
   154  			text, input = input[0], input[1:]
   155  			if !isSingleBytes(text) && strings.Contains(re.String(), `\B`) {
   156  				// RE2's \B considers every byte position,
   157  				// so it sees 'not word boundary' in the
   158  				// middle of UTF-8 sequences.  This package
   159  				// only considers the positions between runes,
   160  				// so it disagrees.  Skip those cases.
   161  				continue
   162  			}
   163  			res := strings.Split(line, ";")
   164  			if len(res) != len(run) {
   165  				t.Fatalf("%s:%d: have %d test results, want %d", file, lineno, len(res), len(run))
   166  			}
   167  			for i := range res {
   168  				have, suffix := run[i](re, refull, text)
   169  				want := parseResult(t, file, lineno, res[i])
   170  				if !same(have, want) {
   171  					t.Errorf("%s:%d: %#q%s.FindSubmatchIndex(%#q) = %v, want %v", file, lineno, re, suffix, text, have, want)
   172  					if nfail++; nfail >= 100 {
   173  						t.Fatalf("stopping after %d errors", nfail)
   174  					}
   175  					continue
   176  				}
   177  				b, suffix := match[i](re, refull, text)
   178  				if b != (want != nil) {
   179  					t.Errorf("%s:%d: %#q%s.MatchString(%#q) = %v, want %v", file, lineno, re, suffix, text, b, !b)
   180  					if nfail++; nfail >= 100 {
   181  						t.Fatalf("stopping after %d errors", nfail)
   182  					}
   183  					continue
   184  				}
   185  			}
   186  
   187  		default:
   188  			t.Fatalf("%s:%d: out of sync: %s\n", file, lineno, line)
   189  		}
   190  	}
   191  	if err := scanner.Err(); err != nil {
   192  		t.Fatalf("%s:%d: %v", file, lineno, err)
   193  	}
   194  	if len(input) != 0 {
   195  		t.Fatalf("%s:%d: out of sync: have %d strings left at EOF", file, lineno, len(input))
   196  	}
   197  	t.Logf("%d cases tested", ncase)
   198  }
   199  
   200  var run = []func(*Regexp, *Regexp, string) ([]int, string){
   201  	runFull,
   202  	runPartial,
   203  	runFullLongest,
   204  	runPartialLongest,
   205  }
   206  
   207  func runFull(re, refull *Regexp, text string) ([]int, string) {
   208  	refull.longest = false
   209  	return refull.FindStringSubmatchIndex(text), "[full]"
   210  }
   211  
   212  func runPartial(re, refull *Regexp, text string) ([]int, string) {
   213  	re.longest = false
   214  	return re.FindStringSubmatchIndex(text), ""
   215  }
   216  
   217  func runFullLongest(re, refull *Regexp, text string) ([]int, string) {
   218  	refull.longest = true
   219  	return refull.FindStringSubmatchIndex(text), "[full,longest]"
   220  }
   221  
   222  func runPartialLongest(re, refull *Regexp, text string) ([]int, string) {
   223  	re.longest = true
   224  	return re.FindStringSubmatchIndex(text), "[longest]"
   225  }
   226  
   227  var match = []func(*Regexp, *Regexp, string) (bool, string){
   228  	matchFull,
   229  	matchPartial,
   230  	matchFullLongest,
   231  	matchPartialLongest,
   232  }
   233  
   234  func matchFull(re, refull *Regexp, text string) (bool, string) {
   235  	refull.longest = false
   236  	return refull.MatchString(text), "[full]"
   237  }
   238  
   239  func matchPartial(re, refull *Regexp, text string) (bool, string) {
   240  	re.longest = false
   241  	return re.MatchString(text), ""
   242  }
   243  
   244  func matchFullLongest(re, refull *Regexp, text string) (bool, string) {
   245  	refull.longest = true
   246  	return refull.MatchString(text), "[full,longest]"
   247  }
   248  
   249  func matchPartialLongest(re, refull *Regexp, text string) (bool, string) {
   250  	re.longest = true
   251  	return re.MatchString(text), "[longest]"
   252  }
   253  
   254  func isSingleBytes(s string) bool {
   255  	for _, c := range s {
   256  		if c >= utf8.RuneSelf {
   257  			return false
   258  		}
   259  	}
   260  	return true
   261  }
   262  
   263  func tryCompile(s string) (re *Regexp, err error) {
   264  	// Protect against panic during Compile.
   265  	defer func() {
   266  		if r := recover(); r != nil {
   267  			err = fmt.Errorf("panic: %v", r)
   268  		}
   269  	}()
   270  	return Compile(s)
   271  }
   272  
   273  func parseResult(t *testing.T, file string, lineno int, res string) []int {
   274  	// A single - indicates no match.
   275  	if res == "-" {
   276  		return nil
   277  	}
   278  	// Otherwise, a space-separated list of pairs.
   279  	n := 1
   280  	for j := 0; j < len(res); j++ {
   281  		if res[j] == ' ' {
   282  			n++
   283  		}
   284  	}
   285  	out := make([]int, 2*n)
   286  	i := 0
   287  	n = 0
   288  	for j := 0; j <= len(res); j++ {
   289  		if j == len(res) || res[j] == ' ' {
   290  			// Process a single pair.  - means no submatch.
   291  			pair := res[i:j]
   292  			if pair == "-" {
   293  				out[n] = -1
   294  				out[n+1] = -1
   295  			} else {
   296  				k := strings.Index(pair, "-")
   297  				if k < 0 {
   298  					t.Fatalf("%s:%d: invalid pair %s", file, lineno, pair)
   299  				}
   300  				lo, err1 := strconv.Atoi(pair[:k])
   301  				hi, err2 := strconv.Atoi(pair[k+1:])
   302  				if err1 != nil || err2 != nil || lo > hi {
   303  					t.Fatalf("%s:%d: invalid pair %s", file, lineno, pair)
   304  				}
   305  				out[n] = lo
   306  				out[n+1] = hi
   307  			}
   308  			n += 2
   309  			i = j + 1
   310  		}
   311  	}
   312  	return out
   313  }
   314  
   315  func same(x, y []int) bool {
   316  	if len(x) != len(y) {
   317  		return false
   318  	}
   319  	for i, xi := range x {
   320  		if xi != y[i] {
   321  			return false
   322  		}
   323  	}
   324  	return true
   325  }
   326  
   327  // TestFowler runs this package's regexp API against the
   328  // POSIX regular expression tests collected by Glenn Fowler
   329  // at http://www2.research.att.com/~astopen/testregex/testregex.html.
   330  func TestFowler(t *testing.T) {
   331  	files, err := filepath.Glob("testdata/*.dat")
   332  	if err != nil {
   333  		t.Fatal(err)
   334  	}
   335  	for _, file := range files {
   336  		t.Log(file)
   337  		testFowler(t, file)
   338  	}
   339  }
   340  
   341  var notab = MustCompilePOSIX(`[^\t]+`)
   342  
   343  func testFowler(t *testing.T, file string) {
   344  	f, err := os.Open(file)
   345  	if err != nil {
   346  		t.Error(err)
   347  		return
   348  	}
   349  	defer f.Close()
   350  	b := bufio.NewReader(f)
   351  	lineno := 0
   352  	lastRegexp := ""
   353  Reading:
   354  	for {
   355  		lineno++
   356  		line, err := b.ReadString('\n')
   357  		if err != nil {
   358  			if err != io.EOF {
   359  				t.Errorf("%s:%d: %v", file, lineno, err)
   360  			}
   361  			break Reading
   362  		}
   363  
   364  		// http://www2.research.att.com/~astopen/man/man1/testregex.html
   365  		//
   366  		// INPUT FORMAT
   367  		//   Input lines may be blank, a comment beginning with #, or a test
   368  		//   specification. A specification is five fields separated by one
   369  		//   or more tabs. NULL denotes the empty string and NIL denotes the
   370  		//   0 pointer.
   371  		if line[0] == '#' || line[0] == '\n' {
   372  			continue Reading
   373  		}
   374  		line = line[:len(line)-1]
   375  		field := notab.FindAllString(line, -1)
   376  		for i, f := range field {
   377  			if f == "NULL" {
   378  				field[i] = ""
   379  			}
   380  			if f == "NIL" {
   381  				t.Logf("%s:%d: skip: %s", file, lineno, line)
   382  				continue Reading
   383  			}
   384  		}
   385  		if len(field) == 0 {
   386  			continue Reading
   387  		}
   388  
   389  		//   Field 1: the regex(3) flags to apply, one character per REG_feature
   390  		//   flag. The test is skipped if REG_feature is not supported by the
   391  		//   implementation. If the first character is not [BEASKLP] then the
   392  		//   specification is a global control line. One or more of [BEASKLP] may be
   393  		//   specified; the test will be repeated for each mode.
   394  		//
   395  		//     B 	basic			BRE	(grep, ed, sed)
   396  		//     E 	REG_EXTENDED		ERE	(egrep)
   397  		//     A	REG_AUGMENTED		ARE	(egrep with negation)
   398  		//     S	REG_SHELL		SRE	(sh glob)
   399  		//     K	REG_SHELL|REG_AUGMENTED	KRE	(ksh glob)
   400  		//     L	REG_LITERAL		LRE	(fgrep)
   401  		//
   402  		//     a	REG_LEFT|REG_RIGHT	implicit ^...$
   403  		//     b	REG_NOTBOL		lhs does not match ^
   404  		//     c	REG_COMMENT		ignore space and #...\n
   405  		//     d	REG_SHELL_DOT		explicit leading . match
   406  		//     e	REG_NOTEOL		rhs does not match $
   407  		//     f	REG_MULTIPLE		multiple \n separated patterns
   408  		//     g	FNM_LEADING_DIR		testfnmatch only -- match until /
   409  		//     h	REG_MULTIREF		multiple digit backref
   410  		//     i	REG_ICASE		ignore case
   411  		//     j	REG_SPAN		. matches \n
   412  		//     k	REG_ESCAPE		\ to ecape [...] delimiter
   413  		//     l	REG_LEFT		implicit ^...
   414  		//     m	REG_MINIMAL		minimal match
   415  		//     n	REG_NEWLINE		explicit \n match
   416  		//     o	REG_ENCLOSED		(|&) magic inside [@|&](...)
   417  		//     p	REG_SHELL_PATH		explicit / match
   418  		//     q	REG_DELIMITED		delimited pattern
   419  		//     r	REG_RIGHT		implicit ...$
   420  		//     s	REG_SHELL_ESCAPED	\ not special
   421  		//     t	REG_MUSTDELIM		all delimiters must be specified
   422  		//     u	standard unspecified behavior -- errors not counted
   423  		//     v	REG_CLASS_ESCAPE	\ special inside [...]
   424  		//     w	REG_NOSUB		no subexpression match array
   425  		//     x	REG_LENIENT		let some errors slide
   426  		//     y	REG_LEFT		regexec() implicit ^...
   427  		//     z	REG_NULL		NULL subexpressions ok
   428  		//     $	                        expand C \c escapes in fields 2 and 3
   429  		//     /	                        field 2 is a regsubcomp() expression
   430  		//     =	                        field 3 is a regdecomp() expression
   431  		//
   432  		//   Field 1 control lines:
   433  		//
   434  		//     C		set LC_COLLATE and LC_CTYPE to locale in field 2
   435  		//
   436  		//     ?test ...	output field 5 if passed and != EXPECTED, silent otherwise
   437  		//     &test ...	output field 5 if current and previous passed
   438  		//     |test ...	output field 5 if current passed and previous failed
   439  		//     ; ...	output field 2 if previous failed
   440  		//     {test ...	skip if failed until }
   441  		//     }		end of skip
   442  		//
   443  		//     : comment		comment copied as output NOTE
   444  		//     :comment:test	:comment: ignored
   445  		//     N[OTE] comment	comment copied as output NOTE
   446  		//     T[EST] comment	comment
   447  		//
   448  		//     number		use number for nmatch (20 by default)
   449  		flag := field[0]
   450  		switch flag[0] {
   451  		case '?', '&', '|', ';', '{', '}':
   452  			// Ignore all the control operators.
   453  			// Just run everything.
   454  			flag = flag[1:]
   455  			if flag == "" {
   456  				continue Reading
   457  			}
   458  		case ':':
   459  			i := strings.Index(flag[1:], ":")
   460  			if i < 0 {
   461  				t.Logf("skip: %s", line)
   462  				continue Reading
   463  			}
   464  			flag = flag[1+i+1:]
   465  		case 'C', 'N', 'T', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
   466  			t.Logf("skip: %s", line)
   467  			continue Reading
   468  		}
   469  
   470  		// Can check field count now that we've handled the myriad comment formats.
   471  		if len(field) < 4 {
   472  			t.Errorf("%s:%d: too few fields: %s", file, lineno, line)
   473  			continue Reading
   474  		}
   475  
   476  		// Expand C escapes (a.k.a. Go escapes).
   477  		if strings.Contains(flag, "$") {
   478  			f := `"` + field[1] + `"`
   479  			if field[1], err = strconv.Unquote(f); err != nil {
   480  				t.Errorf("%s:%d: cannot unquote %s", file, lineno, f)
   481  			}
   482  			f = `"` + field[2] + `"`
   483  			if field[2], err = strconv.Unquote(f); err != nil {
   484  				t.Errorf("%s:%d: cannot unquote %s", file, lineno, f)
   485  			}
   486  		}
   487  
   488  		//   Field 2: the regular expression pattern; SAME uses the pattern from
   489  		//     the previous specification.
   490  		//
   491  		if field[1] == "SAME" {
   492  			field[1] = lastRegexp
   493  		}
   494  		lastRegexp = field[1]
   495  
   496  		//   Field 3: the string to match.
   497  		text := field[2]
   498  
   499  		//   Field 4: the test outcome...
   500  		ok, shouldCompile, shouldMatch, pos := parseFowlerResult(field[3])
   501  		if !ok {
   502  			t.Errorf("%s:%d: cannot parse result %#q", file, lineno, field[3])
   503  			continue Reading
   504  		}
   505  
   506  		//   Field 5: optional comment appended to the report.
   507  
   508  	Testing:
   509  		// Run test once for each specified capital letter mode that we support.
   510  		for _, c := range flag {
   511  			pattern := field[1]
   512  			syn := syntax.POSIX | syntax.ClassNL
   513  			switch c {
   514  			default:
   515  				continue Testing
   516  			case 'E':
   517  				// extended regexp (what we support)
   518  			case 'L':
   519  				// literal
   520  				pattern = QuoteMeta(pattern)
   521  			}
   522  
   523  			for _, c := range flag {
   524  				switch c {
   525  				case 'i':
   526  					syn |= syntax.FoldCase
   527  				}
   528  			}
   529  
   530  			re, err := compile(pattern, syn, true)
   531  			if err != nil {
   532  				if shouldCompile {
   533  					t.Errorf("%s:%d: %#q did not compile", file, lineno, pattern)
   534  				}
   535  				continue Testing
   536  			}
   537  			if !shouldCompile {
   538  				t.Errorf("%s:%d: %#q should not compile", file, lineno, pattern)
   539  				continue Testing
   540  			}
   541  			match := re.MatchString(text)
   542  			if match != shouldMatch {
   543  				t.Errorf("%s:%d: %#q.Match(%#q) = %v, want %v", file, lineno, pattern, text, match, shouldMatch)
   544  				continue Testing
   545  			}
   546  			have := re.FindStringSubmatchIndex(text)
   547  			if (len(have) > 0) != match {
   548  				t.Errorf("%s:%d: %#q.Match(%#q) = %v, but %#q.FindSubmatchIndex(%#q) = %v", file, lineno, pattern, text, match, pattern, text, have)
   549  				continue Testing
   550  			}
   551  			if len(have) > len(pos) {
   552  				have = have[:len(pos)]
   553  			}
   554  			if !same(have, pos) {
   555  				t.Errorf("%s:%d: %#q.FindSubmatchIndex(%#q) = %v, want %v", file, lineno, pattern, text, have, pos)
   556  			}
   557  		}
   558  	}
   559  }
   560  
   561  func parseFowlerResult(s string) (ok, compiled, matched bool, pos []int) {
   562  	//   Field 4: the test outcome. This is either one of the posix error
   563  	//     codes (with REG_ omitted) or the match array, a list of (m,n)
   564  	//     entries with m and n being first and last+1 positions in the
   565  	//     field 3 string, or NULL if REG_NOSUB is in effect and success
   566  	//     is expected. BADPAT is acceptable in place of any regcomp(3)
   567  	//     error code. The match[] array is initialized to (-2,-2) before
   568  	//     each test. All array elements from 0 to nmatch-1 must be specified
   569  	//     in the outcome. Unspecified endpoints (offset -1) are denoted by ?.
   570  	//     Unset endpoints (offset -2) are denoted by X. {x}(o:n) denotes a
   571  	//     matched (?{...}) expression, where x is the text enclosed by {...},
   572  	//     o is the expression ordinal counting from 1, and n is the length of
   573  	//     the unmatched portion of the subject string. If x starts with a
   574  	//     number then that is the return value of re_execf(), otherwise 0 is
   575  	//     returned.
   576  	switch {
   577  	case s == "":
   578  		// Match with no position information.
   579  		ok = true
   580  		compiled = true
   581  		matched = true
   582  		return
   583  	case s == "NOMATCH":
   584  		// Match failure.
   585  		ok = true
   586  		compiled = true
   587  		matched = false
   588  		return
   589  	case 'A' <= s[0] && s[0] <= 'Z':
   590  		// All the other error codes are compile errors.
   591  		ok = true
   592  		compiled = false
   593  		return
   594  	}
   595  	compiled = true
   596  
   597  	var x []int
   598  	for s != "" {
   599  		var end byte = ')'
   600  		if len(x)%2 == 0 {
   601  			if s[0] != '(' {
   602  				ok = false
   603  				return
   604  			}
   605  			s = s[1:]
   606  			end = ','
   607  		}
   608  		i := 0
   609  		for i < len(s) && s[i] != end {
   610  			i++
   611  		}
   612  		if i == 0 || i == len(s) {
   613  			ok = false
   614  			return
   615  		}
   616  		var v = -1
   617  		var err error
   618  		if s[:i] != "?" {
   619  			v, err = strconv.Atoi(s[:i])
   620  			if err != nil {
   621  				ok = false
   622  				return
   623  			}
   624  		}
   625  		x = append(x, v)
   626  		s = s[i+1:]
   627  	}
   628  	if len(x)%2 != 0 {
   629  		ok = false
   630  		return
   631  	}
   632  	ok = true
   633  	matched = true
   634  	pos = x
   635  	return
   636  }
   637  
   638  var text []byte
   639  
   640  func makeText(n int) []byte {
   641  	if len(text) >= n {
   642  		return text[:n]
   643  	}
   644  	text = make([]byte, n)
   645  	x := ^uint32(0)
   646  	for i := range text {
   647  		x += x
   648  		x ^= 1
   649  		if int32(x) < 0 {
   650  			x ^= 0x88888eef
   651  		}
   652  		if x%31 == 0 {
   653  			text[i] = '\n'
   654  		} else {
   655  			text[i] = byte(x%(0x7E+1-0x20) + 0x20)
   656  		}
   657  	}
   658  	return text
   659  }
   660  
   661  func benchmark(b *testing.B, re string, n int) {
   662  	r := MustCompile(re)
   663  	t := makeText(n)
   664  	b.ResetTimer()
   665  	b.SetBytes(int64(n))
   666  	for i := 0; i < b.N; i++ {
   667  		if r.Match(t) {
   668  			b.Fatal("match!")
   669  		}
   670  	}
   671  }
   672  
   673  const (
   674  	easy0  = "ABCDEFGHIJKLMNOPQRSTUVWXYZ$"
   675  	easy1  = "A[AB]B[BC]C[CD]D[DE]E[EF]F[FG]G[GH]H[HI]I[IJ]J$"
   676  	medium = "[XYZ]ABCDEFGHIJKLMNOPQRSTUVWXYZ$"
   677  	hard   = "[ -~]*ABCDEFGHIJKLMNOPQRSTUVWXYZ$"
   678  	parens = "([ -~])*(A)(B)(C)(D)(E)(F)(G)(H)(I)(J)(K)(L)(M)" +
   679  		"(N)(O)(P)(Q)(R)(S)(T)(U)(V)(W)(X)(Y)(Z)$"
   680  )
   681  
   682  func BenchmarkMatchEasy0_32(b *testing.B)   { benchmark(b, easy0, 32<<0) }
   683  func BenchmarkMatchEasy0_1K(b *testing.B)   { benchmark(b, easy0, 1<<10) }
   684  func BenchmarkMatchEasy0_32K(b *testing.B)  { benchmark(b, easy0, 32<<10) }
   685  func BenchmarkMatchEasy0_1M(b *testing.B)   { benchmark(b, easy0, 1<<20) }
   686  func BenchmarkMatchEasy0_32M(b *testing.B)  { benchmark(b, easy0, 32<<20) }
   687  func BenchmarkMatchEasy1_32(b *testing.B)   { benchmark(b, easy1, 32<<0) }
   688  func BenchmarkMatchEasy1_1K(b *testing.B)   { benchmark(b, easy1, 1<<10) }
   689  func BenchmarkMatchEasy1_32K(b *testing.B)  { benchmark(b, easy1, 32<<10) }
   690  func BenchmarkMatchEasy1_1M(b *testing.B)   { benchmark(b, easy1, 1<<20) }
   691  func BenchmarkMatchEasy1_32M(b *testing.B)  { benchmark(b, easy1, 32<<20) }
   692  func BenchmarkMatchMedium_32(b *testing.B)  { benchmark(b, medium, 32<<0) }
   693  func BenchmarkMatchMedium_1K(b *testing.B)  { benchmark(b, medium, 1<<10) }
   694  func BenchmarkMatchMedium_32K(b *testing.B) { benchmark(b, medium, 32<<10) }
   695  func BenchmarkMatchMedium_1M(b *testing.B)  { benchmark(b, medium, 1<<20) }
   696  func BenchmarkMatchMedium_32M(b *testing.B) { benchmark(b, medium, 32<<20) }
   697  func BenchmarkMatchHard_32(b *testing.B)    { benchmark(b, hard, 32<<0) }
   698  func BenchmarkMatchHard_1K(b *testing.B)    { benchmark(b, hard, 1<<10) }
   699  func BenchmarkMatchHard_32K(b *testing.B)   { benchmark(b, hard, 32<<10) }
   700  func BenchmarkMatchHard_1M(b *testing.B)    { benchmark(b, hard, 1<<20) }
   701  func BenchmarkMatchHard_32M(b *testing.B)   { benchmark(b, hard, 32<<20) }
   702  
   703  func TestLongest(t *testing.T) {
   704  	re, err := Compile(`a(|b)`)
   705  	if err != nil {
   706  		t.Fatal(err)
   707  	}
   708  	if g, w := re.FindString("ab"), "a"; g != w {
   709  		t.Errorf("first match was %q, want %q", g, w)
   710  	}
   711  	re.Longest()
   712  	if g, w := re.FindString("ab"), "ab"; g != w {
   713  		t.Errorf("longest match was %q, want %q", g, w)
   714  	}
   715  }
   716  
   717  // TestProgramTooLongForBacktrack tests that a regex which is too long
   718  // for the backtracker still executes properly.
   719  func TestProgramTooLongForBacktrack(t *testing.T) {
   720  	longRegex := MustCompile(`(one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty|twentyone|twentytwo|twentythree|twentyfour|twentyfive|twentysix|twentyseven|twentyeight|twentynine|thirty|thirtyone|thirtytwo|thirtythree|thirtyfour|thirtyfive|thirtysix|thirtyseven|thirtyeight|thirtynine|forty|fortyone|fortytwo|fortythree|fortyfour|fortyfive|fortysix|fortyseven|fortyeight|fortynine|fifty|fiftyone|fiftytwo|fiftythree|fiftyfour|fiftyfive|fiftysix|fiftyseven|fiftyeight|fiftynine|sixty|sixtyone|sixtytwo|sixtythree|sixtyfour|sixtyfive|sixtysix|sixtyseven|sixtyeight|sixtynine|seventy|seventyone|seventytwo|seventythree|seventyfour|seventyfive|seventysix|seventyseven|seventyeight|seventynine|eighty|eightyone|eightytwo|eightythree|eightyfour|eightyfive|eightysix|eightyseven|eightyeight|eightynine|ninety|ninetyone|ninetytwo|ninetythree|ninetyfour|ninetyfive|ninetysix|ninetyseven|ninetyeight|ninetynine|onehundred)`)
   721  	if !longRegex.MatchString("two") {
   722  		t.Errorf("longRegex.MatchString(\"two\") was false, want true")
   723  	}
   724  	if longRegex.MatchString("xxx") {
   725  		t.Errorf("longRegex.MatchString(\"xxx\") was true, want false")
   726  	}
   727  }