fix tests (#1813)

bitpacker/benches/bench.rs

@@ -6,12 +6,9 @@ extern crate test;
 mod tests {
     use rand::seq::IteratorRandom;
     use rand::thread_rng;
-    use tantivy_bitpacker::BitPacker;
-    use tantivy_bitpacker::BitUnpacker;
-    use tantivy_bitpacker::BlockedBitpacker;
+    use tantivy_bitpacker::{BitPacker, BitUnpacker, BlockedBitpacker};
     use test::Bencher;
 
-
     #[inline(never)]
     fn create_bitpacked_data(bit_width: u8, num_els: u32) -> Vec<u8> {
         let mut bitpacker = BitPacker::new();

bitpacker/src/bitpacker.rs

@@ -135,7 +135,7 @@ mod test {
             bitpacker.write(val, num_bits, &mut data).unwrap();
         }
         bitpacker.close(&mut data).unwrap();
-        assert_eq!(data.len(), ((num_bits as usize) * len + 7) / 8 + 7);
+        assert_eq!(data.len(), ((num_bits as usize) * len + 7) / 8);
         let bitunpacker = BitUnpacker::new(num_bits);
         (bitunpacker, vals, data)
     }
@@ -159,13 +159,7 @@ mod test {
     use proptest::prelude::*;
 
     fn num_bits_strategy() -> impl Strategy<Value = u8> {
-        prop_oneof!(
-            Just(0),
-            Just(1),
-            2u8..56u8,
-            Just(56),
-            Just(64),
-        )
+        prop_oneof!(Just(0), Just(1), 2u8..56u8, Just(56), Just(64),)
     }
 
     fn vals_strategy() -> impl Strategy<Value = (u8, Vec<u64>)> {
@@ -189,8 +183,7 @@ mod test {
         bitpacker.flush(&mut buffer).unwrap();
         assert_eq!(buffer.len(), (vals.len() * num_bits as usize + 7) / 8);
         let bitunpacker = BitUnpacker::new(num_bits);
-        let max_val =
-            if num_bits == 64 {
+        let max_val = if num_bits == 64 {
             u64::MAX
         } else {
             (1u64 << num_bits) - 1

fastfield_codecs/src/serialize.rs

@@ -402,8 +402,8 @@ mod tests {
         let mut buffer = Vec::new();
         let col = VecColumn::from(&[false, true][..]);
         serialize(col, &mut buffer, &ALL_CODEC_TYPES).unwrap();
-        // 5 bytes of header, 1 byte of value, 7 bytes of padding.
-        assert_eq!(buffer.len(), 3 + 5 + 8 + 4 + 2);
+        // 5 bytes of header, 1 byte of value
+        assert_eq!(buffer.len(), 3 + 5 + 1 + 4 + 2);
     }
 
     #[test]
@@ -411,8 +411,8 @@ mod tests {
         let mut buffer = Vec::new();
         let col = VecColumn::from(&[true][..]);
         serialize(col, &mut buffer, &ALL_CODEC_TYPES).unwrap();
-        // 5 bytes of header, 0 bytes of value, 7 bytes of padding.
-        assert_eq!(buffer.len(), 3 + 5 + 7 + 4 + 2);
+        // 5 bytes of header, 0 bytes of value
+        assert_eq!(buffer.len(), 3 + 5 + 4 + 2);
     }
 
     #[test]
@@ -422,6 +422,6 @@ mod tests {
         let col = VecColumn::from(&vals[..]);
         serialize(col, &mut buffer, &[FastFieldCodecType::Bitpacked]).unwrap();
         // Values are stored over 3 bits.
-        assert_eq!(buffer.len(), 3 + 7 + (3 * 80 / 8) + 7 + 4 + 2);
+        assert_eq!(buffer.len(), 3 + 7 + (3 * 80 / 8) + 4 + 2);
     }
 }

run-tests.sh

@@ -1,2 +0,0 @@
-#!/bin/bash
-cargo test