Move tests in a mod

Author: Keats

.github/workflows/ci.yml

@@ -26,4 +26,4 @@ jobs:
     - name: Run tests
       run: cargo test
     - name: Run tests with features
-      run: cargo test --features=rank_lookup
+      run: RUST_TEST_THREADS=1 cargo test --features marker_lookup

src/combinatorial.rs

@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "const_fn", feature(rank_lookup))]
 use std::convert::TryFrom;
 
 #[cfg(feature = "rank_lookup")]
@@ -84,18 +83,6 @@ pub fn rank(value: usize, k: u8) -> u128 {
     // assert rank(70, 3) == 304   # 100110000
 }
 
-#[test]
-fn test_rank() {
-    assert_eq!(rank(0, 3), 7);
-    assert_eq!(rank(2, 3), 13);
-    assert_eq!(rank(0, 3).count_ones(), 3);
-    assert_eq!(rank(2, 3).count_ones(), 3);
-    assert_eq!(rank(35001, 4).count_ones(), 4);
-
-    // Maximum value of 64 choose 3
-    assert_eq!(rank(41663, 3).count_ones(), 3);
-}
-
 pub fn unrank(marker: u128) -> usize {
     // val = choose(rank(0), 1) + choose(rank(1), 2) + choose(rank(2), 3) + ...
     let mut working_marker = marker;
@@ -110,22 +97,6 @@ pub fn unrank(marker: u128) -> usize {
     value as usize
 }
 
-#[test]
-fn test_unrank() {
-    // 3 bit markers
-    assert_eq!(unrank(7), 0);
-    assert_eq!(unrank(13), 2);
-}
-
-#[test]
-fn test_rank_and_unrank() {
-    for k in 1..4u8 {
-        for value in [1 as usize, 23, 45].iter() {
-            assert_eq!(unrank(rank(*value, k)), *value);
-        }
-    }
-}
-
 /// (Hopefully) fast implementation of a binomial
 ///
 /// This uses a preset group of equations for k < 8 and then falls back to a
@@ -170,61 +141,94 @@ pub fn choose(n: u64, k: u8) -> u64 {
     }
 }
 
-#[test]
-fn test_choose() {
-    assert_eq!(choose(1, 1), 1);
-    assert_eq!(choose(10, 1), 10);
+#[inline]
+fn next_rank(marker: u128) -> u128 {
+    let t = marker | (marker - 1);
+    (t + 1) | (((!t & (t + 1)) - 1) >> (marker.trailing_zeros() + 1))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_rank() {
+        assert_eq!(rank(0, 3), 7);
+        assert_eq!(rank(2, 3), 13);
+        assert_eq!(rank(0, 3).count_ones(), 3);
+        assert_eq!(rank(2, 3).count_ones(), 3);
+        assert_eq!(rank(35001, 4).count_ones(), 4);
+
+        // Maximum value of 64 choose 3
+        assert_eq!(rank(41663, 3).count_ones(), 3);
+    }
 
-    assert_eq!(choose(5, 2), 10);
+    #[test]
+    fn test_unrank() {
+        // 3 bit markers
+        assert_eq!(unrank(7), 0);
+        assert_eq!(unrank(13), 2);
+    }
 
-    assert_eq!(choose(5, 3), 10);
+    #[test]
+    fn test_rank_and_unrank() {
+        for k in 1..4u8 {
+            for value in [1 as usize, 23, 45].iter() {
+                assert_eq!(unrank(rank(*value, k)), *value);
+            }
+        }
+    }
 
-    assert_eq!(choose(5, 4), 5);
+    #[test]
+    fn test_choose() {
+        assert_eq!(choose(1, 1), 1);
+        assert_eq!(choose(10, 1), 10);
 
-    assert_eq!(choose(5, 5), 1);
-    assert_eq!(choose(20, 5), 15504);
+        assert_eq!(choose(5, 2), 10);
 
-    assert_eq!(choose(20, 6), 38760);
+        assert_eq!(choose(5, 3), 10);
 
-    assert_eq!(choose(20, 7), 77520);
-    assert_eq!(choose(23, 7), 245157);
+        assert_eq!(choose(5, 4), 5);
 
-    // test the last branch
-    assert_eq!(choose(8, 8), 1);
-    assert_eq!(choose(9, 8), 9);
+        assert_eq!(choose(5, 5), 1);
+        assert_eq!(choose(20, 5), 15504);
 
-    // every value of 64 choose n should work
-    assert_eq!(choose(64, 0), 1);
-    assert_eq!(choose(64, 1), 64);
-    assert_eq!(choose(64, 16), 488526937079580);
-    assert_eq!(choose(64, 32), 1832624140942590534);
-    assert_eq!(choose(64, 48), 488526937079580);
-    assert_eq!(choose(64, 63), 64);
-    assert_eq!(choose(64, 64), 1);
+        assert_eq!(choose(20, 6), 38760);
 
-    // super high values can overflow; these are approaching the limit
-    assert_eq!(choose(128, 11), 2433440563030400);
-    assert_eq!(choose(128, 13), 211709328983644800);
-    assert_eq!(choose(256, 9), 11288510714272000);
-}
+        assert_eq!(choose(20, 7), 77520);
+        assert_eq!(choose(23, 7), 245157);
 
-#[test]
-#[should_panic(expected = "256 choose 20 is greater than 2**64")]
-fn test_choose_overflow() {
-    assert_eq!(choose(256, 20), 11288510714272000);
-}
+        // test the last branch
+        assert_eq!(choose(8, 8), 1);
+        assert_eq!(choose(9, 8), 9);
 
-#[inline]
-fn next_rank(marker: u128) -> u128 {
-    let t = marker | (marker - 1);
-    (t + 1) | (((!t & (t + 1)) - 1) >> (marker.trailing_zeros() + 1))
-}
+        // every value of 64 choose n should work
+        assert_eq!(choose(64, 0), 1);
+        assert_eq!(choose(64, 1), 64);
+        assert_eq!(choose(64, 16), 488526937079580);
+        assert_eq!(choose(64, 32), 1832624140942590534);
+        assert_eq!(choose(64, 48), 488526937079580);
+        assert_eq!(choose(64, 63), 64);
+        assert_eq!(choose(64, 64), 1);
+
+        // super high values can overflow; these are approaching the limit
+        assert_eq!(choose(128, 11), 2433440563030400);
+        assert_eq!(choose(128, 13), 211709328983644800);
+        assert_eq!(choose(256, 9), 11288510714272000);
+    }
+
+    #[test]
+    #[should_panic(expected = "256 choose 20 is greater than 2**64")]
+    fn test_choose_overflow() {
+        assert_eq!(choose(256, 20), 11288510714272000);
+    }
 
-#[test]
-fn test_next_rank() {
-    assert_eq!(next_rank(0b1), 0b10);
-    assert_eq!(next_rank(0b100), 0b1000);
+    #[test]
+    fn test_next_rank() {
+        assert_eq!(next_rank(0b1), 0b10);
+        assert_eq!(next_rank(0b100), 0b1000);
 
-    assert_eq!(next_rank(0b111), 0b1011);
-    assert_eq!(next_rank(0b1000101), 0b1000110);
+        assert_eq!(next_rank(0b111), 0b1011);
+        assert_eq!(next_rank(0b1000101), 0b1000110);
+    }
 }