cargo fmt

Author: droundy

examples/array_refs.rs

@@ -2,12 +2,12 @@
 extern crate arrayref;
 
 fn main() {
-    let x = [0,1,2,3,4,5,6,7,8,9];
-    let (a,b,c) = array_refs!(&x, 2, 3, 5);
+    let x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    let (a, b, c) = array_refs!(&x, 2, 3, 5);
     assert_eq!(2, a.len());
     assert_eq!(3, b.len());
     assert_eq!(5, c.len());
-    assert_eq!(*a, [0,1]);
-    assert_eq!(*b, [2,3,4]);
-    assert_eq!(*c, [5,6,7,8,9]);
+    assert_eq!(*a, [0, 1]);
+    assert_eq!(*b, [2, 3, 4]);
+    assert_eq!(*c, [5, 6, 7, 8, 9]);
 }

examples/array_refs_with_const.rs

@@ -7,12 +7,12 @@ const SIZE_B: usize = 3;
 const SIZE_C: usize = 5;
 
 fn main() {
-    let x: [u8; SIZE] = [0,1,2,3,4,5,6,7,8,9];
-    let (a,b,c) = array_refs!(&x, SIZE_A, SIZE_B, SIZE_C);
+    let x: [u8; SIZE] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    let (a, b, c) = array_refs!(&x, SIZE_A, SIZE_B, SIZE_C);
     assert_eq!(SIZE_A, a.len());
     assert_eq!(SIZE_B, b.len());
     assert_eq!(SIZE_C, c.len());
-    assert_eq!(*a, [0,1]);
-    assert_eq!(*b, [2,3,4]);
-    assert_eq!(*c, [5,6,7,8,9]);
+    assert_eq!(*a, [0, 1]);
+    assert_eq!(*b, [2, 3, 4]);
+    assert_eq!(*c, [5, 6, 7, 8, 9]);
 }

examples/simple-case.rs

@@ -10,6 +10,6 @@ fn main() {
     x[20] = 1;
     x[21] = 4;
     x[24] = 3;
-    x[0] = add_three(array_mut_ref![x,20,3]);
+    x[0] = add_three(array_mut_ref![x, 20, 3]);
     assert_eq!(x[0], 8);
 }

src/lib.rs

@@ -62,13 +62,13 @@ macro_rules! array_ref {
                 &*(slice.as_ptr() as *const [_; $len])
             }
             let offset = $offset;
-            let slice = & $arr[offset..offset + $len];
+            let slice = &$arr[offset..offset + $len];
             #[allow(unused_unsafe)]
             unsafe {
                 as_array(slice)
             }
         }
-    }}
+    }};
 }
 
 /// You can use `array_refs` to generate a series of array references
@@ -174,7 +174,6 @@ macro_rules! array_refs {
     }}
 }
 
-
 /// You can use `mut_array_refs` to generate a series of mutable array
 /// references to an input mutable array reference.  The idea is if
 /// you want to break an array into a series of contiguous and
@@ -327,210 +326,203 @@ macro_rules! array_mut_ref {
                 as_array(slice)
             }
         }
-    }}
+    }};
 }
 
