🤖 parameterize tests

Author: jvdd

downsample_rs/Cargo.toml

@@ -16,6 +16,8 @@ num-traits = { version = "0.2.15", default-features = false }
 rayon = { version = "1.6.0", default-features = false }
 
 [dev-dependencies]
+rstest = { version = "0.16", default-features = false }
+rstest_reuse = { version = "0.5", default-features = false }
 criterion = "0.4.0"
 dev_utils = { path = "dev_utils" }
 

downsample_rs/src/lib.rs

@@ -1,3 +1,8 @@
+// It is necessary to import this at the root of the crate
+// See: https://github.com/la10736/rstest/tree/master/rstest_reuse#use-rstest_resuse-at-the-top-of-your-crate
+#[cfg(test)]
+use rstest_reuse;
+
 pub mod minmax;
 pub use minmax::*;
 pub mod lttb;

downsample_rs/src/m4/scalar.rs

@@ -116,19 +116,24 @@ mod tests {
     fn test_m4_scalar_without_x_parallel_correct() {
         let arr = (0..100).map(|x| x as f32).collect::<Vec<f32>>();
         let arr = Array1::from(arr);
-        let half_n_threads: usize = available_parallelism().map(|x| x.get()).unwrap_or(2) / 2;
-
-        let sampled_indices = m4_scalar_without_x_parallel(arr.view(), 12, half_n_threads);
-        let sampled_values = sampled_indices.mapv(|x| arr[x]);
 
         let expected_indices = vec![0, 0, 33, 33, 34, 34, 66, 66, 67, 67, 99, 99];
+        let expected_indices = Array1::from(expected_indices);
         let expected_values = expected_indices
             .iter()
             .map(|x| *x as f32)
             .collect::<Vec<f32>>();
+        let expected_values = Array1::from(expected_values);
 
-        assert_eq!(sampled_indices, Array1::from(expected_indices));
-        assert_eq!(sampled_values, Array1::from(expected_values));
+        let all_threads = available_parallelism().map(|x| x.get()).unwrap_or(2);
+        let nb_threads = vec![1, all_threads / 2, all_threads, all_threads + 1];
+
+        for n_threads in nb_threads {
+            let sampled_indices = m4_scalar_without_x_parallel(arr.view(), 12, n_threads);
+            let sampled_values = sampled_indices.mapv(|x| arr[x]);
+            assert_eq!(sampled_indices, expected_indices);
+            assert_eq!(sampled_values, expected_values);
+        }
     }
 
     #[test]
@@ -157,19 +162,23 @@ mod tests {
         let x = Array1::from(x);
         let arr = (0..100).map(|x| x as f32).collect::<Vec<f32>>();
         let arr = Array1::from(arr);
-        let half_n_threads: usize = available_parallelism().map(|x| x.get()).unwrap_or(2) / 2;
-
-        let sampled_indices = m4_scalar_with_x_parallel(x.view(), arr.view(), 12, half_n_threads);
-        let sampled_values = sampled_indices.mapv(|x| arr[x]);
 
         let expected_indices = vec![0, 0, 33, 33, 34, 34, 66, 66, 67, 67, 99, 99];
+        let expected_indices = Array1::from(expected_indices);
         let expected_values = expected_indices
             .iter()
             .map(|x| *x as f32)
             .collect::<Vec<f32>>();
-
-        assert_eq!(sampled_indices, Array1::from(expected_indices));
-        assert_eq!(sampled_values, Array1::from(expected_values));
+        let expected_values = Array1::from(expected_values);
+
+        let all_threads = available_parallelism().map(|x| x.get()).unwrap_or(2);
+        let nb_threads = vec![1, all_threads / 2, all_threads, all_threads + 1];
+        for n_threads in nb_threads {
+            let sampled_indices = m4_scalar_with_x_parallel(x.view(), arr.view(), 12, n_threads);
+            let sampled_values = sampled_indices.mapv(|x| arr[x]);
+            assert_eq!(sampled_indices, expected_indices);
+            assert_eq!(sampled_values, expected_values);
+        }
     }
 
     #[test]
@@ -247,16 +256,19 @@ mod tests {
         let n_out: usize = 204;
         let x = (0..n as i32).collect::<Vec<i32>>();
         let x = Array1::from(x);
-        let half_n_threads: usize = available_parallelism().map(|x| x.get()).unwrap_or(2) / 2;
+        let all_threads = available_parallelism().map(|x| x.get()).unwrap_or(2);
+        let nb_threads = vec![1, all_threads / 2, all_threads, all_threads + 1];
         for _ in 0..100 {
             let arr = get_array_f32(n);
             let idxs1 = m4_scalar_without_x(arr.view(), n_out);
-            let idxs2 = m4_scalar_without_x_parallel(arr.view(), n_out, half_n_threads);
-            let idxs3 = m4_scalar_with_x(x.view(), arr.view(), n_out);
-            let idxs4 = m4_scalar_with_x_parallel(x.view(), arr.view(), n_out, half_n_threads);
+            let idxs2 = m4_scalar_with_x(x.view(), arr.view(), n_out);
             assert_eq!(idxs1, idxs2);
-            assert_eq!(idxs1, idxs3);
-            assert_eq!(idxs1, idxs4);
+            for &n_threads in nb_threads.iter() {
+                let idxs3 = m4_scalar_without_x_parallel(arr.view(), n_out, n_threads);
+                let idxs4 = m4_scalar_with_x_parallel(x.view(), arr.view(), n_out, n_threads);
+                assert_eq!(idxs1, idxs3);
+                assert_eq!(idxs1, idxs4); // TODO: this should not fail
+            }
         }
     }
 }

