Refactor unit tests

marmeladema · marmeladema · commit dbb1dedbbd7c · 2022-04-14T18:00:09.000+02:00
diff --git a/src/aarch64.rs b/src/aarch64.rs
@@ -285,3 +285,20 @@ impl<N: Needle> Searcher<N> for NeonSearcher<N> {
         self.position
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::NeonSearcher;
+
+    impl crate::tests::TestSearcher for NeonSearcher<&[u8]> {
+        fn with_position(needle: &'static [u8], position: usize) -> NeonSearcher<&[u8]> {
+            unsafe { NeonSearcher::with_position(needle, position) }
+        }
+
+        fn search_in(&self, haystack: &[u8]) -> bool {
+            unsafe { NeonSearcher::search_in(self, haystack) }
+        }
+    }
+
+    crate::generate_tests!(neon_searcher, NeonSearcher);
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -360,174 +360,182 @@ mod tests {
         assert_eq!(<&[u8] as Needle>::SIZE, None);
     }
 
-    fn search(haystack: &[u8], needle: &[u8]) -> bool {
+    pub(crate) trait TestSearcher {
+        fn with_position(needle: &'static [u8], position: usize) -> Self;
+        fn search_in(&self, haystack: &[u8]) -> bool;
+    }
+
+    fn search<S: TestSearcher>(haystack: &[u8], needle: &'static [u8]) -> bool {
         let result = haystack
             .windows(needle.len())
             .any(|window| window == needle);
 
         for position in 0..needle.len() {
-            cfg_if::cfg_if! {
-                if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] {
-                    use crate::x86::{Avx2Searcher, DynamicAvx2Searcher};
-
-                    let searcher =  unsafe { Avx2Searcher::with_position(needle, position) };
-                    assert_eq!(unsafe { searcher.search_in(haystack) }, result);
-
-                    let searcher =  unsafe { DynamicAvx2Searcher::with_position(needle, position) };
-                    assert_eq!(unsafe { searcher.search_in(haystack) }, result);
-                } else if #[cfg(target_arch = "wasm32")] {
-                    use crate::wasm32::Wasm32Searcher;
-
-                    let searcher = unsafe { Wasm32Searcher::with_position(needle, position) };
-                    assert_eq!(unsafe { searcher.search_in(haystack) }, result);
-                } else if #[cfg(target_arch = "aarch64")] {
-                    use crate::aarch64::NeonSearcher;
-
-                    let searcher = unsafe { NeonSearcher::with_position(needle, position) };
-                    assert_eq!(unsafe { searcher.search_in(haystack) }, result);
-                } else if #[cfg(not(feature = "stdsimd"))] {
-                    compile_error!("Unsupported architecture");
+            let searcher = S::with_position(needle, position);
+            assert_eq!(searcher.search_in(haystack), result);
+        }
+
+        result
+    }
+
+    #[macro_export]
+    macro_rules! generate_tests {
+        ($mod: ident, $name:ident) => {
+            mod $mod {
+                use super::$name;
+
+                #[test]
+                fn test_search_same() {
+                    $crate::tests::search_same::<$name<&[u8]>>();
                 }
-            }
 
-            cfg_if::cfg_if! {
-                if #[cfg(feature = "stdsimd")] {
-                    use crate::stdsimd::StdSimdSearcher;
+                #[test]
+                fn test_search_different() {
+                    $crate::tests::search_different::<$name<&[u8]>>();
+                }
 
-                    let searcher = StdSimdSearcher::with_position(needle, position);
-                    assert_eq!(searcher.search_in(haystack), result);
+                #[test]
+                fn test_search_prefix() {
+                    $crate::tests::search_prefix::<$name<&[u8]>>();
                 }
-            }
-        }
 
-        result
+                #[test]
+                fn test_search_suffix() {
+                    $crate::tests::search_suffix::<$name<&[u8]>>();
+                }
+
+                #[test]
+                fn test_search_multiple() {
+                    $crate::tests::search_multiple::<$name<&[u8]>>();
+                }
+
+                #[test]
+                fn test_search_middle() {
+                    $crate::tests::search_middle::<$name<&[u8]>>();
+                }
+            }
+        };
     }
 
