Replace quickcheck! with #[quickcheck]

Author: jturner314

src/correlation.rs

@@ -171,31 +171,31 @@ mod cov_tests {
     use super::*;
     use ndarray::array;
     use ndarray_rand::RandomExt;
-    use quickcheck::quickcheck;
+    use quickcheck_macros::quickcheck;
     use rand;
     use rand::distributions::Uniform;
 
-    quickcheck! {
-        fn constant_random_variables_have_zero_covariance_matrix(value: f64) -> bool {
-            let n_random_variables = 3;
-            let n_observations = 4;
-            let a = Array::from_elem((n_random_variables, n_observations), value);
-            a.cov(1.).all_close(
-                &Array::zeros((n_random_variables, n_random_variables)),
-                1e-8
-            )
-        }
+    #[quickcheck]
+    fn constant_random_variables_have_zero_covariance_matrix(value: f64) -> bool {
+        let n_random_variables = 3;
+        let n_observations = 4;
+        let a = Array::from_elem((n_random_variables, n_observations), value);
+        a.cov(1.).all_close(
+            &Array::zeros((n_random_variables, n_random_variables)),
+            1e-8
+        )
+    }
 
-        fn covariance_matrix_is_symmetric(bound: f64) -> bool {
-            let n_random_variables = 3;
-            let n_observations = 4;
-            let a = Array::random(
-                (n_random_variables, n_observations),
-                Uniform::new(-bound.abs(), bound.abs())
-            );
-            let covariance = a.cov(1.);
-            covariance.all_close(&covariance.t(), 1e-8)
-        }
+    #[quickcheck]
+    fn covariance_matrix_is_symmetric(bound: f64) -> bool {
+        let n_random_variables = 3;
+        let n_observations = 4;
+        let a = Array::random(
+            (n_random_variables, n_observations),
+            Uniform::new(-bound.abs(), bound.abs())
+        );
+        let covariance = a.cov(1.);
+        covariance.all_close(&covariance.t(), 1e-8)
     }
 
     #[test]
@@ -273,28 +273,28 @@ mod pearson_correlation_tests {
     use super::*;
     use ndarray::array;
     use ndarray_rand::RandomExt;
-    use quickcheck::quickcheck;
+    use quickcheck_macros::quickcheck;
     use rand::distributions::Uniform;
 
-    quickcheck! {
-        fn output_matrix_is_symmetric(bound: f64) -> bool {
-            let n_random_variables = 3;
-            let n_observations = 4;
-            let a = Array::random(
-                (n_random_variables, n_observations),
-                Uniform::new(-bound.abs(), bound.abs())
-            );
-            let pearson_correlation = a.pearson_correlation();
-            pearson_correlation.all_close(&pearson_correlation.t(), 1e-8)
-        }
+    #[quickcheck]
+    fn output_matrix_is_symmetric(bound: f64) -> bool {
+        let n_random_variables = 3;
+        let n_observations = 4;
+        let a = Array::random(
+            (n_random_variables, n_observations),
+            Uniform::new(-bound.abs(), bound.abs())
+        );
+        let pearson_correlation = a.pearson_correlation();
+        pearson_correlation.all_close(&pearson_correlation.t(), 1e-8)
+    }
 
-        fn constant_random_variables_have_nan_correlation(value: f64) -> bool {
-            let n_random_variables = 3;
-            let n_observations = 4;
-            let a = Array::from_elem((n_random_variables, n_observations), value);
-            let pearson_correlation = a.pearson_correlation();
-            pearson_correlation.iter().map(|x| x.is_nan()).fold(true, |acc, flag| acc & flag)
-        }
+    #[quickcheck]
+    fn constant_random_variables_have_nan_correlation(value: f64) -> bool {
+        let n_random_variables = 3;
+        let n_observations = 4;
+        let a = Array::from_elem((n_random_variables, n_observations), value);
+        let pearson_correlation = a.pearson_correlation();
+        pearson_correlation.iter().map(|x| x.is_nan()).fold(true, |acc, flag| acc & flag)
     }
 
     #[test]

src/histogram/bins.rs

@@ -351,68 +351,71 @@ impl<A: Ord> Bins<A> {
 #[cfg(test)]
 mod edges_tests {
     use super::*;
-    use quickcheck::quickcheck;
+    use quickcheck_macros::quickcheck;
     use std::collections::BTreeSet;
     use std::iter::FromIterator;
 
-    quickcheck! {
-        fn check_sorted_from_vec(v: Vec<i32>) -> bool {
-            let edges = Edges::from(v);
-            let n = edges.len();
-            for i in 1..n {
-                if edges[i-1] > edges[i] {
-                    return false;
-                }
+    #[quickcheck]
+    fn check_sorted_from_vec(v: Vec<i32>) -> bool {
+        let edges = Edges::from(v);
+        let n = edges.len();
+        for i in 1..n {
+            if edges[i-1] > edges[i] {
+                return false;
             }
-            true
         }
+        true
+    }
 
-        fn check_sorted_from_array(v: Vec<i32>) -> bool {
-            let a = Array1::from_vec(v);
-            let edges = Edges::from(a);
-            let n = edges.len();
-            for i in 1..n {
-                if edges[i-1] > edges[i] {
-                    return false;
-                }
+    #[quickcheck]
+    fn check_sorted_from_array(v: Vec<i32>) -> bool {
+        let a = Array1::from_vec(v);
+        let edges = Edges::from(a);
+        let n = edges.len();
+        for i in 1..n {
+            if edges[i-1] > edges[i] {
+                return false;
             }
-            true
         }
+        true
+    }
 
-        fn edges_are_right_exclusive(v: Vec<i32>) -> bool {
-            let edges = Edges::from(v);
-            let view = edges.as_array_view();
-            if view.len() == 0 {
-                true
-            } else {
-                let last = view[view.len()-1];
-                edges.indices_of(&last).is_none()
-            }
+    #[quickcheck]
+    fn edges_are_right_exclusive(v: Vec<i32>) -> bool {
+        let edges = Edges::from(v);
+        let view = edges.as_array_view();
+        if view.len() == 0 {
+            true
+        } else {
+            let last = view[view.len()-1];
+            edges.indices_of(&last).is_none()
         }
+    }
 
-        fn edges_are_left_inclusive(v: Vec<i32>) -> bool {
-            let edges = Edges::from(v);
-            match edges.len() {
-                1 => true,
-                _ => {
-                    let view = edges.as_array_view();
-                    if view.len() == 0 {
-                        true
-                    } else {
-                        let first = view[0];
-                        edges.indices_of(&first).is_some()
-                    }
+    #[quickcheck]
+    fn edges_are_left_inclusive(v: Vec<i32>) -> bool {
+        let edges = Edges::from(v);
+        match edges.len() {
+            1 => true,
+            _ => {
+                let view = edges.as_array_view();
+                if view.len() == 0 {
+                    true
+                } else {
+                    let first = view[0];
+                    edges.indices_of(&first).is_some()
                 }
             }
         }
+    }
 
-        fn edges_are_deduped(v: Vec<i32>) -> bool {
-            let unique_elements = BTreeSet::from_iter(v.iter());
-            let edges = Edges::from(v.clone());
-            let view = edges.as_array_view();
-            let unique_edges = BTreeSet::from_iter(view.iter());
-            unique_edges == unique_elements
-        }
+    #[quickcheck]
+    fn edges_are_deduped(v: Vec<i32>) -> bool {
+        let unique_elements = BTreeSet::from_iter(v.iter());
+        let edges = Edges::from(v.clone());
+        let view = edges.as_array_view();
+        let unique_edges = BTreeSet::from_iter(view.iter());
+        unique_edges == unique_elements
     }
 }
 

src/maybe_nan/mod.rs

@@ -370,37 +370,38 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use quickcheck::quickcheck;
-
-    quickcheck! {
-        fn remove_nan_mut_idempotent(is_nan: Vec<bool>) -> bool {
-            let mut values: Vec<_> = is_nan
-                .into_iter()
-                .map(|is_nan| if is_nan { None } else { Some(1) })
-                .collect();
-            let view = ArrayViewMut1::from_shape(values.len(), &mut values).unwrap();
-            let removed = remove_nan_mut(view);
-            removed == remove_nan_mut(removed.to_owned().view_mut())
-        }
+    use quickcheck_macros::quickcheck;
+
+    #[quickcheck]
+    fn remove_nan_mut_idempotent(is_nan: Vec<bool>) -> bool {
+        let mut values: Vec<_> = is_nan
+            .into_iter()
+            .map(|is_nan| if is_nan { None } else { Some(1) })
+            .collect();
+        let view = ArrayViewMut1::from_shape(values.len(), &mut values).unwrap();
+        let removed = remove_nan_mut(view);
+        removed == remove_nan_mut(removed.to_owned().view_mut())
+    }
 
-        fn remove_nan_mut_only_nan_remaining(is_nan: Vec<bool>) -> bool {
-            let mut values: Vec<_> = is_nan
-                .into_iter()
-                .map(|is_nan| if is_nan { None } else { Some(1) })
-                .collect();
-            let view = ArrayViewMut1::from_shape(values.len(), &mut values).unwrap();
-            remove_nan_mut(view).iter().all(|elem| !elem.is_nan())
-        }
+    #[quickcheck]
+    fn remove_nan_mut_only_nan_remaining(is_nan: Vec<bool>) -> bool {
+        let mut values: Vec<_> = is_nan
+            .into_iter()
+            .map(|is_nan| if is_nan { None } else { Some(1) })
+            .collect();
+        let view = ArrayViewMut1::from_shape(values.len(), &mut values).unwrap();
+        remove_nan_mut(view).iter().all(|elem| !elem.is_nan())
+    }
 
-        fn remove_nan_mut_keep_all_non_nan(is_nan: Vec<bool>) -> bool {
-            let non_nan_count = is_nan.iter().filter(|&&is_nan| !is_nan).count();
-            let mut values: Vec<_> = is_nan
-                .into_iter()
-                .map(|is_nan| if is_nan { None } else { Some(1) })
-                .collect();
-            let view = ArrayViewMut1::from_shape(values.len(), &mut values).unwrap();
-            remove_nan_mut(view).len() == non_nan_count
-        }
+    #[quickcheck]
+    fn remove_nan_mut_keep_all_non_nan(is_nan: Vec<bool>) -> bool {
+        let non_nan_count = is_nan.iter().filter(|&&is_nan| !is_nan).count();
+        let mut values: Vec<_> = is_nan
+            .into_iter()
+            .map(|is_nan| if is_nan { None } else { Some(1) })
+            .collect();
+        let view = ArrayViewMut1::from_shape(values.len(), &mut values).unwrap();
+        remove_nan_mut(view).len() == non_nan_count
     }
 }
 

tests/quantile.rs

@@ -2,8 +2,6 @@ extern crate itertools;
 extern crate ndarray;
 extern crate ndarray_stats;
 extern crate noisy_float;
-#[macro_use]
-extern crate quickcheck;
 extern crate quickcheck_macros;
 
 use itertools::izip;
@@ -32,11 +30,10 @@ fn test_argmin() {
     assert_eq!(a.argmin(), Err(MinMaxError::EmptyInput));
 }
 
-quickcheck! {
-    fn argmin_matches_min(data: Vec<f32>) -> bool {
-        let a = Array1::from(data);
-        a.argmin().map(|i| &a[i]) == a.min()
-    }
+#[quickcheck]
+fn argmin_matches_min(data: Vec<f32>) -> bool {
+    let a = Array1::from(data);
+    a.argmin().map(|i| &a[i]) == a.min()
 }
 
 #[test]
@@ -57,16 +54,15 @@ fn test_argmin_skipnan() {
     assert_eq!(a.argmin_skipnan(), Err(MinMaxError::EmptyInput));
 }
 
-quickcheck! {
-    fn argmin_skipnan_matches_min_skipnan(data: Vec<Option<i32>>) -> bool {
-        let a = Array1::from(data);
-        let min = a.min_skipnan();
-        let argmin = a.argmin_skipnan();
-        if min.is_none() {
-            argmin == Err(MinMaxError::EmptyInput)
-        } else {
-            a[argmin.unwrap()] == *min
-        }
+#[quickcheck]
+fn argmin_skipnan_matches_min_skipnan(data: Vec<Option<i32>>) -> bool {
+    let a = Array1::from(data);
+    let min = a.min_skipnan();
+    let argmin = a.argmin_skipnan();
+    if min.is_none() {
+        argmin == Err(MinMaxError::EmptyInput)
+    } else {
+        a[argmin.unwrap()] == *min
     }
 }
 
@@ -112,11 +108,10 @@ fn test_argmax() {
     assert_eq!(a.argmax(), Err(MinMaxError::EmptyInput));
 }
 
-quickcheck! {
-    fn argmax_matches_max(data: Vec<f32>) -> bool {
-        let a = Array1::from(data);
-        a.argmax().map(|i| &a[i]) == a.max()
-    }
+#[quickcheck]
+fn argmax_matches_max(data: Vec<f32>) -> bool {
+    let a = Array1::from(data);
+    a.argmax().map(|i| &a[i]) == a.max()
 }
 
 #[test]
@@ -140,16 +135,15 @@ fn test_argmax_skipnan() {
     assert_eq!(a.argmax_skipnan(), Err(MinMaxError::EmptyInput));
 }
 
-quickcheck! {
-    fn argmax_skipnan_matches_max_skipnan(data: Vec<Option<i32>>) -> bool {
-        let a = Array1::from(data);
-        let max = a.max_skipnan();
-        let argmax = a.argmax_skipnan();
-        if max.is_none() {
-            argmax == Err(MinMaxError::EmptyInput)
-        } else {
-            a[argmax.unwrap()] == *max
-        }
+#[quickcheck]
+fn argmax_skipnan_matches_max_skipnan(data: Vec<Option<i32>>) -> bool {
+    let a = Array1::from(data);
+    let max = a.max_skipnan();
+    let argmax = a.argmax_skipnan();
+    if max.is_none() {
+        argmax == Err(MinMaxError::EmptyInput)
+    } else {
+        a[argmax.unwrap()] == *max
     }
 }