Adding upstream version 0.70.1+ds1.upstream/0.70.1+ds1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 1415 insertions, 0 deletions

diff --git a/vendor/regex-automata/debian/patches/disable-tests-missing-testdata.patch b/vendor/regex-automata/debian/patches/disable-tests-missing-testdata.patch
new file mode 100644
index 0000000..318cd60
--- /dev/null
+++ b/vendor/regex-automata/debian/patches/disable-tests-missing-testdata.patch
@@ -0,0 +1,495 @@
+Index: regex-automata/tests/dfa/suite.rs
+===================================================================
+--- regex-automata.orig/tests/dfa/suite.rs
++++ regex-automata/tests/dfa/suite.rs
+@@ -16,12 +16,12 @@ use {
+     },
+ };
+ 
+-use crate::{create_input, suite, untestify_kind};
++use crate::{create_input, untestify_kind};
+ 
+ const EXPANSIONS: &[&str] = &["is_match", "find", "which"];
+ 
+ /// Runs the test suite with the default configuration.
+-#[test]
++/*#[test]
+ fn unminimized_default() -> Result<()> {
+     let builder = Regex::builder();
+     TestRunner::new()?
+@@ -30,11 +30,11 @@ fn unminimized_default() -> Result<()> {
+         .test_iter(suite()?.iter(), dense_compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Runs the test suite with the default configuration and a prefilter enabled,
+ /// if one can be built.
+-#[test]
++/*#[test]
+ fn unminimized_prefilter() -> Result<()> {
+     let my_compiler = |test: &RegexTest, regexes: &[String]| {
+         // Parse regexes as HIRs so we can get literals to build a prefilter.
+@@ -61,10 +61,10 @@ fn unminimized_prefilter() -> Result<()>
+         .test_iter(suite()?.iter(), my_compiler)
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Runs the test suite with start states specialized.
+-#[test]
++/*#[test]
+ fn unminimized_specialized_start_states() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dense(dense::Config::new().specialize_start_states(true));
+@@ -75,10 +75,10 @@ fn unminimized_specialized_start_states(
+         .test_iter(suite()?.iter(), dense_compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Runs the test suite with byte classes disabled.
+-#[test]
++/*#[test]
+ fn unminimized_no_byte_class() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dense(dense::Config::new().byte_classes(false));
+@@ -89,10 +89,10 @@ fn unminimized_no_byte_class() -> Result
+         .test_iter(suite()?.iter(), dense_compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Runs the test suite with NFA shrinking enabled.
+-#[test]
++/*#[test]
+ fn unminimized_nfa_shrink() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.thompson(thompson::Config::new().shrink(true));
+@@ -103,11 +103,11 @@ fn unminimized_nfa_shrink() -> Result<()
+         .test_iter(suite()?.iter(), dense_compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Runs the test suite on a minimized DFA with an otherwise default
+ /// configuration.
+-#[test]
++/*#[test]
+ fn minimized_default() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dense(dense::Config::new().minimize(true));
+@@ -117,10 +117,10 @@ fn minimized_default() -> Result<()> {
+         .test_iter(suite()?.iter(), dense_compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Runs the test suite on a minimized DFA with byte classes disabled.
+-#[test]
++/*#[test]
+ fn minimized_no_byte_class() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dense(dense::Config::new().minimize(true).byte_classes(false));
+@@ -131,10 +131,10 @@ fn minimized_no_byte_class() -> Result<(
+         .test_iter(suite()?.iter(), dense_compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Runs the test suite on a sparse unminimized DFA.
+-#[test]
++/*#[test]
+ fn sparse_unminimized_default() -> Result<()> {
+     let builder = Regex::builder();
+     TestRunner::new()?
+@@ -143,10 +143,10 @@ fn sparse_unminimized_default() -> Resul
+         .test_iter(suite()?.iter(), sparse_compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Runs the test suite on a sparse unminimized DFA with prefilters enabled.
+-#[test]
++/*#[test]
+ fn sparse_unminimized_prefilter() -> Result<()> {
+     let my_compiler = |test: &RegexTest, regexes: &[String]| {
+         // Parse regexes as HIRs so we can get literals to build a prefilter.
+@@ -176,11 +176,11 @@ fn sparse_unminimized_prefilter() -> Res
+         .test_iter(suite()?.iter(), my_compiler)
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Another basic sanity test that checks we can serialize and then deserialize
+ /// a regex, and that the resulting regex can be used for searching correctly.
+-#[test]
++/*#[test]
+ fn serialization_unminimized_default() -> Result<()> {
+     let builder = Regex::builder();
+     let my_compiler = |builder| {
+@@ -205,12 +205,12 @@ fn serialization_unminimized_default() -
+         .test_iter(suite()?.iter(), my_compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// A basic sanity test that checks we can serialize and then deserialize a
+ /// regex using sparse DFAs, and that the resulting regex can be used for
+ /// searching correctly.
+-#[test]
++/*#[test]
+ fn sparse_serialization_unminimized_default() -> Result<()> {
+     let builder = Regex::builder();
+     let my_compiler = |builder| {
+@@ -234,7 +234,7 @@ fn sparse_serialization_unminimized_defa
+         .test_iter(suite()?.iter(), my_compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ fn dense_compiler(
+     builder: dfa::regex::Builder,
+Index: regex-automata/tests/hybrid/suite.rs
+===================================================================
+--- regex-automata.orig/tests/hybrid/suite.rs
++++ regex-automata/tests/hybrid/suite.rs
+@@ -15,12 +15,12 @@ use {
+     },
+ };
+ 
+-use crate::{create_input, suite, untestify_kind};
++use crate::{create_input, untestify_kind};
+ 
+ const EXPANSIONS: &[&str] = &["is_match", "find", "which"];
+ 
+ /// Tests the default configuration of the hybrid NFA/DFA.
+-#[test]
++/*#[test]
+ fn default() -> Result<()> {
+     let builder = Regex::builder();
+     TestRunner::new()?
+@@ -30,10 +30,10 @@ fn default() -> Result<()> {
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the hybrid NFA/DFA with prefilters enabled.
+-#[test]
++/*#[test]
+ fn prefilter() -> Result<()> {
+     let my_compiler = |test: &RegexTest, regexes: &[String]| {
+         // Parse regexes as HIRs so we can get literals to build a prefilter.
+@@ -57,7 +57,7 @@ fn prefilter() -> Result<()> {
+         .test_iter(suite()?.iter(), my_compiler)
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the hybrid NFA/DFA with NFA shrinking enabled.
+ ///
+@@ -71,7 +71,7 @@ fn prefilter() -> Result<()> {
+ /// Nevertheless, we test to make sure everything is OK with NFA shrinking. As
+ /// a bonus, there are some tests we don't need to skip because they now fit in
+ /// the default cache capacity.
+-#[test]
++/*#[test]
+ fn nfa_shrink() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.thompson(thompson::Config::new().shrink(true));
+@@ -80,11 +80,11 @@ fn nfa_shrink() -> Result<()> {
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the hybrid NFA/DFA when 'starts_for_each_pattern' is enabled for all
+ /// tests.
+-#[test]
++/*#[test]
+ fn starts_for_each_pattern() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dfa(DFA::config().starts_for_each_pattern(true));
+@@ -95,10 +95,10 @@ fn starts_for_each_pattern() -> Result<(
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the hybrid NFA/DFA when 'specialize_start_states' is enabled.
+-#[test]
++/*#[test]
+ fn specialize_start_states() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dfa(DFA::config().specialize_start_states(true));
+@@ -109,14 +109,14 @@ fn specialize_start_states() -> Result<(
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the hybrid NFA/DFA when byte classes are disabled.
+ ///
+ /// N.B. Disabling byte classes doesn't avoid any indirection at search time.
+ /// All it does is cause every byte value to be its own distinct equivalence
+ /// class.
+-#[test]
++/*#[test]
+ fn no_byte_classes() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dfa(DFA::config().byte_classes(false));
+@@ -127,7 +127,7 @@ fn no_byte_classes() -> Result<()> {
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests that hybrid NFA/DFA never clears its cache for any test with the
+ /// default capacity.
+@@ -135,7 +135,7 @@ fn no_byte_classes() -> Result<()> {
+ /// N.B. If a regex suite test is added that causes the cache to be cleared,
+ /// then this should just skip that test. (Which can be done by calling the
+ /// 'blacklist' method on 'TestRunner'.)
+-#[test]
++/*#[test]
+ fn no_cache_clearing() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dfa(DFA::config().minimum_cache_clear_count(Some(0)));
+@@ -146,10 +146,10 @@ fn no_cache_clearing() -> Result<()> {
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the hybrid NFA/DFA when the minimum cache capacity is set.
+-#[test]
++/*#[test]
+ fn min_cache_capacity() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder
+@@ -159,7 +159,7 @@ fn min_cache_capacity() -> Result<()> {
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ fn compiler(
+     mut builder: regex::Builder,
+Index: regex-automata/tests/lib.rs
+===================================================================
+--- regex-automata.orig/tests/lib.rs
++++ regex-automata/tests/lib.rs
+@@ -28,7 +28,7 @@ mod meta;
+ #[cfg(any(feature = "nfa-backtrack", feature = "nfa-pikevm"))]
+ mod nfa;
+ 
+-fn suite() -> anyhow::Result<regex_test::RegexTests> {
++/*fn suite() -> anyhow::Result<regex_test::RegexTests> {
+     let _ = env_logger::try_init();
+ 
+     let mut tests = regex_test::RegexTests::new();
+@@ -66,7 +66,7 @@ fn suite() -> anyhow::Result<regex_test:
+     load!("fowler/repetition");
+ 
+     Ok(tests)
+-}
++}*/
+ 
+ /// Configure a regex_automata::Input with the given test configuration.
+ fn create_input<'h>(
+Index: regex-automata/tests/meta/suite.rs
+===================================================================
+--- regex-automata.orig/tests/meta/suite.rs
++++ regex-automata/tests/meta/suite.rs
+@@ -11,7 +11,7 @@ use {
+     },
+ };
+ 
+-use crate::{create_input, suite, testify_captures};
++use crate::{create_input, testify_captures};
+ 
+ const BLACKLIST: &[&str] = &[
+     // These 'earliest' tests are blacklisted because the meta searcher doesn't
+@@ -27,7 +27,7 @@ const BLACKLIST: &[&str] = &[
+ ];
+ 
+ /// Tests the default configuration of the meta regex engine.
+-#[test]
++/*#[test]
+ fn default() -> Result<()> {
+     let builder = Regex::builder();
+     let mut runner = TestRunner::new()?;
+@@ -37,10 +37,10 @@ fn default() -> Result<()> {
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the default configuration minus the full DFA.
+-#[test]
++/*#[test]
+ fn no_dfa() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.configure(Regex::config().dfa(false));
+@@ -51,10 +51,10 @@ fn no_dfa() -> Result<()> {
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the default configuration minus the full DFA and lazy DFA.
+-#[test]
++/*#[test]
+ fn no_dfa_hybrid() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.configure(Regex::config().dfa(false).hybrid(false));
+@@ -65,11 +65,11 @@ fn no_dfa_hybrid() -> Result<()> {
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the default configuration minus the full DFA, lazy DFA and one-pass
+ /// DFA.
+-#[test]
++/*#[test]
+ fn no_dfa_hybrid_onepass() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.configure(Regex::config().dfa(false).hybrid(false).onepass(false));
+@@ -80,11 +80,11 @@ fn no_dfa_hybrid_onepass() -> Result<()>
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the default configuration minus the full DFA, lazy DFA, one-pass
+ /// DFA and backtracker.
+-#[test]
++/*#[test]
+ fn no_dfa_hybrid_onepass_backtrack() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.configure(
+@@ -101,7 +101,7 @@ fn no_dfa_hybrid_onepass_backtrack() ->
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ fn compiler(
+     mut builder: meta::Builder,
+Index: regex-automata/tests/nfa/thompson/backtrack/suite.rs
+===================================================================
+--- regex-automata.orig/tests/nfa/thompson/backtrack/suite.rs
++++ regex-automata/tests/nfa/thompson/backtrack/suite.rs
+@@ -15,10 +15,10 @@ use {
+     },
+ };
+ 
+-use crate::{create_input, suite, testify_captures};
++use crate::{create_input, testify_captures};
+ 
+ /// Tests the default configuration of the bounded backtracker.
+-#[test]
++/*#[test]
+ fn default() -> Result<()> {
+     let builder = BoundedBacktracker::builder();
+     let mut runner = TestRunner::new()?;
+@@ -34,10 +34,10 @@ fn default() -> Result<()> {
+     runner.blacklist("expensive/backtrack-blow-visited-capacity");
+     runner.test_iter(suite()?.iter(), compiler(builder)).assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the backtracker with prefilters enabled.
+-#[test]
++/*#[test]
+ fn prefilter() -> Result<()> {
+     let my_compiler = |test: &RegexTest, regexes: &[String]| {
+         // Parse regexes as HIRs so we can get literals to build a prefilter.
+@@ -60,11 +60,11 @@ fn prefilter() -> Result<()> {
+     runner.blacklist("expensive/backtrack-blow-visited-capacity");
+     runner.test_iter(suite()?.iter(), my_compiler).assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the bounded backtracker when its visited capacity is set to its
+ /// minimum amount.
+-#[test]
++/*#[test]
+ fn min_visited_capacity() -> Result<()> {
+     let mut runner = TestRunner::new()?;
+     runner.expand(&["is_match", "find", "captures"], |test| test.compiles());
+@@ -95,7 +95,7 @@ fn min_visited_capacity() -> Result<()>
+         })
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+ fn compiler(
+     mut builder: backtrack::Builder,
+Index: regex-automata/tests/nfa/thompson/pikevm/suite.rs
+===================================================================
+--- regex-automata.orig/tests/nfa/thompson/pikevm/suite.rs
++++ regex-automata/tests/nfa/thompson/pikevm/suite.rs
+@@ -14,20 +14,20 @@ use {
+     },
+ };
+ 
+-use crate::{create_input, suite, testify_captures, untestify_kind};
++use crate::{create_input, testify_captures, untestify_kind};
+ 
+ /// Tests the default configuration of the hybrid NFA/DFA.
+-#[test]
++/*#[test]
+ fn default() -> Result<()> {
+     let builder = PikeVM::builder();
+     let mut runner = TestRunner::new()?;
+     runner.expand(&["is_match", "find", "captures"], |test| test.compiles());
+     runner.test_iter(suite()?.iter(), compiler(builder)).assert();
+     Ok(())
+-}
++}*/
+ 
+ /// Tests the PikeVM with prefilters enabled.
+-#[test]
++/*#[test]
+ fn prefilter() -> Result<()> {
+     let my_compiler = |test: &RegexTest, regexes: &[String]| {
+         // Parse regexes as HIRs so we can get literals to build a prefilter.
+@@ -48,7 +48,7 @@ fn prefilter() -> Result<()> {
+     runner.expand(&["is_match", "find", "captures"], |test| test.compiles());
+     runner.test_iter(suite()?.iter(), my_compiler).assert();
+     Ok(())
+-}
++}*/
+ 
+ fn compiler(
+     mut builder: pikevm::Builder,
diff --git a/vendor/regex-automata/debian/patches/relax-dep.diff b/vendor/regex-automata/debian/patches/relax-dep.diff
new file mode 100644
index 0000000..02fa61c
--- /dev/null
+++ b/vendor/regex-automata/debian/patches/relax-dep.diff
@@ -0,0 +1,19 @@
+Index: regex-automata/Cargo.toml
+===================================================================
+--- regex-automata.orig/Cargo.toml
++++ regex-automata/Cargo.toml
+@@ -70,11 +70,11 @@ default-features = false
+ version = "0.3.3"
+ 
+ [dev-dependencies.env_logger]
+-version = "0.9.3"
++version = "0.10"
+ features = [
+-    "atty",
++    "auto-color",
+     "humantime",
+-    "termcolor",
++    "color",
+ ]
+ default-features = false
+ 
diff --git a/vendor/regex-automata/debian/patches/remove-regex-test.patch b/vendor/regex-automata/debian/patches/remove-regex-test.patch
new file mode 100644
index 0000000..d7dbe7e
--- /dev/null
+++ b/vendor/regex-automata/debian/patches/remove-regex-test.patch
@@ -0,0 +1,898 @@
+Index: regex-automata/tests/dfa/onepass/suite.rs
+===================================================================
+--- regex-automata.orig/tests/dfa/onepass/suite.rs
++++ regex-automata/tests/dfa/onepass/suite.rs
+@@ -5,17 +5,17 @@ use {
+         nfa::thompson,
+         util::{iter, syntax},
+     },
+-    regex_test::{
++    /*regex_test::{
+         CompiledRegex, Match, RegexTest, SearchKind, Span, TestResult,
+         TestRunner,
+-    },
++    },*/
+ };
+ 
+-use crate::{create_input, suite, testify_captures, untestify_kind};
++//use crate::{create_input, testify_captures, untestify_kind};
+ 
+ const EXPANSIONS: &[&str] = &["is_match", "find", "captures"];
+ 
+-/// Tests the default configuration of the hybrid NFA/DFA.
++/* /// Tests the default configuration of the hybrid NFA/DFA.
+ #[test]
+ fn default() -> Result<()> {
+     let builder = DFA::builder();
+@@ -24,9 +24,9 @@ fn default() -> Result<()> {
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+-/// Tests the hybrid NFA/DFA when 'starts_for_each_pattern' is enabled for all
++/* /// Tests the hybrid NFA/DFA when 'starts_for_each_pattern' is enabled for all
+ /// tests.
+ #[test]
+ fn starts_for_each_pattern() -> Result<()> {
+@@ -37,9 +37,9 @@ fn starts_for_each_pattern() -> Result<(
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+-/// Tests the hybrid NFA/DFA when byte classes are disabled.
++/* /// Tests the hybrid NFA/DFA when byte classes are disabled.
+ ///
+ /// N.B. Disabling byte classes doesn't avoid any indirection at search time.
+ /// All it does is cause every byte value to be its own distinct equivalence
+@@ -53,9 +53,9 @@ fn no_byte_classes() -> Result<()> {
+         .test_iter(suite()?.iter(), compiler(builder))
+         .assert();
+     Ok(())
+-}
++}*/
+ 
+-fn compiler(
++/*fn compiler(
+     mut builder: onepass::Builder,
+ ) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+     move |test, regexes| {
+@@ -90,9 +90,9 @@ fn compiler(
+             run_test(&re, &mut cache, test)
+         }))
+     }
+-}
++}*/
+ 
+-fn run_test(
++/*fn run_test(
+     re: &DFA,
+     cache: &mut onepass::Cache,
+     test: &RegexTest,
+@@ -153,9 +153,9 @@ fn run_test(
+         },
+         name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+     }
+-}
++}*/
+ 
+-/// Configures the given regex builder with all relevant settings on the given
++/* /// Configures the given regex builder with all relevant settings on the given
+ /// regex test.
+ ///
+ /// If the regex test has a setting that is unsupported, then this returns
+@@ -178,20 +178,20 @@ fn configure_onepass_builder(
+         .syntax(config_syntax(test))
+         .thompson(config_thompson(test));
+     true
+-}
++}*/
+ 
+-/// Configuration of a Thompson NFA compiler from a regex test.
++/* /// Configuration of a Thompson NFA compiler from a regex test.
+ fn config_thompson(test: &RegexTest) -> thompson::Config {
+     let mut lookm = regex_automata::util::look::LookMatcher::new();
+     lookm.set_line_terminator(test.line_terminator());
+     thompson::Config::new().utf8(test.utf8()).look_matcher(lookm)
+-}
++}*/
+ 
+-/// Configuration of the regex parser from a regex test.
++/* /// Configuration of the regex parser from a regex test.
+ fn config_syntax(test: &RegexTest) -> syntax::Config {
+     syntax::Config::new()
+         .case_insensitive(test.case_insensitive())
+         .unicode(test.unicode())
+         .utf8(test.utf8())
+         .line_terminator(test.line_terminator())
+-}
++}*/
+Index: regex-automata/Cargo.toml
+===================================================================
+--- regex-automata.orig/Cargo.toml
++++ regex-automata/Cargo.toml
+@@ -82,9 +82,6 @@ default-features = false
+ version = "1.0.3"
+ default-features = false
+ 
+-[dev-dependencies.regex-test]
+-version = "0.1.0"
+-
+ [features]
+ alloc = []
+ default = [
+Index: regex-automata/tests/dfa/suite.rs
+===================================================================
+--- regex-automata.orig/tests/dfa/suite.rs
++++ regex-automata/tests/dfa/suite.rs
+@@ -10,18 +10,18 @@ use {
+         Anchored, Input, PatternSet,
+     },
+     regex_syntax::hir,
+-    regex_test::{
++    /*regex_test::{
+         CompiledRegex, Match, RegexTest, SearchKind, Span, TestResult,
+         TestRunner,
+-    },
++    },*/
+ };
+ 
+-use crate::{create_input, untestify_kind};
++//use crate::{create_input, untestify_kind};
+ 
+ const EXPANSIONS: &[&str] = &["is_match", "find", "which"];
+ 
+-/// Runs the test suite with the default configuration.
+-/*#[test]
++/* /// Runs the test suite with the default configuration.
++#[test]
+ fn unminimized_default() -> Result<()> {
+     let builder = Regex::builder();
+     TestRunner::new()?
+@@ -32,9 +32,9 @@ fn unminimized_default() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Runs the test suite with the default configuration and a prefilter enabled,
++/* /// Runs the test suite with the default configuration and a prefilter enabled,
+ /// if one can be built.
+-/*#[test]
++#[test]
+ fn unminimized_prefilter() -> Result<()> {
+     let my_compiler = |test: &RegexTest, regexes: &[String]| {
+         // Parse regexes as HIRs so we can get literals to build a prefilter.
+@@ -63,8 +63,8 @@ fn unminimized_prefilter() -> Result<()>
+     Ok(())
+ }*/
+ 
+-/// Runs the test suite with start states specialized.
+-/*#[test]
++/* /// Runs the test suite with start states specialized.
++#[test]
+ fn unminimized_specialized_start_states() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dense(dense::Config::new().specialize_start_states(true));
+@@ -77,8 +77,8 @@ fn unminimized_specialized_start_states(
+     Ok(())
+ }*/
+ 
+-/// Runs the test suite with byte classes disabled.
+-/*#[test]
++/* /// Runs the test suite with byte classes disabled.
++#[test]
+ fn unminimized_no_byte_class() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dense(dense::Config::new().byte_classes(false));
+@@ -91,8 +91,8 @@ fn unminimized_no_byte_class() -> Result
+     Ok(())
+ }*/
+ 
+-/// Runs the test suite with NFA shrinking enabled.
+-/*#[test]
++/* /// Runs the test suite with NFA shrinking enabled.
++#[test]
+ fn unminimized_nfa_shrink() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.thompson(thompson::Config::new().shrink(true));
+@@ -105,9 +105,9 @@ fn unminimized_nfa_shrink() -> Result<()
+     Ok(())
+ }*/
+ 
+-/// Runs the test suite on a minimized DFA with an otherwise default
++/* /// Runs the test suite on a minimized DFA with an otherwise default
+ /// configuration.
+-/*#[test]
++#[test]
+ fn minimized_default() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dense(dense::Config::new().minimize(true));
+@@ -119,8 +119,8 @@ fn minimized_default() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Runs the test suite on a minimized DFA with byte classes disabled.
+-/*#[test]
++/* /// Runs the test suite on a minimized DFA with byte classes disabled.
++#[test]
+ fn minimized_no_byte_class() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dense(dense::Config::new().minimize(true).byte_classes(false));
+@@ -133,8 +133,8 @@ fn minimized_no_byte_class() -> Result<(
+     Ok(())
+ }*/
+ 
+-/// Runs the test suite on a sparse unminimized DFA.
+-/*#[test]
++/* /// Runs the test suite on a sparse unminimized DFA.
++#[test]
+ fn sparse_unminimized_default() -> Result<()> {
+     let builder = Regex::builder();
+     TestRunner::new()?
+@@ -145,8 +145,7 @@ fn sparse_unminimized_default() -> Resul
+     Ok(())
+ }*/
+ 
+-/// Runs the test suite on a sparse unminimized DFA with prefilters enabled.
+-/*#[test]
++/* #[test]
+ fn sparse_unminimized_prefilter() -> Result<()> {
+     let my_compiler = |test: &RegexTest, regexes: &[String]| {
+         // Parse regexes as HIRs so we can get literals to build a prefilter.
+@@ -178,9 +177,9 @@ fn sparse_unminimized_prefilter() -> Res
+     Ok(())
+ }*/
+ 
+-/// Another basic sanity test that checks we can serialize and then deserialize
++/* /// Another basic sanity test that checks we can serialize and then deserialize
+ /// a regex, and that the resulting regex can be used for searching correctly.
+-/*#[test]
++#[test]
+ fn serialization_unminimized_default() -> Result<()> {
+     let builder = Regex::builder();
+     let my_compiler = |builder| {
+@@ -207,10 +206,10 @@ fn serialization_unminimized_default() -
+     Ok(())
+ }*/
+ 
+-/// A basic sanity test that checks we can serialize and then deserialize a
++/* /// A basic sanity test that checks we can serialize and then deserialize a
+ /// regex using sparse DFAs, and that the resulting regex can be used for
+ /// searching correctly.
+-/*#[test]
++#[test]
+ fn sparse_serialization_unminimized_default() -> Result<()> {
+     let builder = Regex::builder();
+     let my_compiler = |builder| {
+@@ -236,7 +235,7 @@ fn sparse_serialization_unminimized_defa
+     Ok(())
+ }*/
+ 
+-fn dense_compiler(
++/* fn dense_compiler(
+     builder: dfa::regex::Builder,
+ ) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+     compiler(builder, |_, _, re| {
+@@ -244,9 +243,9 @@ fn dense_compiler(
+             run_test(&re, test)
+         }))
+     })
+-}
++}*/
+ 
+-fn sparse_compiler(
++/*fn sparse_compiler(
+     builder: dfa::regex::Builder,
+ ) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+     compiler(builder, |builder, _, re| {
+@@ -257,9 +256,9 @@ fn sparse_compiler(
+             run_test(&re, test)
+         }))
+     })
+-}
++}*/
+ 
+-fn compiler(
++/* fn compiler(
+     mut builder: dfa::regex::Builder,
+     mut create_matcher: impl FnMut(
+         &dfa::regex::Builder,
+@@ -298,9 +297,9 @@ fn compiler(
+         }
+         create_matcher(&builder, pre, builder.build_many(&regexes)?)
+     }
+-}
++}*/
+ 
+-fn run_test<A: Automaton>(re: &Regex<A>, test: &RegexTest) -> TestResult {
++/*fn run_test<A: Automaton>(re: &Regex<A>, test: &RegexTest) -> TestResult {
+     let input = create_input(test);
+     match test.additional_name() {
+         "is_match" => TestResult::matched(re.is_match(input.earliest(true))),
+@@ -336,9 +335,9 @@ fn run_test<A: Automaton>(re: &Regex<A>,
+         },
+         name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+     }
+-}
++}*/
+ 
+-/// Configures the given regex builder with all relevant settings on the given
++/* /// Configures the given regex builder with all relevant settings on the given
+ /// regex test.
+ ///
+ /// If the regex test has a setting that is unsupported, then this returns
+@@ -383,18 +382,18 @@ fn config_thompson(test: &RegexTest) ->
+     let mut lookm = regex_automata::util::look::LookMatcher::new();
+     lookm.set_line_terminator(test.line_terminator());
+     thompson::Config::new().utf8(test.utf8()).look_matcher(lookm)
+-}
++}*/
+ 
+-/// Configuration of the regex syntax from a regex test.
++/* /// Configuration of the regex syntax from a regex test.
+ fn config_syntax(test: &RegexTest) -> syntax::Config {
+     syntax::Config::new()
+         .case_insensitive(test.case_insensitive())
+         .unicode(test.unicode())
+         .utf8(test.utf8())
+         .line_terminator(test.line_terminator())
+-}
++}*/
+ 
+-/// Execute an overlapping search, and for each match found, also find its
++/* /// Execute an overlapping search, and for each match found, also find its
+ /// overlapping starting positions.
+ ///
+ /// N.B. This routine used to be part of the crate API, but 1) it wasn't clear
+@@ -444,4 +443,4 @@ fn try_search_overlapping<A: Automaton>(
+         }
+     }
+     Ok(TestResult::matches(matches))
+-}
++}*/
+Index: regex-automata/tests/hybrid/suite.rs
+===================================================================
+--- regex-automata.orig/tests/hybrid/suite.rs
++++ regex-automata/tests/hybrid/suite.rs
+@@ -9,18 +9,18 @@ use {
+         util::{prefilter::Prefilter, syntax},
+         Anchored, Input, PatternSet,
+     },
+-    regex_test::{
++    /*regex_test::{
+         CompiledRegex, Match, RegexTest, SearchKind, Span, TestResult,
+         TestRunner,
+-    },
++    },*/
+ };
+ 
+-use crate::{create_input, untestify_kind};
++//use crate::{create_input, untestify_kind};
+ 
+ const EXPANSIONS: &[&str] = &["is_match", "find", "which"];
+ 
+-/// Tests the default configuration of the hybrid NFA/DFA.
+-/*#[test]
++/* /// Tests the default configuration of the hybrid NFA/DFA.
++#[test]
+ fn default() -> Result<()> {
+     let builder = Regex::builder();
+     TestRunner::new()?
+@@ -32,8 +32,8 @@ fn default() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Tests the hybrid NFA/DFA with prefilters enabled.
+-/*#[test]
++/* /// Tests the hybrid NFA/DFA with prefilters enabled.
++#[test]
+ fn prefilter() -> Result<()> {
+     let my_compiler = |test: &RegexTest, regexes: &[String]| {
+         // Parse regexes as HIRs so we can get literals to build a prefilter.
+@@ -59,7 +59,7 @@ fn prefilter() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Tests the hybrid NFA/DFA with NFA shrinking enabled.
++/* /// Tests the hybrid NFA/DFA with NFA shrinking enabled.
+ ///
+ /// This is *usually* not the configuration one wants for a lazy DFA. NFA
+ /// shrinking is mostly only advantageous when building a full DFA since it
+@@ -71,7 +71,7 @@ fn prefilter() -> Result<()> {
+ /// Nevertheless, we test to make sure everything is OK with NFA shrinking. As
+ /// a bonus, there are some tests we don't need to skip because they now fit in
+ /// the default cache capacity.
+-/*#[test]
++#[test]
+ fn nfa_shrink() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.thompson(thompson::Config::new().shrink(true));
+@@ -82,9 +82,9 @@ fn nfa_shrink() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Tests the hybrid NFA/DFA when 'starts_for_each_pattern' is enabled for all
++/* /// Tests the hybrid NFA/DFA when 'starts_for_each_pattern' is enabled for all
+ /// tests.
+-/*#[test]
++#[test]
+ fn starts_for_each_pattern() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dfa(DFA::config().starts_for_each_pattern(true));
+@@ -97,8 +97,8 @@ fn starts_for_each_pattern() -> Result<(
+     Ok(())
+ }*/
+ 
+-/// Tests the hybrid NFA/DFA when 'specialize_start_states' is enabled.
+-/*#[test]
++/* /// Tests the hybrid NFA/DFA when 'specialize_start_states' is enabled.
++#[test]
+ fn specialize_start_states() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dfa(DFA::config().specialize_start_states(true));
+@@ -111,12 +111,12 @@ fn specialize_start_states() -> Result<(
+     Ok(())
+ }*/
+ 
+-/// Tests the hybrid NFA/DFA when byte classes are disabled.
++/* /// Tests the hybrid NFA/DFA when byte classes are disabled.
+ ///
+ /// N.B. Disabling byte classes doesn't avoid any indirection at search time.
+ /// All it does is cause every byte value to be its own distinct equivalence
+ /// class.
+-/*#[test]
++#[test]
+ fn no_byte_classes() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dfa(DFA::config().byte_classes(false));
+@@ -129,13 +129,13 @@ fn no_byte_classes() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Tests that hybrid NFA/DFA never clears its cache for any test with the
++/* /// Tests that hybrid NFA/DFA never clears its cache for any test with the
+ /// default capacity.
+ ///
+ /// N.B. If a regex suite test is added that causes the cache to be cleared,
+ /// then this should just skip that test. (Which can be done by calling the
+ /// 'blacklist' method on 'TestRunner'.)
+-/*#[test]
++#[test]
+ fn no_cache_clearing() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.dfa(DFA::config().minimum_cache_clear_count(Some(0)));
+@@ -148,8 +148,8 @@ fn no_cache_clearing() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Tests the hybrid NFA/DFA when the minimum cache capacity is set.
+-/*#[test]
++/* /// Tests the hybrid NFA/DFA when the minimum cache capacity is set.
++#[test]
+ fn min_cache_capacity() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder
+@@ -161,7 +161,7 @@ fn min_cache_capacity() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-fn compiler(
++/* fn compiler(
+     mut builder: regex::Builder,
+ ) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+     move |test, regexes| {
+@@ -189,9 +189,9 @@ fn compiler(
+             run_test(&re, &mut cache, test)
+         }))
+     }
+-}
++} */
+ 
+-fn run_test(
++/*fn run_test(
+     re: &Regex,
+     cache: &mut regex::Cache,
+     test: &RegexTest,
+@@ -234,9 +234,9 @@ fn run_test(
+         },
+         name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+     }
+-}
++}*/
+ 
+-/// Configures the given regex builder with all relevant settings on the given
++/* /// Configures the given regex builder with all relevant settings on the given
+ /// regex test.
+ ///
+ /// If the regex test has a setting that is unsupported, then this returns
+@@ -266,25 +266,25 @@ fn configure_regex_builder(
+         .thompson(config_thompson(test))
+         .dfa(dfa_config);
+     true
+-}
++}*/
+ 
+-/// Configuration of a Thompson NFA compiler from a regex test.
++/* /// Configuration of a Thompson NFA compiler from a regex test.
+ fn config_thompson(test: &RegexTest) -> thompson::Config {
+     let mut lookm = regex_automata::util::look::LookMatcher::new();
+     lookm.set_line_terminator(test.line_terminator());
+     thompson::Config::new().utf8(test.utf8()).look_matcher(lookm)
+-}
++}*/
+ 
+-/// Configuration of the regex parser from a regex test.
++/* /// Configuration of the regex parser from a regex test.
+ fn config_syntax(test: &RegexTest) -> syntax::Config {
+     syntax::Config::new()
+         .case_insensitive(test.case_insensitive())
+         .unicode(test.unicode())
+         .utf8(test.utf8())
+         .line_terminator(test.line_terminator())
+-}
++}*/
+ 
+-/// Execute an overlapping search, and for each match found, also find its
++/* /// Execute an overlapping search, and for each match found, also find its
+ /// overlapping starting positions.
+ ///
+ /// N.B. This routine used to be part of the crate API, but 1) it wasn't clear
+@@ -344,4 +344,4 @@ fn try_search_overlapping(
+         }
+     }
+     Ok(TestResult::matches(matches))
+-}
++}*/
+Index: regex-automata/tests/lib.rs
+===================================================================
+--- regex-automata.orig/tests/lib.rs
++++ regex-automata/tests/lib.rs
+@@ -68,7 +68,7 @@ mod nfa;
+     Ok(tests)
+ }*/
+ 
+-/// Configure a regex_automata::Input with the given test configuration.
++/* /// Configure a regex_automata::Input with the given test configuration.
+ fn create_input<'h>(
+     test: &'h regex_test::RegexTest,
+ ) -> regex_automata::Input<'h> {
+@@ -79,9 +79,9 @@ fn create_input<'h>(
+     regex_automata::Input::new(test.haystack())
+         .range(bounds.start..bounds.end)
+         .anchored(anchored)
+-}
++}*/
+ 
+-/// Convert capture matches into the test suite's capture values.
++/* /// Convert capture matches into the test suite's capture values.
+ ///
+ /// The given captures must represent a valid match, where the first capturing
+ /// group has a non-None span. Otherwise this panics.
+@@ -97,9 +97,9 @@ fn testify_captures(
+     // group being non-None.
+     regex_test::Captures::new(caps.pattern().unwrap().as_usize(), spans)
+         .unwrap()
+-}
++}*/
+ 
+-/// Convert a test harness match kind to a regex-automata match kind. If
++/* /// Convert a test harness match kind to a regex-automata match kind. If
+ /// regex-automata doesn't support the harness kind, then `None` is returned.
+ fn untestify_kind(
+     kind: regex_test::MatchKind,
+@@ -111,4 +111,4 @@ fn untestify_kind(
+         }
+         regex_test::MatchKind::LeftmostLongest => None,
+     }
+-}
++}*/
+Index: regex-automata/tests/meta/suite.rs
+===================================================================
+--- regex-automata.orig/tests/meta/suite.rs
++++ regex-automata/tests/meta/suite.rs
+@@ -5,13 +5,13 @@ use {
+         util::syntax,
+         MatchKind, PatternSet,
+     },
+-    regex_test::{
++    /*regex_test::{
+         CompiledRegex, Match, RegexTest, SearchKind, Span, TestResult,
+         TestRunner,
+-    },
++    },*/
+ };
+ 
+-use crate::{create_input, testify_captures};
++//use crate::{create_input, testify_captures};
+ 
+ const BLACKLIST: &[&str] = &[
+     // These 'earliest' tests are blacklisted because the meta searcher doesn't
+@@ -26,8 +26,8 @@ const BLACKLIST: &[&str] = &[
+     "earliest/",
+ ];
+ 
+-/// Tests the default configuration of the meta regex engine.
+-/*#[test]
++/* /// Tests the default configuration of the meta regex engine.
++#[test]
+ fn default() -> Result<()> {
+     let builder = Regex::builder();
+     let mut runner = TestRunner::new()?;
+@@ -39,8 +39,8 @@ fn default() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Tests the default configuration minus the full DFA.
+-/*#[test]
++/* /// Tests the default configuration minus the full DFA.
++#[test]
+ fn no_dfa() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.configure(Regex::config().dfa(false));
+@@ -53,8 +53,8 @@ fn no_dfa() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Tests the default configuration minus the full DFA and lazy DFA.
+-/*#[test]
++/* /// Tests the default configuration minus the full DFA and lazy DFA.
++#[test]
+ fn no_dfa_hybrid() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.configure(Regex::config().dfa(false).hybrid(false));
+@@ -67,9 +67,9 @@ fn no_dfa_hybrid() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Tests the default configuration minus the full DFA, lazy DFA and one-pass
++/* /// Tests the default configuration minus the full DFA, lazy DFA and one-pass
+ /// DFA.
+-/*#[test]
++#[test]
+ fn no_dfa_hybrid_onepass() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.configure(Regex::config().dfa(false).hybrid(false).onepass(false));
+@@ -82,9 +82,9 @@ fn no_dfa_hybrid_onepass() -> Result<()>
+     Ok(())
+ }*/
+ 
+-/// Tests the default configuration minus the full DFA, lazy DFA, one-pass
++/* /// Tests the default configuration minus the full DFA, lazy DFA, one-pass
+ /// DFA and backtracker.
+-/*#[test]
++#[test]
+ fn no_dfa_hybrid_onepass_backtrack() -> Result<()> {
+     let mut builder = Regex::builder();
+     builder.configure(
+@@ -103,7 +103,7 @@ fn no_dfa_hybrid_onepass_backtrack() ->
+     Ok(())
+ }*/
+ 
+-fn compiler(
++/*fn compiler(
+     mut builder: meta::Builder,
+ ) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+     move |test, regexes| {
+@@ -115,9 +115,9 @@ fn compiler(
+             run_test(&re, test)
+         }))
+     }
+-}
++}*/
+ 
+-fn run_test(re: &Regex, test: &RegexTest) -> TestResult {
++/*fn run_test(re: &Regex, test: &RegexTest) -> TestResult {
+     let input = create_input(test);
+     match test.additional_name() {
+         "is_match" => TestResult::matched(re.is_match(input)),
+@@ -188,13 +188,13 @@ fn configure_meta_builder(
+         .line_terminator(test.line_terminator());
+     builder.configure(meta_config).syntax(config_syntax(test));
+     true
+-}
++}*/
+ 
+-/// Configuration of the regex parser from a regex test.
++/* /// Configuration of the regex parser from a regex test.
+ fn config_syntax(test: &RegexTest) -> syntax::Config {
+     syntax::Config::new()
+         .case_insensitive(test.case_insensitive())
+         .unicode(test.unicode())
+         .utf8(test.utf8())
+         .line_terminator(test.line_terminator())
+-}
++}*/
+Index: regex-automata/tests/nfa/thompson/backtrack/suite.rs
+===================================================================
+--- regex-automata.orig/tests/nfa/thompson/backtrack/suite.rs
++++ regex-automata/tests/nfa/thompson/backtrack/suite.rs
+@@ -9,16 +9,16 @@ use {
+         util::{prefilter::Prefilter, syntax},
+         Input,
+     },
+-    regex_test::{
++    /*regex_test::{
+         CompiledRegex, Match, MatchKind, RegexTest, SearchKind, Span,
+         TestResult, TestRunner,
+-    },
++    },*/
+ };
+ 
+-use crate::{create_input, testify_captures};
++//use crate::{create_input, testify_captures};
+ 
+-/// Tests the default configuration of the bounded backtracker.
+-/*#[test]
++/* /// Tests the default configuration of the bounded backtracker.
++#[test]
+ fn default() -> Result<()> {
+     let builder = BoundedBacktracker::builder();
+     let mut runner = TestRunner::new()?;
+@@ -36,8 +36,8 @@ fn default() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Tests the backtracker with prefilters enabled.
+-/*#[test]
++/* /// Tests the backtracker with prefilters enabled.
++#[test]
+ fn prefilter() -> Result<()> {
+     let my_compiler = |test: &RegexTest, regexes: &[String]| {
+         // Parse regexes as HIRs so we can get literals to build a prefilter.
+@@ -62,9 +62,9 @@ fn prefilter() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Tests the bounded backtracker when its visited capacity is set to its
++/* /// Tests the bounded backtracker when its visited capacity is set to its
+ /// minimum amount.
+-/*#[test]
++#[test]
+ fn min_visited_capacity() -> Result<()> {
+     let mut runner = TestRunner::new()?;
+     runner.expand(&["is_match", "find", "captures"], |test| test.compiles());
+@@ -97,7 +97,7 @@ fn min_visited_capacity() -> Result<()>
+     Ok(())
+ }*/
+ 
+-fn compiler(
++/* fn compiler(
+     mut builder: backtrack::Builder,
+ ) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+     move |test, regexes| {
+@@ -110,9 +110,9 @@ fn compiler(
+             run_test(&re, &mut cache, test)
+         }))
+     }
+-}
++}*/
+ 
+-fn run_test(
++/*fn run_test(
+     re: &BoundedBacktracker,
+     cache: &mut backtrack::Cache,
+     test: &RegexTest,
+@@ -194,20 +194,20 @@ fn configure_backtrack_builder(
+         .syntax(config_syntax(test))
+         .thompson(config_thompson(test));
+     true
+-}
++}*/
+ 
+-/// Configuration of a Thompson NFA compiler from a regex test.
++/* /// Configuration of a Thompson NFA compiler from a regex test.
+ fn config_thompson(test: &RegexTest) -> thompson::Config {
+     let mut lookm = regex_automata::util::look::LookMatcher::new();
+     lookm.set_line_terminator(test.line_terminator());
+     thompson::Config::new().utf8(test.utf8()).look_matcher(lookm)
+-}
++}*/
+ 
+-/// Configuration of the regex parser from a regex test.
++/* /// Configuration of the regex parser from a regex test.
+ fn config_syntax(test: &RegexTest) -> syntax::Config {
+     syntax::Config::new()
+         .case_insensitive(test.case_insensitive())
+         .unicode(test.unicode())
+         .utf8(test.utf8())
+         .line_terminator(test.line_terminator())
+-}
++}*/
+Index: regex-automata/tests/nfa/thompson/pikevm/suite.rs
+===================================================================
+--- regex-automata.orig/tests/nfa/thompson/pikevm/suite.rs
++++ regex-automata/tests/nfa/thompson/pikevm/suite.rs
+@@ -8,16 +8,16 @@ use {
+         util::{prefilter::Prefilter, syntax},
+         PatternSet,
+     },
+-    regex_test::{
++    /*regex_test::{
+         CompiledRegex, Match, RegexTest, SearchKind, Span, TestResult,
+         TestRunner,
+-    },
++    },*/
+ };
+ 
+-use crate::{create_input, testify_captures, untestify_kind};
++//use crate::{create_input, testify_captures, untestify_kind};
+ 
+-/// Tests the default configuration of the hybrid NFA/DFA.
+-/*#[test]
++/* /// Tests the default configuration of the hybrid NFA/DFA.
++#[test]
+ fn default() -> Result<()> {
+     let builder = PikeVM::builder();
+     let mut runner = TestRunner::new()?;
+@@ -26,8 +26,8 @@ fn default() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-/// Tests the PikeVM with prefilters enabled.
+-/*#[test]
++/* /// Tests the PikeVM with prefilters enabled.
++#[test]
+ fn prefilter() -> Result<()> {
+     let my_compiler = |test: &RegexTest, regexes: &[String]| {
+         // Parse regexes as HIRs so we can get literals to build a prefilter.
+@@ -50,7 +50,7 @@ fn prefilter() -> Result<()> {
+     Ok(())
+ }*/
+ 
+-fn compiler(
++/* fn compiler(
+     mut builder: pikevm::Builder,
+ ) -> impl FnMut(&RegexTest, &[String]) -> Result<CompiledRegex> {
+     move |test, regexes| {
+@@ -63,9 +63,9 @@ fn compiler(
+             run_test(&re, &mut cache, test)
+         }))
+     }
+-}
++}*/
+ 
+-fn run_test(
++/*fn run_test(
+     re: &PikeVM,
+     cache: &mut pikevm::Cache,
+     test: &RegexTest,
+@@ -122,9 +122,9 @@ fn run_test(
+         },
+         name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+     }
+-}
++}*/
+ 
+-/// Configures the given regex builder with all relevant settings on the given
++/* /// Configures the given regex builder with all relevant settings on the given
+ /// regex test.
+ ///
+ /// If the regex test has a setting that is unsupported, then this returns
+@@ -143,20 +143,20 @@ fn configure_pikevm_builder(
+         .syntax(config_syntax(test))
+         .thompson(config_thompson(test));
+     true
+-}
++}*/
+ 
+-/// Configuration of a Thompson NFA compiler from a regex test.
++/* /// Configuration of a Thompson NFA compiler from a regex test.
+ fn config_thompson(test: &RegexTest) -> thompson::Config {
+     let mut lookm = regex_automata::util::look::LookMatcher::new();
+     lookm.set_line_terminator(test.line_terminator());
+     thompson::Config::new().utf8(test.utf8()).look_matcher(lookm)
+-}
++}*/
+ 
+-/// Configuration of the regex parser from a regex test.
++/* /// Configuration of the regex parser from a regex test.
+ fn config_syntax(test: &RegexTest) -> syntax::Config {
+     syntax::Config::new()
+         .case_insensitive(test.case_insensitive())
+         .unicode(test.unicode())
+         .utf8(test.utf8())
+         .line_terminator(test.line_terminator())
+-}
++}*/
diff --git a/vendor/regex-automata/debian/patches/series b/vendor/regex-automata/debian/patches/series
new file mode 100644
index 0000000..b0c6f80
--- /dev/null
+++ b/vendor/regex-automata/debian/patches/series
@@ -0,0 +1,3 @@
+#disable-tests-missing-testdata.patch
+#remove-regex-test.patch
+#relax-dep.diff