code review 4612041: exp/regexp/syntax: more escapes, character classes

src/pkg/exp/regexp/syntax/parse_test.go

 // 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 (
         "bytes"
         "fmt"
         "testing"
@@ skipping 14 matching lines @@
         //      { "abc", "str{abc}" },
         {"abc", "cat{lit{a}lit{b}lit{c}}"},
         {"a|^", "alt{lit{a}bol{}}"},
         //      { "a|b", "cc{0x61-0x62}" },
         {"a|b", "alt{lit{a}lit{b}}"},
         {"(a)", "cap{lit{a}}"},
         {"(a)|b", "alt{cap{lit{a}}lit{b}}"},
         {"a*", "star{lit{a}}"},
         {"a+", "plus{lit{a}}"},
         {"a?", "que{lit{a}}"},
-        //      { "a{2}", "rep{2,2 lit{a}}" },
-        //      { "a{2,3}", "rep{2,3 lit{a}}" },
-        //      { "a{2,}", "rep{2,-1 lit{a}}" },
-        //      { "a*?", "nstar{lit{a}}" },
-        //      { "a+?", "nplus{lit{a}}" },
-        //      { "a??", "nque{lit{a}}" },
-        //      { "a{2}?", "nrep{2,2 lit{a}}" },
-        //      { "a{2,3}?", "nrep{2,3 lit{a}}" },
-        //      { "a{2,}?", "nrep{2,-1 lit{a}}" },
+        {"a{2}", "rep{2,2 lit{a}}"},
+        {"a{2,3}", "rep{2,3 lit{a}}"},
+        {"a{2,}", "rep{2,-1 lit{a}}"},
+        {"a*?", "nstar{lit{a}}"},
+        {"a+?", "nplus{lit{a}}"},
+        {"a??", "nque{lit{a}}"},
+        {"a{2}?", "nrep{2,2 lit{a}}"},
+        {"a{2,3}?", "nrep{2,3 lit{a}}"},
+        {"a{2,}?", "nrep{2,-1 lit{a}}"},
         {"", "emp{}"},
         //      { "|", "emp{}" },  // alt{emp{}emp{}} but got factored
-        //      { "|", "alt{emp{}emp{}}" },
+        {"|", "alt{emp{}emp{}}"},
         {"|x|", "alt{emp{}lit{x}emp{}}"},
         {".", "dot{}"},
         {"^", "bol{}"},
         {"$", "eol{}"},
-        //      { "\\|", "lit{|}" },
-        //      { "\\(", "lit{(}" },
-        //      { "\\)", "lit{)}" },
-        //      { "\\*", "lit{*}" },
-        //      { "\\+", "lit{+}" },
-        //      { "\\?", "lit{?}" },
-        //      { "{", "lit{{}" },
+        {"\\|", "lit{|}"},
+        {"\\(", "lit{(}"},
+        {"\\)", "lit{)}"},
+        {"\\*", "lit{*}"},
+        {"\\+", "lit{+}"},
+        {"\\?", "lit{?}"},
+        {"{", "lit{{}"},
         {"}", "lit{}}"},
-        //      { "\\.", "lit{.}" },
-        //      { "\\^", "lit{^}" },
-        //      { "\\$", "lit{$}" },
-        //      { "\\\\", "lit{\\}" },
+        {"\\.", "lit{.}"},
+        {"\\^", "lit{^}"},
+        {"\\$", "lit{$}"},
+        {"\\\\", "lit{\\}"},
         {"[ace]", "cc{0x61 0x63 0x65}"},
         {"[abc]", "cc{0x61-0x63}"},
         {"[a-z]", "cc{0x61-0x7a}"},
         //      { "[a]", "lit{a}" },
         {"[a]", "cc{0x61}"},
-        //      { "\\-", "lit{-}" },
+        {"\\-", "lit{-}"},
         {"-", "lit{-}"},
-        //      { "\\_", "lit{_}" },
+        {"\\_", "lit{_}"},
 
         // Posix and Perl extensions
