Added tests for array_combinations_with_replacement

Author: mendelsshop

benches/combinations_with_replacement.rs

@@ -30,11 +30,42 @@ fn comb_replacement_n10_k10(c: &mut Criterion) {
         })
     });
 }
+fn array_comb_replacement_n10_k5(c: &mut Criterion) {
+    c.bench_function("array comb replacement n10k5", move |b| {
+        b.iter(|| {
+            for i in (0..10).array_combinations_with_replacement::<5>() {
+                black_box(i);
+            }
+        })
+    });
+}
 
+fn array_comb_replacement_n5_k10(c: &mut Criterion) {
+    c.bench_function("array comb replacement n5 k10", move |b| {
+        b.iter(|| {
+            for i in (0..5).array_combinations_with_replacement::<10>() {
+                black_box(i);
+            }
+        })
+    });
+}
+
+fn array_comb_replacement_n10_k10(c: &mut Criterion) {
+    c.bench_function("array comb replacement n10 k10", move |b| {
+        b.iter(|| {
+            for i in (0..10).array_combinations_with_replacement::<10>() {
+                black_box(i);
+            }
+        })
+    });
+}
 criterion_group!(
     benches,
     comb_replacement_n10_k5,
     comb_replacement_n5_k10,
     comb_replacement_n10_k10,
+    array_comb_replacement_n10_k5,
+    array_comb_replacement_n5_k10,
+    array_comb_replacement_n10_k10,
 );
 criterion_main!(benches);

benches/specializations.rs

@@ -441,6 +441,30 @@ bench_specializations! {
         }
         v.iter().combinations_with_replacement(4)
     }
+    array_combinations_with_replacement1 {
+        {
+            let v = black_box(vec![0; 4096]);
+        }
+        v.iter().array_combinations_with_replacement::<1>()
+    }
+    array_combinations_with_replacement2 {
+        {
+            let v = black_box(vec![0; 90]);
+        }
+        v.iter().array_combinations_with_replacement::<2>()
+    }
+    array_combinations_with_replacement3 {
+        {
+            let v = black_box(vec![0; 28]);
+        }
+        v.iter().array_combinations_with_replacement::<3>()
+    }
+    array_combinations_with_replacement4 {
+        {
+            let v = black_box(vec![0; 16]);
+        }
+        v.iter().array_combinations_with_replacement::<4>()
+    }
     permutations1 {
         {
             let v = black_box(vec![0; 1024]);

tests/adaptors_no_collect.rs

@@ -49,3 +49,7 @@ fn combinations_no_collect() {
 fn combinations_with_replacement_no_collect() {
     no_collect_test(|iter| iter.combinations_with_replacement(5))
 }
+#[test]
+fn array_combinations_with_replacement_no_collect() {
+    no_collect_test(|iter| iter.array_combinations_with_replacement::<5>())
+}

tests/laziness.rs

@@ -217,6 +217,11 @@ must_use_tests! {
         let _ = Panicking.combinations_with_replacement(1);
         let _ = Panicking.combinations_with_replacement(2);
     }
+    array_combinations_with_replacement {
+        let _ = Panicking.array_combinations_with_replacement::<0>();
+        let _ = Panicking.array_combinations_with_replacement::<1>();
+        let _ = Panicking.array_combinations_with_replacement::<2>();
+    }
     permutations {
         let _ = Panicking.permutations(0);
         let _ = Panicking.permutations(1);

tests/quick.rs

@@ -1838,6 +1838,11 @@ quickcheck! {
         is_fused(a.combinations_with_replacement(3))
     }
 
+    fn fused_array_combination_with_replacement(a: Iter<i16>) -> bool
+    {
+        is_fused(a.clone().array_combinations_with_replacement::<1>()) &&
+        is_fused(a.array_combinations_with_replacement::<3>())
+    }
     fn fused_tuple_combination(a: Iter<i16>) -> bool
     {
         is_fused(a.clone().fuse().tuple_combinations::<(_,)>()) &&

tests/specializations.rs

@@ -299,6 +299,16 @@ quickcheck! {
         TestResult::passed()
     }
 
+    fn array_combinations_with_replacement(a: Vec<u8>) -> TestResult {
+        if a.len() > 10 {
+            return TestResult::discard();
+        }
+        test_specializations(&a.iter().array_combinations_with_replacement::<1>());
+        test_specializations(&a.iter().array_combinations_with_replacement::<2>());
+        test_specializations(&a.iter().array_combinations_with_replacement::<3>());
+
+        TestResult::passed()
+    }
     fn permutations(a: Vec<u8>, n: u8) -> TestResult {
         if n > 3 || a.len() > 8 {
             return TestResult::discard();

tests/test_std.rs

@@ -1256,6 +1256,30 @@ fn combinations_with_replacement_range_count() {
     }
 }
 
+#[test]
+#[cfg(not(miri))]
+fn array_combinations_with_replacement() {
+    // Pool smaller than n
+    it::assert_equal(
+        (0..1).array_combinations_with_replacement::<2>(),
+        vec![[0, 0]],
+    );
+    // Pool larger than n
+    it::assert_equal(
+        (0..3).array_combinations_with_replacement::<2>(),
+        vec![[0, 0], [0, 1], [0, 2], [1, 1], [1, 2], [2, 2]],
+    );
+    // Zero size
+    it::assert_equal((0..3).array_combinations_with_replacement::<0>(), vec![[]]);
+    // Zero size on empty pool
+    it::assert_equal((0..0).array_combinations_with_replacement::<0>(), vec![[]]);
+    // Empty pool
+    it::assert_equal(
+        (0..0).array_combinations_with_replacement::<2>(),
+        vec![] as Vec<[_; 2]>,
+    );
+}
+
 #[test]
 fn powerset() {
     it::assert_equal((0..0).powerset(), vec![vec![]]);