move benchmarks out

benches/affine_transformations.rs

@@ -0,0 +1,28 @@
+#![feature(test)]
+extern crate test;
+use fimg::*;
+use test::Bencher;
+
+macro_rules! bench {
+    (fn $name: ident() { run $fn: ident() }) => {
+        #[bench]
+        fn $name(b: &mut Bencher) {
+            let mut img: Image<_, 4> = Image::new(
+                64.try_into().unwrap(),
+                64.try_into().unwrap(),
+                include_bytes!("4_180x180.imgbuf").to_vec(),
+            );
+            b.iter(|| {
+                for _ in 0..256 {
+                    img.flip_h();
+                }
+            });
+        }
+    };
+}
+
+bench!(fn flip_h() { run flip_h() });
+bench!(fn flip_v() { run flip_v() });
+bench!(fn rotate_90() { run rot_90() });
+bench!(fn rotate_180() { run rot_180() });
+bench!(fn rotate_270() { run rot_270() });

benches/overlays.rs

@@ -0,0 +1,63 @@
+#![feature(test)]
+extern crate test;
+use fimg::*;
+use test::Bencher;
+
+#[bench]
+fn overlay_3on3at(bench: &mut Bencher) {
+    let mut v = vec![0u8; 3 * 64 * 64];
+    let mut a: Image<_, 3> = Image::new(
+        64.try_into().unwrap(),
+        64.try_into().unwrap(),
+        v.as_mut_slice(),
+    );
+    let b = Image::<&[u8], 3>::new(
+        4.try_into().unwrap(),
+        4.try_into().unwrap(),
+        *&include_bytes!("3_4x4.imgbuf"),
+    );
+    bench.iter(|| unsafe {
+        for x in 0..16 {
+            for y in 0..16 {
+                a.overlay_at(&b, x * 4, y * 4);
+            }
+        }
+    });
+    assert_eq!(a.as_ref().buffer, include_bytes!("3x3_at_out.imgbuf"));
+}
+
+#[bench]
+fn overlay_4on3at(bench: &mut Bencher) {
+    let mut a: Image<_, 3> = Image::alloc(64, 64);
+    let b = Image::<&[u8], 4>::new(
+        4.try_into().unwrap(),
+        4.try_into().unwrap(),
+        *&include_bytes!("4_4x4.imgbuf"),
+    );
+    bench.iter(|| unsafe {
+        for x in 0..16 {
+            for y in 0..16 {
+                a.as_mut().overlay_at(&b, x * 4, y * 4);
+            }
+        }
+    });
+    assert_eq!(a.as_ref().buffer, include_bytes!("4x3_at_out.imgbuf"));
+}
+
+#[bench]
+fn overlay_4on4at(bench: &mut Bencher) {
+    let mut a: Image<_, 4> = Image::alloc(64, 64);
+    let b = Image::<&[u8], 4>::new(
+        4.try_into().unwrap(),
+        4.try_into().unwrap(),
+        *&include_bytes!("4_4x4.imgbuf"),
+    );
+    bench.iter(|| unsafe {
+        for x in 0..16 {
+            for y in 0..16 {
+                a.as_mut().overlay_at(&b, x * 4, y * 4);
+            }
+        }
+    });
+    assert_eq!(a.as_ref().buffer, include_bytes!("4x4_at_out.imgbuf"));
+}

src/affine.rs

@@ -219,35 +219,3 @@ mod tests {
         );
     }
 }
-
-#[cfg(test)]
-mod bench {
-    use super::*;
-    extern crate test;
-    use crate::Image;
-    use test::Bencher;
-
-    macro_rules! bench {
-        (fn $name: ident() { run $fn: ident() }) => {
-            #[bench]
-            fn $name(b: &mut Bencher) {
-                let mut img: Image<_, 4> = Image::new(
-                    64.try_into().unwrap(),
-                    64.try_into().unwrap(),
-                    include_bytes!("../test_data/4_180x180.imgbuf").to_vec(),
-                );
-                b.iter(|| {
-                    for _ in 0..256 {
-                        img.flip_h();
-                    }
-                });
-            }
-        };
-    }
-
-    bench!(fn flip_h() { run flip_h() });
-    bench!(fn flip_v() { run flip_v() });
-    bench!(fn rotate_90() { run rot_90() });
-    bench!(fn rotate_180() { run rot_180() });
-    bench!(fn rotate_270() { run rot_270() });
-}

src/overlay.rs

@@ -170,81 +170,3 @@ impl OverlayAt<Image<&[u8], 4>> for Image<&mut [u8], 4> {
         self
     }
 }
-
-#[cfg(test)]
-mod bench {
-    extern crate test;
-
-    use test::Bencher;
-
-    use super::*;
-    use crate::{FromRef, FromRefMut};
-
-    #[bench]
-    fn overlay_3on3at(bench: &mut Bencher) {
-        let mut v = vec![0u8; 3 * 64 * 64];
-        let mut a: Image<_, 3> = Image::new(
-            64.try_into().unwrap(),
-            64.try_into().unwrap(),
-            v.as_mut_slice(),
-        );
-        let b = Image::<&[u8], 3>::new(
-            4.try_into().unwrap(),
-            4.try_into().unwrap(),
-            *&include_bytes!("../test_data/3_4x4.imgbuf"),
-        );
-        bench.iter(|| unsafe {
-            for x in 0..16 {
-                for y in 0..16 {
-                    a.overlay_at(&b, x * 4, y * 4);
-                }
-            }
-        });
-        assert_eq!(
-            a.as_ref().buffer,
-            include_bytes!("../test_results/3x3_at_out.buf")
-        );
-    }
-
-    #[bench]
-    fn overlay_4on3at(bench: &mut Bencher) {
-        let mut a: Image<_, 3> = Image::alloc(64, 64);
-        let b = Image::<&[u8], 4>::new(
-            4.try_into().unwrap(),
-            4.try_into().unwrap(),
-            *&include_bytes!("../test_data/4_4x4.imgbuf"),
-        );
-        bench.iter(|| unsafe {
-            for x in 0..16 {
-                for y in 0..16 {
-                    a.as_mut().overlay_at(&b, x * 4, y * 4);
-                }
-            }
-        });
-        assert_eq!(
-            a.as_ref().buffer,
-            include_bytes!("../test_results/4x3_at_out.buf")
-        );
-    }
-
-    #[bench]
-    fn overlay_4on4at(bench: &mut Bencher) {
-        let mut a: Image<_, 4> = Image::alloc(64, 64);
-        let b = Image::<&[u8], 4>::new(
-            4.try_into().unwrap(),
-            4.try_into().unwrap(),
-            *&include_bytes!("../test_data/4_4x4.imgbuf"),
-        );
-        bench.iter(|| unsafe {
-            for x in 0..16 {
-                for y in 0..16 {
-                    a.as_mut().overlay_at(&b, x * 4, y * 4);
-                }
-            }
-        });
-        assert_eq!(
-            a.as_ref().buffer,
-            include_bytes!("../test_results/4x4_at_out.buf")
-        );
-    }
-}