| Server IP : 2.57.91.217 / Your IP : 216.73.216.217 Web Server : LiteSpeed System : Linux id-dci-web1986.main-hosting.eu 5.14.0-611.26.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Jan 29 05:24:47 EST 2026 x86_64 User : u686484674 ( 686484674) PHP Version : 8.0.30 Disable Function : system, exec, shell_exec, passthru, mysql_list_dbs, ini_alter, dl, symlink, link, chgrp, leak, popen, apache_child_terminate, virtual, mb_send_mail MySQL : OFF | cURL : ON | WGET : ON | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /opt/golang/1.22.0/src/regexp/syntax/ |
Upload File : |
// Copyright 2011 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 syntax
import "testing"
var simplifyTests = []struct {
Regexp string
Simple string
}{
// Already-simple constructs
{`a`, `a`},
{`ab`, `ab`},
{`a|b`, `[ab]`},
{`ab|cd`, `ab|cd`},
{`(ab)*`, `(ab)*`},
{`(ab)+`, `(ab)+`},
{`(ab)?`, `(ab)?`},
{`.`, `(?s:.)`},
{`^`, `(?m:^)`},
{`$`, `(?m:$)`},
{`[ac]`, `[ac]`},
{`[^ac]`, `[^ac]`},
// Posix character classes
{`[[:alnum:]]`, `[0-9A-Za-z]`},
{`[[:alpha:]]`, `[A-Za-z]`},
{`[[:blank:]]`, `[\t ]`},
{`[[:cntrl:]]`, `[\x00-\x1f\x7f]`},
{`[[:digit:]]`, `[0-9]`},
{`[[:graph:]]`, `[!-~]`},
{`[[:lower:]]`, `[a-z]`},
{`[[:print:]]`, `[ -~]`},
{`[[:punct:]]`, "[!-/:-@\\[-`\\{-~]"},
{`[[:space:]]`, `[\t-\r ]`},
{`[[:upper:]]`, `[A-Z]`},
{`[[:xdigit:]]`, `[0-9A-Fa-f]`},
// Perl character classes
{`\d`, `[0-9]`},
{`\s`, `[\t\n\f\r ]`},
{`\w`, `[0-9A-Z_a-z]`},
{`\D`, `[^0-9]`},
{`\S`, `[^\t\n\f\r ]`},
{`\W`, `[^0-9A-Z_a-z]`},
{`[\d]`, `[0-9]`},
{`[\s]`, `[\t\n\f\r ]`},
{`[\w]`, `[0-9A-Z_a-z]`},
{`[\D]`, `[^0-9]`},
{`[\S]`, `[^\t\n\f\r ]`},
{`[\W]`, `[^0-9A-Z_a-z]`},
// Posix repetitions
{`a{1}`, `a`},
{`a{2}`, `aa`},
{`a{5}`, `aaaaa`},
{`a{0,1}`, `a?`},
// The next three are illegible because Simplify inserts (?:)
// parens instead of () parens to avoid creating extra
// captured subexpressions. The comments show a version with fewer parens.
{`(a){0,2}`, `(?:(a)(a)?)?`}, // (aa?)?
{`(a){0,4}`, `(?:(a)(?:(a)(?:(a)(a)?)?)?)?`}, // (a(a(aa?)?)?)?
{`(a){2,6}`, `(a)(a)(?:(a)(?:(a)(?:(a)(a)?)?)?)?`}, // aa(a(a(aa?)?)?)?
{`a{0,2}`, `(?:aa?)?`}, // (aa?)?
{`a{0,4}`, `(?:a(?:a(?:aa?)?)?)?`}, // (a(a(aa?)?)?)?
{`a{2,6}`, `aa(?:a(?:a(?:aa?)?)?)?`}, // aa(a(a(aa?)?)?)?
{`a{0,}`, `a*`},
{`a{1,}`, `a+`},
{`a{2,}`, `aa+`},
{`a{5,}`, `aaaaa+`},
// Test that operators simplify their arguments.
{`(?:a{1,}){1,}`, `a+`},
{`(a{1,}b{1,})`, `(a+b+)`},
{`a{1,}|b{1,}`, `a+|b+`},
{`(?:a{1,})*`, `(?:a+)*`},
{`(?:a{1,})+`, `a+`},
{`(?:a{1,})?`, `(?:a+)?`},
{``, `(?:)`},
{`a{0}`, `(?:)`},
// Character class simplification
{`[ab]`, `[ab]`},
{`[abc]`, `[a-c]`},
{`[a-za-za-z]`, `[a-z]`},
{`[A-Za-zA-Za-z]`, `[A-Za-z]`},
{`[ABCDEFGH]`, `[A-H]`},
{`[AB-CD-EF-GH]`, `[A-H]`},
{`[W-ZP-XE-R]`, `[E-Z]`},
{`[a-ee-gg-m]`, `[a-m]`},
{`[a-ea-ha-m]`, `[a-m]`},
{`[a-ma-ha-e]`, `[a-m]`},
{`[a-zA-Z0-9 -~]`, `[ -~]`},
// Empty character classes
{`[^[:cntrl:][:^cntrl:]]`, `[^\x00-\x{10FFFF}]`},
// Full character classes
{`[[:cntrl:][:^cntrl:]]`, `(?s:.)`},
// Unicode case folding.
{`(?i)A`, `(?i:A)`},
{`(?i)a`, `(?i:A)`},
{`(?i)[A]`, `(?i:A)`},
{`(?i)[a]`, `(?i:A)`},
{`(?i)K`, `(?i:K)`},
{`(?i)k`, `(?i:K)`},
{`(?i)\x{212a}`, "(?i:K)"},
{`(?i)[K]`, "[Kk\u212A]"},
{`(?i)[k]`, "[Kk\u212A]"},
{`(?i)[\x{212a}]`, "[Kk\u212A]"},
{`(?i)[a-z]`, "[A-Za-z\u017F\u212A]"},
{`(?i)[\x00-\x{FFFD}]`, "[\\x00-\uFFFD]"},
{`(?i)[\x00-\x{10FFFF}]`, `(?s:.)`},
// Empty string as a regular expression.
// The empty string must be preserved inside parens in order
// to make submatches work right, so these tests are less
// interesting than they might otherwise be. String inserts
// explicit (?:) in place of non-parenthesized empty strings,
// to make them easier to spot for other parsers.
{`(a|b|c|)`, `([a-c]|(?:))`},
{`(a|b|)`, `([ab]|(?:))`},
{`(|)`, `()`},
{`a()`, `a()`},
{`(()|())`, `(()|())`},
{`(a|)`, `(a|(?:))`},
{`ab()cd()`, `ab()cd()`},
{`()`, `()`},
{`()*`, `()*`},
{`()+`, `()+`},
{`()?`, `()?`},
{`(){0}`, `(?:)`},
{`(){1}`, `()`},
{`(){1,}`, `()+`},
{`(){0,2}`, `(?:()()?)?`},
}
func TestSimplify(t *testing.T) {
for _, tt := range simplifyTests {
re, err := Parse(tt.Regexp, MatchNL|Perl&^OneLine)
if err != nil {
t.Errorf("Parse(%#q) = error %v", tt.Regexp, err)
continue
}
s := re.Simplify().String()
if s != tt.Simple {
t.Errorf("Simplify(%#q) = %#q, want %#q", tt.Regexp, s, tt.Simple)
}
}
}