cargo fmt

src/common/BitArrayTestCase.rs

@@ -29,127 +29,126 @@
 use super::BitArray;
 use rand::Rng;
 
-  #[test]
-  fn test_get_set() {
-    let mut array =  BitArray::with_size(33);
+#[test]
+fn test_get_set() {
+    let mut array = BitArray::with_size(33);
     for i in 0..33 {
-    // for (int i = 0; i < 33; i++) {
-      assert!(!array.get(i));
-      array.set(i);
-      assert!(array.get(i));
+        // for (int i = 0; i < 33; i++) {
+        assert!(!array.get(i));
+        array.set(i);
+        assert!(array.get(i));
     }
-  }
+}
 
-  #[test]
-  fn test_get_next_set1() {
-    let array =  BitArray::with_size(32);
+#[test]
+fn test_get_next_set1() {
+    let array = BitArray::with_size(32);
     for i in 0..array.getSize() {
-    // for (int i = 0; i < array.getSize(); i++) {
-      assert_eq!( 32, array.getNextSet(i), "{}", i);
+        // for (int i = 0; i < array.getSize(); i++) {
+        assert_eq!(32, array.getNextSet(i), "{}", i);
     }
-    let array =  BitArray::with_size(33);
-    for i in 0..array.getSize(){
-    // for (int i = 0; i < array.getSize(); i++) {
-      assert_eq!( 33, array.getNextSet(i), "{}", i);
+    let array = BitArray::with_size(33);
+    for i in 0..array.getSize() {
+        // for (int i = 0; i < array.getSize(); i++) {
+        assert_eq!(33, array.getNextSet(i), "{}", i);
     }
-  }
-  
-  #[test]
-  fn test_get_next_set2() {
-    let mut array =  BitArray::with_size(33);    
-    array.set(31);
-    for i in 0 ..array.getSize() {
-    // for (int i = 0; i < array.getSize(); i++) {
-      assert_eq!(if i <= 31 { 31} else {33}, array.getNextSet(i), "{}", i);
-    }
-    array =  BitArray::with_size(33);
-    array.set(32);
-    for i in 0 ..array.getSize(){
-    // for (int i = 0; i < array.getSize(); i++) {
-      assert_eq!(32, array.getNextSet(i), "{}", i);
-    }
-  }
-  
-  #[test]
-  fn test_get_next_set3() {
-    let mut array =  BitArray::with_size(63);    
-    array.set(31);
-    array.set(32);
-    for i in 0 .. array.getSize() {
-    // for (int i = 0; i < array.getSize(); i++) {
-      let expected;
-      if i <= 31 {
-        expected = 31;
-      } else if i == 32 {
-        expected = 32;
-      } else {
-        expected = 63;
-      }
-      assert_eq!(expected, array.getNextSet(i), "{}", i);
-    }
-  }
+}
 
-  #[test]
-  fn test_get_next_set4() {
-    let mut array =  BitArray::with_size(63);
+#[test]
+fn test_get_next_set2() {
+    let mut array = BitArray::with_size(33);
+    array.set(31);
+    for i in 0..array.getSize() {
+        // for (int i = 0; i < array.getSize(); i++) {
+        assert_eq!(if i <= 31 { 31 } else { 33 }, array.getNextSet(i), "{}", i);
+    }
+    array = BitArray::with_size(33);
+    array.set(32);
+    for i in 0..array.getSize() {
+        // for (int i = 0; i < array.getSize(); i++) {
+        assert_eq!(32, array.getNextSet(i), "{}", i);
+    }
+}
+
+#[test]
+fn test_get_next_set3() {
+    let mut array = BitArray::with_size(63);
+    array.set(31);
+    array.set(32);
+    for i in 0..array.getSize() {
+        // for (int i = 0; i < array.getSize(); i++) {
+        let expected;
+        if i <= 31 {
+            expected = 31;
+        } else if i == 32 {
+            expected = 32;
+        } else {
+            expected = 63;
+        }
+        assert_eq!(expected, array.getNextSet(i), "{}", i);
+    }
+}
+
+#[test]
+fn test_get_next_set4() {
+    let mut array = BitArray::with_size(63);
     array.set(33);
     array.set(40);
-    for i in 0..array.getSize(){
-    // for (int i = 0; i < array.getSize(); i++) {
-      let expected;
-      if i <= 33 {
-        expected = 33;
-      } else if i <= 40 {
-        expected = 40;
-      } else {
-        expected = 63;
-      }
-      assert_eq!( expected, array.getNextSet(i), "{}", i);
-    }
-  }
-  
-  #[test]
-  fn test_get_next_set5() {
-    let mut r = rand::thread_rng();
-    for _i in 0 .. 10 {
-    // for (int i = 0; i < 10; i++) {
-      let  mut array =  BitArray::with_size(1 + r.gen_range(0..100));
-      let numSet = r.gen_range(0..20);
-      for _j in 0..numSet {
-      // for (int j = 0; j < numSet; j++) {
-        array.set(r.gen_range(0..array.getSize()));
-      }
-      let numQueries = r.gen_range(0..20);
-      for _j in 0..numQueries {
-      // for (int j = 0; j < numQueries; j++) {
-        let query = r.gen_range(0..array.getSize());
-        let mut expected = query;
-        while expected < array.getSize() && !array.get(expected) {
-          expected+=1;
+    for i in 0..array.getSize() {
+        // for (int i = 0; i < array.getSize(); i++) {
+        let expected;
+        if i <= 33 {
+            expected = 33;
+        } else if i <= 40 {
+            expected = 40;
+        } else {
+            expected = 63;
         }
-        let actual = array.getNextSet(query);
-        assert_eq!(expected, actual);
-      }
+        assert_eq!(expected, array.getNextSet(i), "{}", i);
     }
-  }
+}
 
+#[test]
+fn test_get_next_set5() {
+    let mut r = rand::thread_rng();
+    for _i in 0..10 {
+        // for (int i = 0; i < 10; i++) {
+        let mut array = BitArray::with_size(1 + r.gen_range(0..100));
+        let numSet = r.gen_range(0..20);
+        for _j in 0..numSet {
+            // for (int j = 0; j < numSet; j++) {
+            array.set(r.gen_range(0..array.getSize()));
+        }
+        let numQueries = r.gen_range(0..20);
+        for _j in 0..numQueries {
+            // for (int j = 0; j < numQueries; j++) {
+            let query = r.gen_range(0..array.getSize());
+            let mut expected = query;
+            while expected < array.getSize() && !array.get(expected) {
+                expected += 1;
+            }
+            let actual = array.getNextSet(query);
+            assert_eq!(expected, actual);
+        }
+    }
+}
 
-  #[test]
-  fn test_set_bulk() {
-    let mut array =  BitArray::with_size(64);
+#[test]
+fn test_set_bulk() {
+    let mut array = BitArray::with_size(64);
     array.setBulk(32, 0xFFFF0000);
     for i in 0..48 {
-    // for (int i = 0; i < 48; i++) {
-      assert!(!array.get(i));
+        // for (int i = 0; i < 48; i++) {
+        assert!(!array.get(i));
     }
     for i in 48..64 {
-    // for (int i = 48; i < 64; i++) {
-      assert!(array.get(i));
+        // for (int i = 48; i < 64; i++) {
+        assert!(array.get(i));
     }
-  }
+}
 
-  #[test]
-  fn test_append_bit(){
+#[test]
+fn test_append_bit() {
     let mut array = BitArray::new();
     array.appendBits(0x000001E, 6).expect("must append)");
     let mut array_2 = BitArray::new();
@@ -161,57 +160,57 @@ use rand::Rng;
     array_2.appendBit(false);
 
     assert_eq!(array, array_2)
-  }
+}
 
-  #[test]
-  fn test_set_range() {
-    let mut array =  BitArray::with_size(64);
+#[test]
+fn test_set_range() {
+    let mut array = BitArray::with_size(64);
     array.setRange(28, 36).unwrap();
     assert!(!array.get(27));
     for i in 28..36 {
-    // for (int i = 28; i < 36; i++) {
-      assert!(array.get(i));
+        // for (int i = 28; i < 36; i++) {
+        assert!(array.get(i));
     }
     assert!(!array.get(36));
-  }
+}
 
-  #[test]
-  fn test_clear() {
-    let mut array =  BitArray::with_size(32);
+#[test]
+fn test_clear() {
+    let mut array = BitArray::with_size(32);
     for i in 0..32 {
-    // for (int i = 0; i < 32; i++) {
-      array.set(i);
+        // for (int i = 0; i < 32; i++) {
+        array.set(i);
     }
     array.clear();
     for i in 0..32 {
-    // for (int i = 0; i < 32; i++) {
-      assert!(!array.get(i));
+        // for (int i = 0; i < 32; i++) {
+        assert!(!array.get(i));
     }
-  }
+}
 
-  #[test]
-  fn test_flip() {
-    let mut array =  BitArray::with_size(32);
+#[test]
+fn test_flip() {
+    let mut array = BitArray::with_size(32);
     assert!(!array.get(5));
     array.flip(5);
     assert!(array.get(5));
     array.flip(5);
     assert!(!array.get(5));
-  }
+}
 
-  #[test]
-  fn test_get_array() {
-    let mut array =  BitArray::with_size(64);
+#[test]
+fn test_get_array() {
+    let mut array = BitArray::with_size(64);
     array.set(0);
     array.set(63);
     let ints = array.getBitArray();
     assert_eq!(1, ints[0]);
     assert_eq!(0b10_00_00_00_00_00_00_00_00_00_00_00_00_00_00_00, ints[1]);
-  }
+}
 
-  #[test]
-  fn test_is_range() {
-    let mut array =  BitArray::with_size(64);
+#[test]
+fn test_is_range() {
+    let mut array = BitArray::with_size(64);
     assert!(array.isRange(0, 64, false).unwrap());
     assert!(!array.isRange(0, 64, true).unwrap());
     array.set(32);
@@ -221,42 +220,46 @@ use rand::Rng;
     array.set(34);
     assert!(!array.isRange(31, 35, true).unwrap());
     for i in 0..31 {
-    // for (int i = 0; i < 31; i++) {
-      array.set(i);
+        // for (int i = 0; i < 31; i++) {
+        array.set(i);
     }
     assert!(array.isRange(0, 33, true).unwrap());
     for i in 33..64 {
-    // for (int i = 33; i < 64; i++) {
-      array.set(i);
+        // for (int i = 33; i < 64; i++) {
+        array.set(i);
     }
     assert!(array.isRange(0, 64, true).unwrap());
     assert!(!array.isRange(0, 64, false).unwrap());
-  }
+}
 
-  #[test]
-  fn reverse_algorithm_test() {
-    let oldBits:Vec<u32> = vec![128, 256, 512, 6453324, 50934953];
+#[test]
+fn reverse_algorithm_test() {
+    let oldBits: Vec<u32> = vec![128, 256, 512, 6453324, 50934953];
     for size in 1..160 {
-    // for (int size = 1; size < 160; size++) {
-      let newBitsOriginal = reverse_original(&oldBits.clone(), size);
-      let mut newBitArray = BitArray::with_initial_values(oldBits.clone(), size);
-      newBitArray.reverse();
-      let newBitsNew = newBitArray.getBitArray();
-      assert!(arrays_are_equal(&newBitsOriginal, &newBitsNew, size / 32 + 1));
+        // for (int size = 1; size < 160; size++) {
+        let newBitsOriginal = reverse_original(&oldBits.clone(), size);
+        let mut newBitArray = BitArray::with_initial_values(oldBits.clone(), size);
+        newBitArray.reverse();
+        let newBitsNew = newBitArray.getBitArray();
+        assert!(arrays_are_equal(
+            &newBitsOriginal,
+            &newBitsNew,
+            size / 32 + 1
+        ));
     }
-  }
+}
 
-  #[test]
-  fn test_clone() {
-    let array =  BitArray::with_size(32);
+#[test]
+fn test_clone() {
+    let array = BitArray::with_size(32);
     array.clone().set(0);
     assert!(!array.get(0));
-  }
+}
 
-  #[test]
-  fn test_equals() {
-    let mut a =  BitArray::with_size(32);
-    let mut b =  BitArray::with_size(32);
+#[test]
+fn test_equals() {
+    let mut a = BitArray::with_size(32);
+    let mut b = BitArray::with_size(32);
     assert_eq!(a, b);
     // assert_eq!(a.hash(), b.hash());
     assert_ne!(a, BitArray::with_size(31));
@@ -266,31 +269,31 @@ use rand::Rng;
     b.set(16);
     assert_eq!(a, b);
     // assert_eq!(a.hash(), b.hash());
-  }
+}
 
-  fn reverse_original( oldBits:&[u32],  size:usize) -> Vec<u32>{
-    let mut newBits = vec![0;oldBits.len()];
+fn reverse_original(oldBits: &[u32], size: usize) -> Vec<u32> {
+    let mut newBits = vec![0; oldBits.len()];
     for i in 0..size {
-    // for (int i = 0; i < size; i++) {
-      if bit_set(oldBits, size - i - 1) {
-        newBits[i / 32 as usize] |= 1 << (i & 0x1F);
-      }
+        // for (int i = 0; i < size; i++) {
+        if bit_set(oldBits, size - i - 1) {
+            newBits[i / 32 as usize] |= 1 << (i & 0x1F);
+        }
     }
     return newBits;
-  }
+}
 
-  fn bit_set( bits:&[u32],  i:usize) -> bool{
+fn bit_set(bits: &[u32], i: usize) -> bool {
     return (bits[i / 32] & (1 << (i & 0x1F))) != 0;
-  }
+}
 
-  fn arrays_are_equal( left :&[u32],  right:&[u32],  size:usize) -> bool{
+fn arrays_are_equal(left: &[u32], right: &[u32], size: usize) -> bool {
     for i in 0..size {
-    // for (int i = 0; i < size; i++) {
-      if left[i] != right[i] {
-        return false;
-      }
+        // for (int i = 0; i < size; i++) {
+        if left[i] != right[i] {
+            return false;
+        }
     }
     return true;
-  }
+}
 
 // }