downsample_rs/src/searchsorted.rs

@@ -2,7 +2,6 @@ use ndarray::ArrayView1;
 
 use rayon::iter::IndexedParallelIterator;
 use rayon::prelude::*;
-use std::thread::available_parallelism;
 
 use super::types::Num;
 use num_traits::{AsPrimitive, FromPrimitive};
@@ -191,12 +190,29 @@ where
 
 #[cfg(test)]
 mod tests {
+    use rstest::rstest;
+    use rstest_reuse::{self, *};
+
     use super::*;
     use ndarray::Array1;
+    use std::thread::available_parallelism;
 
     extern crate dev_utils;
     use dev_utils::utils::get_random_array;
 
+    fn get_all_threads() -> usize {
+        available_parallelism().map(|x| x.get()).unwrap_or(1)
+    }
+
+    // Template for the n_threads matrix
+    #[template]
+    #[rstest]
+    #[case(1)]
+    #[case(get_all_threads() / 2)]
+    #[case(get_all_threads())]
+    #[case(get_all_threads() * 2)]
+    fn threads(#[case] n_threads: usize) {}
+
     #[test]
     fn test_search_sorted_identicial_to_np_linspace_searchsorted() {
         // Create a 0..9999 array
@@ -281,42 +297,50 @@ mod tests {
         // assert_eq!(binary_search_with_mid(arr.view(), 11, 0, arr.len() - 1, 9), 10);
     }
 
-    #[test]
-    fn test_get_equidistant_bin_idxs() {
+    #[apply(threads)]
+    fn test_get_equidistant_bin_idxs(n_threads: usize) {
+        let expected_indices = vec![0, 4, 7];
+
         let arr = Array1::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
         let bin_idxs_iter = get_equidistant_bin_idx_iterator(arr.view(), 3);
         let bin_idxs = bin_idxs_iter.map(|x| x.unwrap().0).collect::<Vec<usize>>();
-        let half_n_threads: usize = available_parallelism().map(|x| x.get()).unwrap_or(2) / 2;
-        assert_eq!(bin_idxs, vec![0, 4, 7]);
-        let bin_idxs_iter =
-            get_equidistant_bin_idx_iterator_parallel(arr.view(), 3, half_n_threads);
+        assert_eq!(bin_idxs, expected_indices);
+
+        let bin_idxs_iter = get_equidistant_bin_idx_iterator_parallel(arr.view(), 3, n_threads);
         let bin_idxs = bin_idxs_iter
             .map(|x| x.map(|x| x.unwrap().0).collect::<Vec<usize>>())
             .flatten()
             .collect::<Vec<usize>>();
-        assert_eq!(bin_idxs, vec![0, 4, 7]);
+        assert_eq!(bin_idxs, expected_indices);
     }
 
-    #[test]
-    fn test_many_random_same_result() {
+    #[apply(threads)]
+    fn test_many_random_same_result(n_threads: usize) {
         let n = 5_000;
         let nb_bins = 100;
-        let half_n_threads: usize = available_parallelism().map(|x| x.get()).unwrap_or(2) / 2;
+        let all_threads = available_parallelism().map(|x| x.get()).unwrap_or(2);
+        let nb_threads = vec![1, all_threads / 2, all_threads, all_threads + 1];
+
         for _ in 0..100 {
             let arr = get_random_array::<i32>(n, i32::MIN, i32::MAX);
             // Sort the array
             let mut arr = arr.to_vec();
             arr.sort_by(|a, b| a.partial_cmp(b).unwrap());
             let arr = Array1::from(arr);
+
             // Calculate the bin indexes
             let bin_idxs_iter = get_equidistant_bin_idx_iterator(arr.view(), nb_bins);
             let bin_idxs = bin_idxs_iter.map(|x| x.unwrap().0).collect::<Vec<usize>>();
+
+            // Calculate the bin indexes in parallel
             let bin_idxs_iter =
-                get_equidistant_bin_idx_iterator_parallel(arr.view(), nb_bins, half_n_threads);
+                get_equidistant_bin_idx_iterator_parallel(arr.view(), nb_bins, n_threads);
             let bin_idxs_parallel = bin_idxs_iter
                 .map(|x| x.map(|x| x.unwrap().0).collect::<Vec<usize>>())
                 .flatten()
                 .collect::<Vec<usize>>();
+
+            // Check that the results are the same
             assert_eq!(bin_idxs, bin_idxs_parallel);
         }
     }