-    #[test]
-    fn search_same() {
-        assert!(search(b"x", b"x"));
+    pub(crate) fn search_same<S: TestSearcher>() {
+        assert!(search::<S>(b"x", b"x"));
 
-        assert!(search(b"xy", b"xy"));
+        assert!(search::<S>(b"xy", b"xy"));
 
-        assert!(search(b"foo", b"foo"));
+        assert!(search::<S>(b"foo", b"foo"));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit",
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit"
         ));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas commodo posuere orci a consectetur. Ut mattis turpis ut auctor consequat. Aliquam iaculis fringilla mi, nec aliquet purus",
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas commodo posuere orci a consectetur. Ut mattis turpis ut auctor consequat. Aliquam iaculis fringilla mi, nec aliquet purus"
         ));
     }
 
-    #[test]
-    fn search_different() {
-        assert!(!search(b"x", b"y"));
+    pub(crate) fn search_different<S: TestSearcher>() {
+        assert!(!search::<S>(b"x", b"y"));
 
-        assert!(!search(b"xy", b"xz"));
+        assert!(!search::<S>(b"xy", b"xz"));
 
-        assert!(!search(b"bar", b"foo"));
+        assert!(!search::<S>(b"bar", b"foo"));
 
-        assert!(!search(
+        assert!(!search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit",
             b"foo"
         ));
 
-        assert!(!search(
+        assert!(!search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas commodo posuere orci a consectetur. Ut mattis turpis ut auctor consequat. Aliquam iaculis fringilla mi, nec aliquet purus",
             b"foo"
         ));
 
-        assert!(!search(
+        assert!(!search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas commodo posuere orci a consectetur. Ut mattis turpis ut auctor consequat. Aliquam iaculis fringilla mi, nec aliquet purus",
             b"foo bar baz qux quux quuz corge grault garply waldo fred plugh xyzzy thud"
         ));
     }
 
-    #[test]
-    fn search_prefix() {
-        assert!(search(b"xy", b"x"));
+    pub(crate) fn search_prefix<S: TestSearcher>() {
+        assert!(search::<S>(b"xy", b"x"));
 
-        assert!(search(b"foobar", b"foo"));
+        assert!(search::<S>(b"foobar", b"foo"));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit",
             b"Lorem"
         ));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas commodo posuere orci a consectetur. Ut mattis turpis ut auctor consequat. Aliquam iaculis fringilla mi, nec aliquet purus",
             b"Lorem"
         ));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas commodo posuere orci a consectetur. Ut mattis turpis ut auctor consequat. Aliquam iaculis fringilla mi, nec aliquet purus",
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit"
         ));
     }
 
-    #[test]
-    fn search_suffix() {
-        assert!(search(b"xy", b"y"));
+    pub(crate) fn search_suffix<S: TestSearcher>() {
+        assert!(search::<S>(b"xy", b"y"));
 
-        assert!(search(b"foobar", b"bar"));
+        assert!(search::<S>(b"foobar", b"bar"));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit",
             b"elit"
         ));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas commodo posuere orci a consectetur. Ut mattis turpis ut auctor consequat. Aliquam iaculis fringilla mi, nec aliquet purus",
             b"purus"
         ));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas commodo posuere orci a consectetur. Ut mattis turpis ut auctor consequat. Aliquam iaculis fringilla mi, nec aliquet purus",
             b"Aliquam iaculis fringilla mi, nec aliquet purus"
         ));
     }
 
-    #[test]
-    fn search_multiple() {
-        assert!(search(b"xx", b"x"));
+    pub(crate) fn search_multiple<S: TestSearcher>() {
+        assert!(search::<S>(b"xx", b"x"));
 
-        assert!(search(b"xyxy", b"xy"));
+        assert!(search::<S>(b"xyxy", b"xy"));
 
-        assert!(search(b"foobarfoo", b"foo"));
+        assert!(search::<S>(b"foobarfoo", b"foo"));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit",
             b"it"
         ));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas commodo posuere orci a consectetur. Ut mattis turpis ut auctor consequat. Aliquam iaculis fringilla mi, nec aliquet purus",
             b"conse"
         ));
     }
 
