Removed unicode character classes from 'features not supported' list

Reviewed-on: #3

cmd/main.go

@@ -129,6 +129,8 @@ func main() {
 			matchIndices = regComp.FindAllSubmatch(test_str)
 		}
 
+		test_str_runes := []rune(test_str) // Converting to runes preserves unicode characters
+
 		if *printMatchesFlag {
 			// if we are in single line mode, print the line on which
 			// the matches occur
@@ -158,10 +160,10 @@ func main() {
 			oldIndices := indicesToPrint.values()
 			indicesToPrint = new_uniq_arr[int]()
 			// Explanation:
-			// Find all numbers from 0 to len(test_str) that are NOT in oldIndices.
+			// Find all numbers from 0 to len(test_str_runes) that are NOT in oldIndices.
 			// These are the values we want to print, now that we have inverted the match.
 			// Re-initialize indicesToPrint and add all of these values to it.
-			indicesToPrint.add(setDifference(genRange(0, len(test_str)), oldIndices)...)
+			indicesToPrint.add(setDifference(genRange(0, len(test_str_runes)), oldIndices)...)
 
 		}
 		// If lineFlag is enabled, we should only print something if:
@@ -182,7 +184,7 @@ func main() {
 		//			the corresponding end index.
 		// 		3. If not, just print the character.
 		if substituteFlagEnabled {
-			for i := range test_str {
+			for i := range test_str_runes {
 				inMatchIndex := false
 				for _, m := range matchIndices {
 					if i == m[0].StartIdx {
@@ -193,11 +195,11 @@ func main() {
 					}
 				}
 				if !inMatchIndex {
-					fmt.Fprintf(out, "%c", test_str[i])
+					fmt.Fprintf(out, "%c", test_str_runes[i])
 				}
 			}
 		} else {
-			for i, c := range test_str {
+			for i, c := range test_str_runes {
 				if indicesToPrint.contains(i) {
 					color.New(color.FgRed).Fprintf(out, "%c", c)
 					// Newline after every match - only if -o is enabled and -v is disabled.

regex/compile.go

@@ -108,6 +108,48 @@ func getPOSIXClass(str []rune) (bool, string) {
 	return true, rtv
 }
 
+// isUnicodeCharClassLetter returns whether or not the given letter represents a unicode character class.
+func isUnicodeCharClassLetter(c rune) bool {
+	return slices.Contains([]rune{'L', 'M', 'S', 'N', 'P', 'C', 'Z'}, c)
+}
+
+// rangeTableToRuneSlice converts the given range table into a rune slice and returns it.
+func rangeTableToRuneSlice(rangetable *unicode.RangeTable) []rune {
+	var rtv []rune
+	for _, r := range rangetable.R16 {
+		for c := r.Lo; c <= r.Hi; c += r.Stride {
+			rtv = append(rtv, rune(c))
+		}
+	}
+	for _, r := range rangetable.R32 {
+		for c := r.Lo; c <= r.Hi; c += r.Stride {
+			rtv = append(rtv, rune(c))
+		}
+	}
+	return rtv
+}
+
+// unicodeCharClassToRange converts the given unicode character class name into a list of characters in that class.
+// This class could also be a single letter eg. 'C'.
+func unicodeCharClassToRange(class string) ([]rune, error) {
+	if len(class) == 0 {
+		return nil, fmt.Errorf("empty unicode character class")
+	}
+	if len(class) == 1 || len(class) == 2 {
+		if rangeTable, ok := unicode.Categories[class]; ok {
+			return rangeTableToRuneSlice(rangeTable), nil
+		} else {
+			return nil, fmt.Errorf("invalid short unicode character class")
+		}
+	} else {
+		if rangeTable, ok := unicode.Scripts[class]; ok {
+			return rangeTableToRuneSlice(rangeTable), nil
+		} else {
+			return nil, fmt.Errorf("invalid long unicode character class")
+		}
+	}
+}
+
 // Stores whether the case-insensitive flag has been enabled.
 var caseInsensitive bool
 
@@ -309,10 +351,30 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 					}
 				} else if isHex(re_runes[i]) {
 					re_postfix = append(re_postfix, re_runes[i:i+2]...)
-					i += 2
+					i += 1 // I don't skip forward 2 steps, because the second step will happen with the loop increment
 				} else {
 					return nil, fmt.Errorf("invalid hex value in expression")
 				}
+			} else if re_runes[i] == 'p' || re_runes[i] == 'P' { // Unicode character class (P is negated unicode charclass)
+				re_postfix = append(re_postfix, re_runes[i])
+				i++
+				if i >= len(re_runes) {
+					return nil, fmt.Errorf("error parsing unicode character class in expression")
+				}
+				if re_runes[i] == '{' { // Full name charclass
+					for re_runes[i] != '}' {
+						re_postfix = append(re_postfix, re_runes[i])
+						i++
+					}
+					re_postfix = append(re_postfix, re_runes[i])
+					i++
+				} else if isUnicodeCharClassLetter(re_runes[i]) {
+					re_postfix = append(re_postfix, re_runes[i])
+					i++
+				} else {
+					return nil, fmt.Errorf("error parsing unicode character class in expression")
+				}
+				i-- // The loop increment at the top will move us forward
 			} else if re_runes[i] == '0' { // Start of octal value
 				numDigits := 1
 				for i+numDigits < len(re_runes) && numDigits < 4 && isOctal(re_runes[i+numDigits]) { // Skip while we see an octal character (max of 4, starting with 0)
@@ -429,6 +491,39 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 				} else {
 					return nil, fmt.Errorf("not enough hex characters found in expression")
 				}
+			} else if re_postfix[i] == 'p' || re_postfix[i] == 'P' {
+				charClassInverted := (re_postfix[i] == 'P')
+				charsInClass := []rune{}
+				i++
+				if isUnicodeCharClassLetter(re_postfix[i]) {
+					var err error
+					charsInClass, err = unicodeCharClassToRange(string(re_postfix[i]))
+					if err != nil {
+						return nil, err
+					}
+				} else if re_postfix[i] == '{' {
+					i++ // Skip opening bracket
+					unicodeCharClassStr := ""
+					for re_postfix[i] != '}' {
+						unicodeCharClassStr += string(re_postfix[i])
+						i++
+					}
+					var err error
+					charsInClass, err = unicodeCharClassToRange(unicodeCharClassStr)
+					if err != nil {
+						return nil, err
+					}
+				} else {
+					return nil, fmt.Errorf("error parsing unicode character class in expression")
+				}
+				var toAppend postfixNode
+				if !charClassInverted { // \p
+					toAppend = newPostfixNode(charsInClass...)
+				} else { // \P
+					toAppend = newPostfixDotNode()
+					toAppend.except = append([]postfixNode{}, newPostfixNode(charsInClass...))
+				}
+				outQueue = append(outQueue, toAppend)
 			} else if re_postfix[i] == '0' { // Octal value
 				var octVal int64
 				var octValStr string
@@ -611,7 +706,40 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 						} else {
 							return nil, fmt.Errorf("not enough hex characters found in character class")
 						}
+					} else if re_postfix[i] == 'p' || re_postfix[i] == 'P' {
+						charClassInverted := (re_postfix[i] == 'P')
+						charsInList := []rune{}
+						i++
+						if isUnicodeCharClassLetter(re_postfix[i]) {
+							var err error
+							charsInList, err = unicodeCharClassToRange(string(re_postfix[i]))
+							if err != nil {
+								return nil, err
+							}
+						} else if re_postfix[i] == '{' {
+							i++ // Skip opening bracket
+							unicodeCharClassStr := ""
+							for re_postfix[i] != '}' {
+								unicodeCharClassStr += string(re_postfix[i])
+								i++
+							}
+							var err error
+							charsInList, err = unicodeCharClassToRange(unicodeCharClassStr)
+							if err != nil {
+								return nil, err
+							}
+						} else {
+							return nil, fmt.Errorf("error parsing unicode character class in expression")
+						}
+						if !charClassInverted {
+							chars = append(chars, newPostfixNode(charsInList...))
+						} else {
+							toAppend := newPostfixDotNode()
+							toAppend.except = append([]postfixNode{}, newPostfixNode(charsInList...))
+							chars = append(chars, toAppend)
+						}
 					} else if re_postfix[i] == '0' { // Octal value
+
 						var octVal int64
 						var octValStr string
 						numDigitsParsed := 0

regex/doc.go

@@ -18,7 +18,7 @@ Single characters:
 	[^abc]			Negated character class - match any character except a, b and c
 	[^a-z]			Negated character range - do not match any character from a to z
 	\[				Match a literal '['. Backslashes can escape any character with special meaning, including another backslash.
-	\452			Match the character with the octal value 452 (up to 3 digits)
+	\0452			Match the character with the octal value 452 (up to 4 digits, first digit must be 0)
 	\xFF			Match the character with the hex value FF (exactly 2 characters)
 	\x{0000FF}		Match the character with the hex value 0000FF (exactly 6 characters)
 	\n				Newline
@@ -93,6 +93,10 @@ Lookarounds:
 	(?<=x)y			Positive lookbehind - Match y if preceded by x
 	(?<!x)y			Negative lookbehind - Match y if NOT preceded by x
 
+Backreferences:
+
+	(xy)\1			Match 'xy' followed by the text most recently captured by group 1 (in this case, 'xy')
+
 Numeric ranges:
 
 	<x-y>			Match any number from x to y (inclusive) (x and y must be positive numbers)
@@ -149,13 +153,13 @@ returns the 0-group.
 The following features from [regexp] are (currently) NOT supported:
  1. Named capturing groups
  2. Non-greedy operators
- 3. Unicode character classes
- 4. Embedded flags (flags are instead passed as arguments to [Compile])
- 5. Literal text with \Q ... \E
+ 3. Embedded flags (flags are instead passed as arguments to [Compile])
+ 4. Literal text with \Q ... \E
 
 The following features are not available in [regexp], but are supported in my engine:
  1. Lookarounds
  2. Numeric ranges
+ 3. Backreferences
 
 I hope to shorten the first list, and expand the second.
 */

regex/matching.go

@@ -319,7 +319,7 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in
 				if currentState.contentContains(str, idx, preferLongest) {
 					nextStates = addStateToList(str, idx+1, nextStates, *currentState.next, currentState.threadGroups, nil, preferLongest)
 				}
-			} else if currentState.isBackreference {
+			} else if currentState.isBackreference && currentState.threadGroups[currentState.referredGroup].IsValid() {
 				groupLength := currentState.threadGroups[currentState.referredGroup].EndIdx - currentState.threadGroups[currentState.referredGroup].StartIdx
 				if currentState.threadBackref == groupLength {
 					currentState.threadBackref = 0

regex/re_test.go

@@ -314,10 +314,6 @@ var reTests = []struct {
 	{`\0009`, nil, "\x009", []Group{{0, 2}}},
 	{`\0141`, nil, "a", []Group{{0, 1}}},
 
-	// At this point, the python test suite has a bunch
-	// of backreference tests. Since my engine doesn't
-	// implement backreferences, I've skipped those tests.
-
 	{`*a`, nil, ``, nil},
 	{`(*)b`, nil, ``, nil},
 	{`a**`, nil, ``, nil},
@@ -434,6 +430,7 @@ var reTests = []struct {
 	{`^(.+)?B`, []ReFlag{RE_CASE_INSENSITIVE}, `ab`, []Group{{0, 2}}},
 	{`\0009`, []ReFlag{RE_CASE_INSENSITIVE}, "\x009", []Group{{0, 2}}},
 	{`\0141`, []ReFlag{RE_CASE_INSENSITIVE}, "A", []Group{{0, 1}}},
+	{`\0141\0141`, []ReFlag{RE_CASE_INSENSITIVE}, "AA", []Group{{0, 2}}},
 
 	{`a[-]?c`, []ReFlag{RE_CASE_INSENSITIVE}, `AC`, []Group{{0, 2}}},
 
@@ -464,8 +461,10 @@ var reTests = []struct {
 	{`[\D5]+`, nil, `1234abc5678`, []Group{{4, 8}}},
 	{`[\da-fA-F]+`, nil, `123abc`, []Group{{0, 6}}},
 	{`\xff`, nil, "\u00ff", []Group{{0, 1}}},
+	{`\xff+`, nil, "\u00ff\u00ff", []Group{{0, 2}}},
 	{`\xFF`, nil, "\u00ff", []Group{{0, 1}}},
 	{`\x00ff`, nil, "\u00ff", []Group{}},
+	{`\x{0000ff}+`, nil, "\u00ff\u00ff", []Group{{0, 2}}},
 	{`\x{0000ff}`, nil, "\u00ff", []Group{{0, 1}}},
 	{`\x{0000FF}`, nil, "\u00ff", []Group{{0, 1}}},
 	{"\t\n\v\r\f\a", nil, "\t\n\v\r\f\a", []Group{{0, 6}}},
@@ -520,6 +519,14 @@ var reTests = []struct {
 	{`<389-400`, nil, `-`, nil},
 	{`<389-400>`, nil, `391`, []Group{{0, 3}}},
 	{`\b<1-10000>\b`, nil, `America declared independence in 1776.`, []Group{{33, 37}}},
+
+	{`\p{Tamil}+`, nil, `உயிரெழுத்து`, []Group{{0, 11}}}, // Each letter and matra is counted as a separate rune, so 'u', 'ya', 'e (matra), 'ra', 'e (matra)', 'zha', (oo (matra), 'tha', 'ith', 'tha', 'oo (matra)'.
+	{`\P{Tamil}+`, nil, `vowel=உயிரெழுத்து`, []Group{{0, 6}}},
+	{`\P`, nil, `உயிரெழுத்து`, nil},
+	{`\PM\pM*`, nil, `உயிரெழுத்து`, []Group{{0, 1}, {1, 3}, {3, 5}, {5, 7}, {7, 9}, {9, 11}}},
+	{`\pN+`, nil, `123abc456def`, []Group{{0, 3}, {6, 9}}},
+	{`\PN+`, nil, `123abc456def`, []Group{{3, 6}, {9, 12}}},
+	{`[\p{Greek}\p{Cyrillic}]`, nil, `ΣωШД`, []Group{{0, 1}, {1, 2}, {2, 3}, {3, 4}}},
 }
 
 var groupTests = []struct {
@@ -585,9 +592,33 @@ var groupTests = []struct {
 	{`(.*)c(.*)`, nil, `abcde`, []Match{[]Group{{0, 5}, {0, 2}, {3, 5}}}},
 	{`\((.*), (.*)\)`, nil, `(a, b)`, []Match{[]Group{{0, 6}, {1, 2}, {4, 5}}}},
 
-	// At this point, the python test suite has a bunch
-	// of backreference tests. Since my engine doesn't
-	// implement backreferences, I've skipped those tests.
+	// Backreference tests
+	{`(abc)\1`, nil, `abcabc`, []Match{[]Group{{0, 6}, {0, 3}}}},
+	{`([a-c]+)\1`, nil, `abcabc`, []Match{[]Group{{0, 6}, {0, 3}}}},
+	{`([a-c]*)\1`, nil, `abcabc`, []Match{[]Group{{0, 6}, {0, 3}}, []Group{{6, 6}, {6, 6}}}},
+	{`^(.+)?B`, nil, `AB`, []Match{[]Group{{0, 2}, {0, 1}}}},
+	{`(a+).\1$`, nil, `aaaaa`, []Match{[]Group{{0, 5}, {0, 2}}}},
+	{`^(a+).\1$`, nil, `aaaa`, []Match{}},
+	{`(a)\1`, nil, `aa`, []Match{[]Group{{0, 2}, {0, 1}}}},
+	{`(a+)\1`, nil, `aa`, []Match{[]Group{{0, 2}, {0, 1}}}},
+	{`(a+)+\1`, nil, `aa`, []Match{[]Group{{0, 2}, {0, 1}}}},
+	{`(a).+\1`, nil, `aba`, []Match{[]Group{{0, 3}, {0, 1}}}},
+	{`(a)ba*\1`, nil, `aba`, []Match{[]Group{{0, 3}, {0, 1}}}},
+	{`(aa|a)a\1$`, nil, `aaa`, []Match{[]Group{{0, 3}, {0, 1}}}},
+	{`(a|aa)a\1$`, nil, `aaa`, []Match{[]Group{{0, 3}, {0, 1}}}},
+	{`(a+)a\1$`, nil, `aaa`, []Match{[]Group{{0, 3}, {0, 1}}}},
+	{`([abc]*)\1`, nil, `abcabc`, []Match{[]Group{{0, 6}, {0, 3}}, []Group{{6, 6}, {6, 6}}}},
+	{`(a)(?:b)\1`, nil, `aba`, []Match{[]Group{{0, 3}, {0, 1}}}},
+	{`(a)(?:b)\1`, nil, `abb`, []Match{}},
+	{`(?:a)(b)\1`, nil, `aba`, []Match{}},
+	{`(?:a)(b)\1`, nil, `abb`, []Match{[]Group{{0, 3}, {1, 2}}}},
+	{`(?:(cat)|(dog))\2`, nil, `catdog`, []Match{}},
+	{`(?:a)\1`, nil, `aa`, nil},
+	{`((cat)|(dog)|(cow)|(bat))\4`, nil, `cowcow`, []Match{[]Group{{0, 6}, {0, 3}, {-1, -1}, {-1, -1}, {0, 3}, {-1, -1}}}},
+	{`(a|b)*\1`, nil, `abb`, []Match{[]Group{{0, 3}, {1, 2}}}},
+	{`(a|b)*\1`, nil, `aba`, []Match{}},
+	{`(a|b)*\1`, nil, `bab`, []Match{}},
+	{`(a|b)*\1`, nil, `baa`, []Match{[]Group{{0, 3}, {1, 2}}}},
 
 	{`(a)(b)c|ab`, nil, `ab`, []Match{[]Group{{0, 2}}}},
 	{`(a)+x`, nil, `aaax`, []Match{[]Group{{0, 4}, {2, 3}}}},
@@ -792,23 +823,24 @@ func TestFindSubmatch(t *testing.T) {
 				if test.result != nil {
 					panic(err)
 				}
-			}
-			match, err := regComp.FindSubmatch(test.str)
-			if err != nil {
-				if len(test.result) != 0 {
-					t.Errorf("Wanted %v got no match\n", test.result[0])
-				}
-			} else if len(test.result) == 0 {
-				t.Errorf("Wanted no match got %v\n", match)
-			}
-			for i := range match {
-				if match[i].IsValid() {
-					if test.result[0][i] != match[i] {
-						t.Errorf("Wanted %v	Got %v\n", test.result[0], match)
+			} else {
+				match, err := regComp.FindSubmatch(test.str)
+				if err != nil {
+					if len(test.result) != 0 {
+						t.Errorf("Wanted %v got no match\n", test.result[0])
 					}
-				} else {
-					if i < len(test.result) && test.result[0][i].IsValid() {
-						t.Errorf("Wanted %v	Got %v\n", test.result[0], match)
+				} else if len(test.result) == 0 {
+					t.Errorf("Wanted no match got %v\n", match)
+				}
+				for i := range match {
+					if match[i].IsValid() {
+						if test.result[0][i] != match[i] {
+							t.Errorf("Wanted %v	Got %v\n", test.result[0], match)
+						}
+					} else {
+						if i < len(test.result) && test.result[0][i].IsValid() {
+							t.Errorf("Wanted %v	Got %v\n", test.result[0], match)
+						}
 					}
 				}
 			}
@@ -823,10 +855,22 @@ func TestFindStringSubmatch(t *testing.T) {
 				if test.result != nil {
 					panic(err)
 				}
-			}
-			matchStr := regComp.FindStringSubmatch(test.str)
-			if matchStr == nil {
-				if len(test.result) != 0 {
+			} else {
+				matchStr := regComp.FindStringSubmatch(test.str)
+				if matchStr == nil {
+					if len(test.result) != 0 {
+						expectedStr := funcMap(test.result[0], func(g Group) string {
+							if g.IsValid() {
+								return test.str[g.StartIdx:g.EndIdx]
+							} else {
+								return ""
+							}
+						})
+						t.Errorf("Wanted %v got no match\n", expectedStr)
+					}
+				} else if len(test.result) == 0 {
+					t.Errorf("Wanted no match got %v\n", matchStr)
+				} else {
 					expectedStr := funcMap(test.result[0], func(g Group) string {
 						if g.IsValid() {
 							return test.str[g.StartIdx:g.EndIdx]
@@ -834,26 +878,15 @@ func TestFindStringSubmatch(t *testing.T) {
 							return ""
 						}
 					})
-					t.Errorf("Wanted %v got no match\n", expectedStr)
-				}
-			} else if len(test.result) == 0 {
-				t.Errorf("Wanted no match got %v\n", matchStr)
-			} else {
-				expectedStr := funcMap(test.result[0], func(g Group) string {
-					if g.IsValid() {
-						return test.str[g.StartIdx:g.EndIdx]
-					} else {
-						return ""
-					}
-				})
-				for i, groupStr := range matchStr {
-					if groupStr == "" {
-						if i < len(expectedStr) && expectedStr[i] != "" {
-							t.Errorf("Wanted %v	Got %v\n", expectedStr, matchStr)
-						}
-					} else {
-						if expectedStr[i] != groupStr {
-							t.Errorf("Wanted %v	Got %v\n", expectedStr, matchStr)
+					for i, groupStr := range matchStr {
+						if groupStr == "" {
+							if i < len(expectedStr) && expectedStr[i] != "" {
+								t.Errorf("Wanted %v	Got %v\n", expectedStr, matchStr)
+							}
+						} else {
+							if expectedStr[i] != groupStr {
+								t.Errorf("Wanted %v	Got %v\n", expectedStr, matchStr)
+							}
 						}
 					}
 				}
@@ -870,10 +903,24 @@ func TestFindAllStringSubmatch(t *testing.T) {
 				if test.result != nil {
 					panic(err)
 				}
-			}
-			matchStrs := regComp.FindAllStringSubmatch(test.str)
-			if matchStrs == nil {
-				if len(test.result) != 0 {
+			} else {
+				matchStrs := regComp.FindAllStringSubmatch(test.str)
+				if matchStrs == nil {
+					if len(test.result) != 0 {
+						expectedStrs := funcMap(test.result, func(m Match) []string {
+							return funcMap(m, func(g Group) string {
+								if g.IsValid() {
+									return test.str[g.StartIdx:g.EndIdx]
+								} else {
+									return ""
+								}
+							})
+						})
+						t.Errorf("Wanted %v got no match\n", expectedStrs)
+					}
+				} else if len(test.result) == 0 {
+					t.Errorf("Wanted no match got %v\n", matchStrs)
+				} else {
 					expectedStrs := funcMap(test.result, func(m Match) []string {
 						return funcMap(m, func(g Group) string {
 							if g.IsValid() {
@@ -883,29 +930,16 @@ func TestFindAllStringSubmatch(t *testing.T) {
 							}
 						})
 					})
-					t.Errorf("Wanted %v got no match\n", expectedStrs)
-				}
-			} else if len(test.result) == 0 {
-				t.Errorf("Wanted no match got %v\n", matchStrs)
-			} else {
-				expectedStrs := funcMap(test.result, func(m Match) []string {
-					return funcMap(m, func(g Group) string {
-						if g.IsValid() {
-							return test.str[g.StartIdx:g.EndIdx]
-						} else {
-							return ""
-						}
-					})
-				})
-				for i, matchStr := range matchStrs {
-					for j, groupStr := range matchStr {
-						if groupStr == "" {
-							if j < len(expectedStrs[i]) && expectedStrs[i][j] != "" {
-								t.Errorf("Wanted %v	Got %v\n", expectedStrs, matchStrs)
-							}
-						} else {
-							if expectedStrs[i][j] != groupStr {
-								t.Errorf("Wanted %v	Got %v\n", expectedStrs, matchStrs)
+					for i, matchStr := range matchStrs {
+						for j, groupStr := range matchStr {
+							if groupStr == "" {
+								if j < len(expectedStrs[i]) && expectedStrs[i][j] != "" {
+									t.Errorf("Wanted %v	Got %v\n", expectedStrs, matchStrs)
+								}
+							} else {
+								if expectedStrs[i][j] != groupStr {
+									t.Errorf("Wanted %v	Got %v\n", expectedStrs, matchStrs)
+								}
 							}
 						}
 					}
@@ -923,17 +957,18 @@ func TestFindAllSubmatch(t *testing.T) {
 				if test.result != nil {
 					panic(err)
 				}
-			}
-			matchIndices := regComp.FindAllSubmatch(test.str)
-			for i := range matchIndices {
-				for j := range matchIndices[i] {
-					if matchIndices[i][j].IsValid() {
-						if test.result[i][j] != matchIndices[i][j] {
-							t.Errorf("Wanted %v	Got %v\n", test.result, matchIndices)
-						}
-					} else {
-						if i < len(test.result) && j < len(test.result[i]) && test.result[i][j].IsValid() {
-							t.Errorf("Wanted %v	Got %v\n", test.result, matchIndices)
+			} else {
+				matchIndices := regComp.FindAllSubmatch(test.str)
+				for i := range matchIndices {
+					for j := range matchIndices[i] {
+						if matchIndices[i][j].IsValid() {
+							if test.result[i][j] != matchIndices[i][j] {
+								t.Errorf("Wanted %v	Got %v\n", test.result, matchIndices)
+							}
+						} else {
+							if i < len(test.result) && j < len(test.result[i]) && test.result[i][j].IsValid() {
+								t.Errorf("Wanted %v	Got %v\n", test.result, matchIndices)
+							}
 						}
 					}
 				}