-
 #[allow(clippy::all)]
 #[cfg(test)]
 mod test {
 
-extern crate quickcheck;
+    extern crate quickcheck;
 
-use std::vec::Vec;
+    use std::vec::Vec;
 
-// use super::*;
+    // use super::*;
 
-#[test]
-#[should_panic]
-fn checks_bounds() {
-    let foo: [u8; 11] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    let bar = array_ref!(foo, 1, 11);
-    println!("I am checking that I can dereference bar[0] = {}", bar[0]);
-}
-
-#[test]
-fn simple_case_works() {
-    fn check(expected: [u8; 3], actual: &[u8; 3]) {
-        for (e, a) in (&expected).iter().zip(actual.iter()) {
-            assert_eq!(e, a)
-        }
-    }
-    let mut foo: [u8; 11] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    {
-        let bar = array_ref!(foo, 2, 3);
-        check([2, 3, 4], bar);
+    #[test]
+    #[should_panic]
+    fn checks_bounds() {
+        let foo: [u8; 11] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        let bar = array_ref!(foo, 1, 11);
+        println!("I am checking that I can dereference bar[0] = {}", bar[0]);
     }
-    check([0, 1, 2], array_ref!(foo, 0, 3));
-    fn zero2(x: &mut [u8; 2]) {
-        x[0] = 0;
-        x[1] = 0;
-    }
-    zero2(array_mut_ref!(foo, 8, 2));
-    check([0, 0, 10], array_ref!(foo, 8, 3));
-}
-
 
-#[test]
-fn check_array_ref_5() {
-    fn f(data: Vec<u8>, offset: usize) -> quickcheck::TestResult {
-        if data.len() < offset + 5 {
-            return quickcheck::TestResult::discard();
+    #[test]
+    fn simple_case_works() {
+        fn check(expected: [u8; 3], actual: &[u8; 3]) {
+            for (e, a) in (&expected).iter().zip(actual.iter()) {
+                assert_eq!(e, a)
+            }
         }
-        let out = array_ref!(data, offset, 5);
-        quickcheck::TestResult::from_bool(out.len() == 5)
-    }
-    quickcheck::quickcheck(f as fn(Vec<u8>, usize) -> quickcheck::TestResult);
-}
-
-#[test]
-fn check_array_ref_out_of_bounds_5() {
-    fn f(data: Vec<u8>, offset: usize) -> quickcheck::TestResult {
-        if data.len() >= offset + 5 {
-            return quickcheck::TestResult::discard();
+        let mut foo: [u8; 11] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        {
+            let bar = array_ref!(foo, 2, 3);
+            check([2, 3, 4], bar);
+        }
+        check([0, 1, 2], array_ref!(foo, 0, 3));
+        fn zero2(x: &mut [u8; 2]) {
+            x[0] = 0;
+            x[1] = 0;
         }
-        quickcheck::TestResult::must_fail(move || {
-            array_ref!(data, offset, 5);
-        })
+        zero2(array_mut_ref!(foo, 8, 2));
+        check([0, 0, 10], array_ref!(foo, 8, 3));
     }
-    quickcheck::quickcheck(f as fn(Vec<u8>, usize) -> quickcheck::TestResult);
-}
 
-#[test]
-fn check_array_mut_ref_7() {
-    fn f(mut data: Vec<u8>, offset: usize) -> quickcheck::TestResult {
-        if data.len() < offset + 7 {
-            return quickcheck::TestResult::discard();
+    #[test]
+    fn check_array_ref_5() {
+        fn f(data: Vec<u8>, offset: usize) -> quickcheck::TestResult {
+            if data.len() < offset + 5 {
+                return quickcheck::TestResult::discard();
+            }
+            let out = array_ref!(data, offset, 5);
+            quickcheck::TestResult::from_bool(out.len() == 5)
         }
-        let out = array_mut_ref!(data, offset, 7);
-        out[6] = 3;
-        quickcheck::TestResult::from_bool(out.len() == 7)
+        quickcheck::quickcheck(f as fn(Vec<u8>, usize) -> quickcheck::TestResult);
     }
-    quickcheck::quickcheck(f as fn(Vec<u8>, usize) -> quickcheck::TestResult);
-}
 
-
-#[test]
-fn check_array_mut_ref_out_of_bounds_32() {
-    fn f(mut data: Vec<u8>, offset: usize) -> quickcheck::TestResult {
-        if data.len() >= offset + 32 {
-            return quickcheck::TestResult::discard();
+    #[test]
+    fn check_array_ref_out_of_bounds_5() {
+        fn f(data: Vec<u8>, offset: usize) -> quickcheck::TestResult {
+            if data.len() >= offset + 5 {
+                return quickcheck::TestResult::discard();
+            }
+            quickcheck::TestResult::must_fail(move || {
+                array_ref!(data, offset, 5);
+            })
         }
-        quickcheck::TestResult::must_fail(move || {
-            array_mut_ref!(data, offset, 32);
-        })
+        quickcheck::quickcheck(f as fn(Vec<u8>, usize) -> quickcheck::TestResult);
     }
-    quickcheck::quickcheck(f as fn(Vec<u8>, usize) -> quickcheck::TestResult);
-}
 
-
-#[test]
-fn test_5_array_refs() {
-    let mut data: [usize; 128] = [0; 128];
-    for i in 0..128 {
-        data[i] = i;
+    #[test]
+    fn check_array_mut_ref_7() {
+        fn f(mut data: Vec<u8>, offset: usize) -> quickcheck::TestResult {
+            if data.len() < offset + 7 {
+                return quickcheck::TestResult::discard();
+            }
+            let out = array_mut_ref!(data, offset, 7);
+            out[6] = 3;
+            quickcheck::TestResult::from_bool(out.len() == 7)
+        }
+        quickcheck::quickcheck(f as fn(Vec<u8>, usize) -> quickcheck::TestResult);
     }
-    let data = data;
-    let (a,b,c,d,e) = array_refs!(&data, 1, 14, 3, 100, 10);
-    assert_eq!(a.len(), 1 as usize);
-    assert_eq!(b.len(), 14 as usize);
-    assert_eq!(c.len(), 3 as usize);
-    assert_eq!(d.len(), 100 as usize);
-    assert_eq!(e.len(), 10 as usize);
-    assert_eq!(a, array_ref![data, 0, 1]);
-    assert_eq!(b, array_ref![data, 1, 14]);
-    assert_eq!(c, array_ref![data, 15, 3]);
-    assert_eq!(e, array_ref![data, 118, 10]);
-}
 
-#[test]
-fn test_5_array_refs_dotdot() {
-    let mut data: [usize; 128] = [0; 128];
-    for i in 0..128 {
-        data[i] = i;
+    #[test]
+    fn check_array_mut_ref_out_of_bounds_32() {
+        fn f(mut data: Vec<u8>, offset: usize) -> quickcheck::TestResult {
+            if data.len() >= offset + 32 {
+                return quickcheck::TestResult::discard();
+            }
+            quickcheck::TestResult::must_fail(move || {
+                array_mut_ref!(data, offset, 32);
+            })
+        }
+        quickcheck::quickcheck(f as fn(Vec<u8>, usize) -> quickcheck::TestResult);
     }
-    let data = data;
-    let (a,b,c,d,e) = array_refs!(&data, 1, 14, 3; ..; 10);
-    assert_eq!(a.len(), 1 as usize);
-    assert_eq!(b.len(), 14 as usize);
-    assert_eq!(c.len(), 3 as usize);
-    assert_eq!(d.len(), 100 as usize);
-    assert_eq!(e.len(), 10 as usize);
-    assert_eq!(a, array_ref![data, 0, 1]);
-    assert_eq!(b, array_ref![data, 1, 14]);
-    assert_eq!(c, array_ref![data, 15, 3]);
-    assert_eq!(e, array_ref![data, 118, 10]);
-}
-
 
-#[test]
-fn test_5_mut_xarray_refs() {
-    let mut data: [usize; 128] = [0; 128];
-    {
-        // temporarily borrow the data to modify it.
-        let (a,b,c,d,e) = mut_array_refs!(&mut data, 1, 14, 3, 100, 10);
+    #[test]
+    fn test_5_array_refs() {
+        let mut data: [usize; 128] = [0; 128];
+        for i in 0..128 {
+            data[i] = i;
+        }
+        let data = data;
+        let (a, b, c, d, e) = array_refs!(&data, 1, 14, 3, 100, 10);
         assert_eq!(a.len(), 1 as usize);
         assert_eq!(b.len(), 14 as usize);
         assert_eq!(c.len(), 3 as usize);
         assert_eq!(d.len(), 100 as usize);
         assert_eq!(e.len(), 10 as usize);
-        *a = [1; 1];
-        *b = [14; 14];
-        *c = [3; 3];
-        *d = [100; 100];
-        *e = [10; 10];
+        assert_eq!(a, array_ref![data, 0, 1]);
+        assert_eq!(b, array_ref![data, 1, 14]);
+        assert_eq!(c, array_ref![data, 15, 3]);
+        assert_eq!(e, array_ref![data, 118, 10]);
     }
-    assert_eq!(&[1;1], array_ref![data, 0, 1]);
-    assert_eq!(&[14;14], array_ref![data, 1, 14]);
-    assert_eq!(&[3;3], array_ref![data, 15, 3]);
-    assert_eq!(&[10;10], array_ref![data, 118, 10]);
-}
 
-#[test]
-fn test_5_mut_xarray_refs_with_dotdot() {
-    let mut data: [usize; 128] = [0; 128];
-    {
-        // temporarily borrow the data to modify it.
-        let (a,b,c,d,e) = mut_array_refs!(&mut data, 1, 14, 3; ..; 10);
+    #[test]
+    fn test_5_array_refs_dotdot() {
+        let mut data: [usize; 128] = [0; 128];
+        for i in 0..128 {
+            data[i] = i;
+        }
+        let data = data;
+        let (a, b, c, d, e) = array_refs!(&data, 1, 14, 3; ..; 10);
         assert_eq!(a.len(), 1 as usize);
         assert_eq!(b.len(), 14 as usize);
         assert_eq!(c.len(), 3 as usize);
         assert_eq!(d.len(), 100 as usize);
         assert_eq!(e.len(), 10 as usize);
-        *a = [1; 1];
-        *b = [14; 14];
-        *c = [3; 3];
-        *e = [10; 10];
+        assert_eq!(a, array_ref![data, 0, 1]);
+        assert_eq!(b, array_ref![data, 1, 14]);
+        assert_eq!(c, array_ref![data, 15, 3]);
+        assert_eq!(e, array_ref![data, 118, 10]);
     }
-    assert_eq!(&[1;1], array_ref![data, 0, 1]);
-    assert_eq!(&[14;14], array_ref![data, 1, 14]);
-    assert_eq!(&[3;3], array_ref![data, 15, 3]);
-    assert_eq!(&[10;10], array_ref![data, 118, 10]);
-}
 
-#[forbid(clippy::ptr_offset_with_cast)]
-#[test]
-fn forbidden_clippy_lints_do_not_fire() {
-    let mut data = [0u8; 32];
-    let _ = array_refs![&data, 8; .. ;];
-    let _ = mut_array_refs![&mut data, 8; .. ; 10];
-}
+    #[test]
+    fn test_5_mut_xarray_refs() {
+        let mut data: [usize; 128] = [0; 128];
+        {
+            // temporarily borrow the data to modify it.
+            let (a, b, c, d, e) = mut_array_refs!(&mut data, 1, 14, 3, 100, 10);
+            assert_eq!(a.len(), 1 as usize);
+            assert_eq!(b.len(), 14 as usize);
+            assert_eq!(c.len(), 3 as usize);
+            assert_eq!(d.len(), 100 as usize);
+            assert_eq!(e.len(), 10 as usize);
+            *a = [1; 1];
+            *b = [14; 14];
+            *c = [3; 3];
+            *d = [100; 100];
+            *e = [10; 10];
+        }
+        assert_eq!(&[1; 1], array_ref![data, 0, 1]);
+        assert_eq!(&[14; 14], array_ref![data, 1, 14]);
+        assert_eq!(&[3; 3], array_ref![data, 15, 3]);
+        assert_eq!(&[10; 10], array_ref![data, 118, 10]);
+    }
+
+    #[test]
+    fn test_5_mut_xarray_refs_with_dotdot() {
+        let mut data: [usize; 128] = [0; 128];
+        {
+            // temporarily borrow the data to modify it.
+            let (a, b, c, d, e) = mut_array_refs!(&mut data, 1, 14, 3; ..; 10);
+            assert_eq!(a.len(), 1 as usize);
+            assert_eq!(b.len(), 14 as usize);
+            assert_eq!(c.len(), 3 as usize);
+            assert_eq!(d.len(), 100 as usize);
+            assert_eq!(e.len(), 10 as usize);
+            *a = [1; 1];
+            *b = [14; 14];
+            *c = [3; 3];
+            *e = [10; 10];
+        }
+        assert_eq!(&[1; 1], array_ref![data, 0, 1]);
+        assert_eq!(&[14; 14], array_ref![data, 1, 14]);
+        assert_eq!(&[3; 3], array_ref![data, 15, 3]);
+        assert_eq!(&[10; 10], array_ref![data, 118, 10]);
+    }
 
-#[test]
-fn single_arg_refs() {
-    let mut data = [0u8; 8];
-    let (_, ) = array_refs![&data, 8];
-    let (_, ) = mut_array_refs![&mut data, 8];
+    #[forbid(clippy::ptr_offset_with_cast)]
+    #[test]
+    fn forbidden_clippy_lints_do_not_fire() {
+        let mut data = [0u8; 32];
+        let _ = array_refs![&data, 8; .. ;];
+        let _ = mut_array_refs![&mut data, 8; .. ; 10];
+    }
 
-    let (_, _) = array_refs![&data, 4; ..;];
-    let (_, _) = mut_array_refs![&mut data, 4; ..;];
+    #[test]
+    fn single_arg_refs() {
+        let mut data = [0u8; 8];
+        let (_,) = array_refs![&data, 8];
+        let (_,) = mut_array_refs![&mut data, 8];
 
-    let (_, _) = array_refs![&data,; ..; 4];
-    let (_, _) = mut_array_refs![&mut data,; ..; 4];
+        let (_, _) = array_refs![&data, 4; ..;];
+        let (_, _) = mut_array_refs![&mut data, 4; ..;];
 
-    let (_,) = array_refs![&data,; ..;];
-    let (_,) = mut_array_refs![&mut data,; ..;];
-}
+        let (_, _) = array_refs![&data,; ..; 4];
+        let (_, _) = mut_array_refs![&mut data,; ..; 4];
 
+        let (_,) = array_refs![&data,; ..;];
+        let (_,) = mut_array_refs![&mut data,; ..;];
+    }
 } // mod test
-