-    #[test]
-    fn search_middle() {
-        assert!(search(b"xyz", b"y"));
+    pub(crate) fn search_middle<S: TestSearcher>() {
+        assert!(search::<S>(b"xyz", b"y"));
 
-        assert!(search(b"wxyz", b"xy"));
+        assert!(search::<S>(b"wxyz", b"xy"));
 
-        assert!(search(b"foobarfoo", b"bar"));
+        assert!(search::<S>(b"foobarfoo", b"bar"));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit",
             b"consectetur"
         ));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas commodo posuere orci a consectetur. Ut mattis turpis ut auctor consequat. Aliquam iaculis fringilla mi, nec aliquet purus",
             b"orci"
         ));
 
-        assert!(search(
+        assert!(search::<S>(
             b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas commodo posuere orci a consectetur. Ut mattis turpis ut auctor consequat. Aliquam iaculis fringilla mi, nec aliquet purus",
             b"Maecenas commodo posuere orci a consectetur"
         ));
diff --git a/src/stdsimd.rs b/src/stdsimd.rs
@@ -167,3 +167,20 @@ impl<N: Needle> StdSimdSearcher<N> {
         self.inlined_search_in(haystack)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::StdSimdSearcher;
+
+    impl crate::tests::TestSearcher for StdSimdSearcher<&[u8]> {
+        fn with_position(needle: &'static [u8], position: usize) -> StdSimdSearcher<&[u8]> {
+            StdSimdSearcher::with_position(needle, position)
+        }
+
+        fn search_in(&self, haystack: &[u8]) -> bool {
+            StdSimdSearcher::search_in(self, haystack)
+        }
+    }
+
+    crate::generate_tests!(std_simd_searcher, StdSimdSearcher);
+}
diff --git a/src/wasm32.rs b/src/wasm32.rs
@@ -270,3 +270,20 @@ impl<N: Needle> Wasm32Searcher<N> {
         self.inlined_search_in(haystack)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Wasm32Searcher;
+
+    impl crate::tests::TestSearcher for Wasm32Searcher<&[u8]> {
+        fn with_position(needle: &'static [u8], position: usize) -> Wasm32Searcher<&[u8]> {
+            unsafe { Wasm32Searcher::with_position(needle, position) }
+        }
+
+        fn search_in(&self, haystack: &[u8]) -> bool {
+            unsafe { Wasm32Searcher::search_in(self, haystack) }
+        }
+    }
+
+    crate::generate_tests!(wasm32_searcher, Wasm32Searcher);
+}
diff --git a/src/x86.rs b/src/x86.rs
@@ -583,4 +583,28 @@ mod tests {
         assert_eq!(size_of::<DynamicAvx2Searcher::<[u8; 16]>>(), 160);
         assert_eq!(size_of::<DynamicAvx2Searcher::<Box<[u8]>>>(), 160);
     }
+
+    impl crate::tests::TestSearcher for Avx2Searcher<&[u8]> {
+        fn with_position(needle: &'static [u8], position: usize) -> Avx2Searcher<&[u8]> {
+            unsafe { Avx2Searcher::with_position(needle, position) }
+        }
+
+        fn search_in(&self, haystack: &[u8]) -> bool {
+            unsafe { Avx2Searcher::search_in(self, haystack) }
+        }
+    }
+
+    crate::generate_tests!(avx2_searcher, Avx2Searcher);
+
+    impl crate::tests::TestSearcher for DynamicAvx2Searcher<&[u8]> {
+        fn with_position(needle: &'static [u8], position: usize) -> DynamicAvx2Searcher<&[u8]> {
+            unsafe { DynamicAvx2Searcher::with_position(needle, position) }
+        }
+
+        fn search_in(&self, haystack: &[u8]) -> bool {
+            unsafe { DynamicAvx2Searcher::search_in(self, haystack) }
+        }
+    }
+
+    crate::generate_tests!(dynamic_avx2_searcher, DynamicAvx2Searcher);
 }
