Address feedback, expand tests

Author: natecook1000

Sources/_StringProcessing/Engine/Processor.swift

@@ -239,6 +239,17 @@ extension Processor {
     }
   }
 
+  mutating func clearThrough(_ address: InstructionAddress) {
+    while let sp = savePoints.popLast() {
+      if sp.pc == address {
+        controller.step()
+        return
+      }
+    }
+    // TODO: What should we do here?
+    fatalError("Invalid code: Tried to clear save points when empty")
+  }
+  
   mutating func cycle() {
     _checkInvariants()
     assert(state == .inProgress)
@@ -250,7 +261,6 @@ extension Processor {
     }
     let (opcode, payload) = fetch().destructure
 
-  OpCodeSwitch:
     switch opcode {
     case .invalid:
       fatalError("Invalid program")
@@ -329,15 +339,7 @@ extension Processor {
       }
 
     case .clearThrough:
-      let addr = payload.addr
-      while let sp = savePoints.popLast() {
-        if sp.pc == addr {
-          controller.step()
-          break OpCodeSwitch
-        }
-      }
-      // TODO: What should we do here?
-      fatalError("Invalid code: Tried to clear save points when empty")
+      clearThrough(payload.addr)
 
     case .peek:
       fatalError()

Tests/RegexTests/MatchTests.swift

@@ -917,12 +917,12 @@ extension RegexTests {
       input: "Price: 100 pesos", match: "100")
 
     // More complex lookaheads
-    firstMatchTest(
-      #"(?=.*e)(?=.*o)(?!.*z)"#,
-      input: "hello", match: "")
-    firstMatchTest(
-      #"^(?=.*e)(?=.*o)(?!.*h)"#,
-      input: "hello", match: nil)
+    firstMatchTests(
+      #"(?=.*e)(?=.*o)(?!.*z)."#,
+      (input: "hello", match: "h"),
+      (input: "hzello", match: "e"),
+      (input: "hezllo", match: nil),
+      (input: "helloz", match: nil))
 
     firstMatchTest(
       #"(?<=USD)\d+"#, input: "Price: USD100", match: "100", xfail: true)
@@ -1069,18 +1069,43 @@ extension RegexTests {
     firstMatchTest(
       #"(?:(?>a)|.b)c"#, input: "123abcacxyz", match: "abc")
 
-    // Quantifier behavior inside atomic
-    firstMatchTest(
-      #"^(?>a+?)a$"#, input: "aa", match: "aa")
-    firstMatchTest(
-      #"^(?>a+?)a$"#, input: "aaa", match: nil)
-    firstMatchTest(
-      #"(?>a++)a"#, input: "aaa", match: nil)
+    // Quantifier behavior inside atomic groups
+    
+    // (?:a+?) matches as few 'a's as possible, after matching the first
+    // (?>a+?) always matches exactly one 'a'
+    firstMatchTests(
+      #"^(?:a+?)a$"#,
+      (input: "a", match: nil),
+      (input: "aa", match: "aa"),
+      (input: "aaa", match:  "aaa"))
+    firstMatchTests(
+      #"^(?>a+?)a$"#,
+      (input: "a", match: nil),
+      (input: "aa", match: "aa"),
+      (input: "aaa", match:  nil))
+    
+    // (?:a?+) and (?>a?+) are equivalent: they match one 'a' if available
+    firstMatchTests(
+      #"^(?:a?+)a$"#,
+      (input: "a", match: nil),
+      xfail: true)
+    firstMatchTests(
+      #"^(?:a?+)a$"#,
+      (input: "aa", match: "aa"),
+      (input: "aaa", match: nil))
+    firstMatchTests(
+      #"^(?>a?+)a$"#,
+      (input: "a", match: nil),
+      (input: "aa", match: "aa"),
+      (input: "aaa", match: nil))
 
-    firstMatchTest(
-      #"(?>(\d+))\w+\1"#, input: "123x12", match: nil)
-    firstMatchTest(
-      #"(?>(\d+))\w+\1"#, input: "123x23", match: "23x23",
+    firstMatchTests(
+      #"(?>(\d+))\w+\1"#,
+      (input: "123x12", match: nil))
+    firstMatchTests(
+      #"(?>(\d+))\w+\1"#,
+      (input: "23x23", match: "23x23"),
+      (input: "123x23", match: "23x23"),
       xfail: true)
 
     // TODO: Test example where non-atomic is significant