Add unit tests for look-behind assertions

Author: Multimodcrafter

regex-automata/tests/dfa/onepass/suite.rs

@@ -79,7 +79,10 @@ fn compiler(
                 // Since our error types are all generally opaque, we just
                 // look for an error string. Not great, but not the end of the
                 // world.
-                if test.compiles() && msg.contains("not one-pass") {
+                if test.compiles()
+                    && (msg.contains("not one-pass")
+                        || msg.contains("look-around"))
+                {
                     return Ok(CompiledRegex::skip());
                 }
                 return Err(err.into());

regex-automata/tests/dfa/suite.rs

@@ -292,7 +292,17 @@ fn compiler(
         if !configure_regex_builder(test, &mut builder) {
             return Ok(CompiledRegex::skip());
         }
-        create_matcher(&builder, pre, builder.build_many(&regexes)?)
+        let re = match builder.build_many(regexes) {
+            Ok(re) => re,
+            Err(err)
+                if test.compiles()
+                    && format!("{err}").contains("look-around") =>
+            {
+                return Ok(CompiledRegex::skip());
+            }
+            Err(err) => return Err(err.into()),
+        };
+        create_matcher(&builder, pre, re)
     }
 }
 

regex-automata/tests/hybrid/suite.rs

@@ -183,7 +183,16 @@ fn compiler(
         if !configure_regex_builder(test, &mut builder) {
             return Ok(CompiledRegex::skip());
         }
-        let re = builder.build_many(&regexes)?;
+        let re = match builder.build_many(regexes) {
+            Ok(re) => re,
+            Err(err)
+                if test.compiles()
+                    && format!("{err}").contains("look-around") =>
+            {
+                return Ok(CompiledRegex::skip());
+            }
+            Err(err) => return Err(err.into()),
+        };
         let mut cache = re.create_cache();
         Ok(CompiledRegex::compiled(move |test| -> TestResult {
             run_test(&re, &mut cache, test)

regex-automata/tests/lib.rs

@@ -65,6 +65,7 @@ fn suite() -> anyhow::Result<regex_test::RegexTests> {
     load!("fowler/basic");
     load!("fowler/nullsubexpr");
     load!("fowler/repetition");
+    load!("lookaround");
 
     Ok(tests)
 }

regex-automata/tests/nfa/thompson/backtrack/suite.rs

@@ -74,6 +74,10 @@ fn min_visited_capacity() -> Result<()> {
                 .configure(config_thompson(test))
                 .syntax(config_syntax(test))
                 .build_many(&regexes)?;
+            // TODO: remove once look-around is supported.
+            if nfa.lookaround_count() > 0 {
+                return Ok(CompiledRegex::skip());
+            }
             let mut builder = BoundedBacktracker::builder();
             if !configure_backtrack_builder(test, &mut builder) {
                 return Ok(CompiledRegex::skip());
@@ -105,6 +109,10 @@ fn compiler(
             return Ok(CompiledRegex::skip());
         }
         let re = builder.build_many(&regexes)?;
+        // TODO: remove once look-around is supported.
+        if re.get_nfa().lookaround_count() > 0 {
+            return Ok(CompiledRegex::skip());
+        }
         let mut cache = re.create_cache();
         Ok(CompiledRegex::compiled(move |test| -> TestResult {
             run_test(&re, &mut cache, test)

testdata/lookaround.toml

@@ -0,0 +1,59 @@
+[[test]]
+name = "basic lookbehind positive"
+regex = "(?<=b)a"
+haystack = "ba"
+matches = [[1, 2]]
+
+[[test]]
+name = "basic lookbehind negative"
+regex = "(?<!c)a"
+haystack = "ba"
+matches = [[1, 2]]
+
+[[test]]
+name = "basic lookbehind positive no match"
+regex = "(?<=c)a"
+haystack = "ba"
+matches = []
+
+[[test]]
+name = "basic lookbehind negative no match"
+regex = "(?<!b)a"
+haystack = "ba"
+matches = []
+
+[[test]]
+name = "lookbehind in quantifier non-repeating"
+regex = "(?:(?<=c)a)+"
+haystack = "badacacaea"
+matches = [[5,6], [7,8]]
+
+[[test]]
+name = "lookbehind in quantifier repeating"
+regex = "(?:(?<=a)a)+"
+haystack = "babaabaaabaaaac"
+matches = [[4,5], [7,9], [11,14]]
+
+[[test]]
+name = "lookbehind with quantifier"
+regex = "(?<=cb+)a"
+haystack = "acabacbacbbaea"
+matches = [[7,8], [11,12]]
+
+[[test]]
+name = "nested lookbehind"
+regex = "(?<=c[def]+(?<!fed))a"
+haystack = "cdaceacfeeacfedeacfeda"
+matches = [[2,3], [5,6], [10,11], [16,17]]
+
+[[test]]
+name = "lookbehind with alternation"
+regex = "(?<=def|abc)a"
+haystack = "defaabcadefbca"
+matches = [[3,4], [7,8]]
+
+[[test]]
+name = "lookbehind in alternation"
+regex = "(?<=c+)a|(?<=d+)a"
+haystack = "aabacadaccaddaea"
+matches = [[5,6], [7,8], [10,11], [13,14]]