-        //      { "[[:lower:]]", "cc{0x61-0x7a}" },
-        //      { "[a-z]", "cc{0x61-0x7a}" },
-        //      { "[^[:lower:]]", "cc{0x0-0x60 0x7b-0x10ffff}" },
-        //      { "[[:^lower:]]", "cc{0x0-0x60 0x7b-0x10ffff}" },
+        {"[[:lower:]]", "cc{0x61-0x7a}"},
+        {"[a-z]", "cc{0x61-0x7a}"},
+        {"[^[:lower:]]", "cc{0x0-0x60 0x7b-0x10ffff}"},
+        {"[[:^lower:]]", "cc{0x0-0x60 0x7b-0x10ffff}"},
         //      { "(?i)[[:lower:]]", "cc{0x41-0x5a 0x61-0x7a 0x17f 0x212a}" },
         //      { "(?i)[a-z]", "cc{0x41-0x5a 0x61-0x7a 0x17f 0x212a}" },
         //      { "(?i)[^[:lower:]]", "cc{0x0-0x40 0x5b-0x60 0x7b-0x17e 0x180-0x2129 0x212b-0x10ffff}" },
         //      { "(?i)[[:^lower:]]", "cc{0x0-0x40 0x5b-0x60 0x7b-0x17e 0x180-0x2129 0x212b-0x10ffff}" },
-        //      { "\\d", "cc{0x30-0x39}" },
-        //      { "\\D", "cc{0x0-0x2f 0x3a-0x10ffff}" },
-        //      { "\\s", "cc{0x9-0xa 0xc-0xd 0x20}" },
-        //      { "\\S", "cc{0x0-0x8 0xb 0xe-0x1f 0x21-0x10ffff}" },
-        //      { "\\w", "cc{0x30-0x39 0x41-0x5a 0x5f 0x61-0x7a}" },
-        //      { "\\W", "cc{0x0-0x2f 0x3a-0x40 0x5b-0x5e 0x60 0x7b-0x10ffff}" },
+        {"\\d", "cc{0x30-0x39}"},
+        {"\\D", "cc{0x0-0x2f 0x3a-0x10ffff}"},
+        {"\\s", "cc{0x9-0xa 0xc-0xd 0x20}"},
+        {"\\S", "cc{0x0-0x8 0xb 0xe-0x1f 0x21-0x10ffff}"},
+        {"\\w", "cc{0x30-0x39 0x41-0x5a 0x5f 0x61-0x7a}"},
+        {"\\W", "cc{0x0-0x2f 0x3a-0x40 0x5b-0x5e 0x60 0x7b-0x10ffff}"},
         //      { "(?i)\\w", "cc{0x30-0x39 0x41-0x5a 0x5f 0x61-0x7a 0x17f 0x212a}" },
         //      { "(?i)\\W", "cc{0x0-0x2f 0x3a-0x40 0x5b-0x5e 0x60 0x7b-0x17e 0x180-0x2129 0x212b-0x10ffff}" },
-        //      { "[^\\\\]", "cc{0x0-0x5b 0x5d-0x10ffff}" },
+        {"[^\\\\]", "cc{0x0-0x5b 0x5d-0x10ffff}"},
         //      { "\\C", "byte{}" },
 
         // Unicode, negatives, and a double negative.
-        //      { "\\p{Braille}", "cc{0x2800-0x28ff}" },
-        //      { "\\P{Braille}", "cc{0x0-0x27ff 0x2900-0x10ffff}" },
-        //      { "\\p{^Braille}", "cc{0x0-0x27ff 0x2900-0x10ffff}" },
-        //      { "\\P{^Braille}", "cc{0x2800-0x28ff}" },
+        {"\\p{Braille}", "cc{0x2800-0x28ff}"},
+        {"\\P{Braille}", "cc{0x0-0x27ff 0x2900-0x10ffff}"},
+        {"\\p{^Braille}", "cc{0x0-0x27ff 0x2900-0x10ffff}"},
+        {"\\P{^Braille}", "cc{0x2800-0x28ff}"},
+        {"\\pZ", "cc{0x20 0xa0 0x1680 0x180e 0x2000-0x200a 0x2028-0x2029 0x202f 0x205f 0x3000}"},
+        {"[\\p{Braille}]", "cc{0x2800-0x28ff}"},
+        {"[\\P{Braille}]", "cc{0x0-0x27ff 0x2900-0x10ffff}"},
+        {"[\\p{^Braille}]", "cc{0x0-0x27ff 0x2900-0x10ffff}"},
+        {"[\\P{^Braille}]", "cc{0x2800-0x28ff}"},
+        {"[\\pZ]", "cc{0x20 0xa0 0x1680 0x180e 0x2000-0x200a 0x2028-0x2029 0x202f 0x205f 0x3000}"},
 
         // More interesting regular expressions.
         //      { "a{,2}", "str{a{,2}}" },
         //      { "\\.\\^\\$\\\\", "str{.^$\\}" },
         {"[a-zABC]", "cc{0x41-0x43 0x61-0x7a}"},
         {"[^a]", "cc{0x0-0x60 0x62-0x10ffff}"},
         {"[\xce\xb1-\xce\xb5\xe2\x98\xba]", "cc{0x3b1-0x3b5 0x263a}"}, // utf-8
