Added unit test

1 files changed, 23 insertions, 7 deletions

diff --git a/src/common/bitpacker.rs b/src/common/bitpacker.rs
index 5df1e72..49ea9f9 100644
--- a/src/common/bitpacker.rs
+++ b/src/common/bitpacker.rs
@@ -133,23 +133,21 @@ impl<Data> BitUnpacker<Data>
             for val in output.iter_mut() {
                 *val = 0;
             }
-        }
-        else {
+        } else {
             let data: &[u8] = &*self.data;
             let num_bits = self.num_bits;
             let mask = self.mask;
-            
             let mut addr_in_bits = (start as usize) * num_bits;
-            for i in 0..output.len() {
+            for output_val in output.iter_mut() {
                 let addr = addr_in_bits >> 3;
                 let bit_shift = addr_in_bits & 7;
                 let val_unshifted_unmasked: u64 = unsafe { *(data[addr..].as_ptr() as *const u64) };
                 let val_shifted = (val_unshifted_unmasked >> bit_shift) as u64;
-                output[i] = val_shifted & mask;
+                *output_val = val_shifted & mask;
                 addr_in_bits += num_bits;
             }
         }
-        
+
     }
 }
 
@@ -172,7 +170,7 @@ mod test {
         assert_eq!(compute_num_bits(5_000_000_000), 33u8);
     }
 
-    fn test_bitpacker_util(len: usize, num_bits: usize) {
+    fn create_fastfield_bitpacker(len: usize, num_bits: usize) -> (BitUnpacker<Vec<u8>>, Vec<u64>) {
         let mut data = Vec::new();
         let mut bitpacker = BitPacker::new(num_bits);
         let max_val: u64 = (1 << num_bits) - 1;
@@ -185,6 +183,11 @@ mod test {
         bitpacker.close(&mut data).unwrap();
         assert_eq!(data.len(), (num_bits * len + 7) / 8 + 7);
         let bitunpacker = BitUnpacker::new(data, num_bits);
+        (bitunpacker, vals)
+    }
+
+    fn test_bitpacker_util(len: usize, num_bits: usize) {
+        let (bitunpacker, vals) = create_fastfield_bitpacker(len, num_bits);
         for (i, val) in vals.iter().enumerate() {
             assert_eq!(bitunpacker.get(i), *val);
         }
@@ -198,4 +201,17 @@ mod test {
         test_bitpacker_util(6, 14);
         test_bitpacker_util(1000, 14);
     }
+
+    #[test]
+    fn test_bitpacker_range() {
+        let (bitunpacker, vals) = create_fastfield_bitpacker(100_000, 12);
+        let buffer_len = 100;
+        let mut buffer = vec![0u64; buffer_len];
+        for start in vec![0, 10, 20, 100, 1_000] {
+            bitunpacker.get_range(start as u32, &mut buffer[..]);
+            for i in 0..buffer_len {
+                assert_eq!(buffer[i], vals[start + i]);
+            }
+        }
+    }
 }