-        //      { "a*{", "cat{star{lit{a}}lit{{}}" },
+        {"a*{", "cat{star{lit{a}}lit{{}}"},
 
         // Test precedences
         //      { "(?:ab)*", "star{str{ab}}" },
         //      { "(ab)*", "star{cap{str{ab}}}" },
         //      { "ab|cd", "alt{str{ab}str{cd}}" },
         //      { "a(b|c)d", "cat{lit{a}cap{cc{0x62-0x63}}lit{d}}" },
         {"(?:ab)*", "star{cat{lit{a}lit{b}}}"},
         {"(ab)*", "star{cap{cat{lit{a}lit{b}}}}"},
         {"ab|cd", "alt{cat{lit{a}lit{b}}cat{lit{c}lit{d}}}"},
         {"a(b|c)d", "cat{lit{a}cap{alt{lit{b}lit{c}}}lit{d}}"},
 
         // Test flattening.
-        //      { "(?:a)", "lit{a}" },
+        {"(?:a)", "lit{a}"},
         //      { "(?:ab)(?:cd)", "str{abcd}" },
         //      { "(?:a|b)|(?:c|d)", "cc{0x61-0x64}" },
         //      { "a|.", "dot{}" },
         //      { ".|a", "dot{}" },
 
         // Test Perl quoted literals
-        //      { "\\Q+|*?{[\\E", "str{+|*?{[}" },
-        //      { "\\Q+\\E+", "plus{lit{+}}" },
-        //      { "\\Q\\\\E", "lit{\\}" },
-        //      { "\\Q\\\\\\E", "str{\\\\}" },
+        {"\\Q+|*?{[\\E", "str{+|*?{[}"},
+        {"\\Q+\\E+", "plus{lit{+}}"},
+        {"\\Q\\\\E", "lit{\\}"},
+        {"\\Q\\\\\\E", "str{\\\\}"},
 
         // Test Perl \A and \z
-        //      { "(?m)^", "bol{}" },
-        //      { "(?m)$", "eol{}" },
-        //      { "(?-m)^", "bot{}" },
-        //      { "(?-m)$", "eot{}" },
-        //      { "(?m)\\A", "bot{}" },
-        //      { "(?m)\\z", "eot{\\z}" },
-        //      { "(?-m)\\A", "bot{}" },
-        //      { "(?-m)\\z", "eot{\\z}" },
+        {"(?m)^", "bol{}"},
+        {"(?m)$", "eol{}"},
+        {"(?-m)^", "bot{}"},
+        {"(?-m)$", "eot{}"},
+        {"(?m)\\A", "bot{}"},
+        {"(?m)\\z", "eot{\\z}"},
+        {"(?-m)\\A", "bot{}"},
+        {"(?-m)\\z", "eot{\\z}"},
 
         // Test named captures
-        //      { "(?P<name>a)", "cap{name:lit{a}}" },
+        {"(?P<name>a)", "cap{name:lit{a}}"},
 
         // Case-folded literals
         //      { "[Aa]", "litfold{a}" },
 
         // Strings
         //      { "abcde", "str{abcde}" },
         //      { "[Aa][Bb]cd", "cat{strfold{ab}str{cd}}" },
 }
 
 const testFlags = MatchNL | PerlX | UnicodeGroups
@@ skipping 106 matching lines @@
                         lo, hi := re.Rune[i], re.Rune[i+1]
                         if lo == hi {
                                 fmt.Fprintf(b, "%#x", lo)
                         } else {
                                 fmt.Fprintf(b, "%#x-%#x", lo, hi)
                         }
                 }
         }
         b.WriteByte('}')
 }