Fixing unit tests

src/datastruct/stacker/hashmap.rs

@@ -64,8 +64,7 @@ mod murmurhash2 {
 pub(crate) fn split_memory(per_thread_memory_budget: usize) -> (usize, usize) {
     let table_size_limit: usize = per_thread_memory_budget / 3;
     let compute_table_size = |num_bits: usize| {
-        let table_size: usize = (1 << num_bits) * mem::size_of::<KeyValue>();
-        table_size * mem::size_of::<KeyValue>()
+        (1 << num_bits) * mem::size_of::<KeyValue>()
     };
     let table_num_bits: usize = (1..)
         .into_iter()
@@ -91,7 +90,6 @@ pub(crate) fn split_memory(per_thread_memory_budget: usize) -> (usize, usize) {
 /// For this reason, the (start, stop) information is actually redundant
 /// and can be simplified in the future
 #[derive(Copy, Clone, Default)]
-#[repr(packed)]
 struct KeyValue {
     key_value_addr: BytesRef,
     hash: u32,
@@ -242,9 +240,9 @@ mod tests {
 
     #[test]
     fn test_hashmap_size() {
-        assert_eq!(split_memory(100_000), (67232, 9));
-        assert_eq!(split_memory(1_000_000), (737856, 12));
-        assert_eq!(split_memory(10_000_000), (7902848, 15));
+        assert_eq!(split_memory(100_000), (67232, 12));
+        assert_eq!(split_memory(1_000_000), (737856, 15));
+        assert_eq!(split_memory(10_000_000), (7902848, 18));
     }
 
 

src/fastfield/mod.rs

@@ -134,7 +134,7 @@ mod tests {
         }
         let source = directory.open_read(&path).unwrap();
         {
-            assert_eq!(source.len(), 60 as usize);
+            assert_eq!(source.len(), 61 as usize);
         }
         {
             let fast_fields_composite = CompositeFile::open(&source).unwrap();
@@ -169,7 +169,7 @@ mod tests {
         }
         let source = directory.open_read(&path).unwrap();
         {
-            assert_eq!(source.len(), 33 as usize);
+            assert_eq!(source.len(), 34 as usize);
         }
         {
             let fast_fields_composite = CompositeFile::open(&source).unwrap();
@@ -204,7 +204,7 @@ mod tests {
         }
         let source = directory.open_read(&path).unwrap();
         {
-            assert_eq!(source.len(), 80041 as usize);
+            assert_eq!(source.len(), 80042 as usize);
         }
         {
             let fast_fields_composite = CompositeFile::open(&source).unwrap();
@@ -243,7 +243,7 @@ mod tests {
         }
         let source = directory.open_read(&path).unwrap();
         {
-            assert_eq!(source.len(), 17708 as usize);
+            assert_eq!(source.len(), 17709 as usize);
         }
         {
             let fast_fields_composite = CompositeFile::open(&source).unwrap();

src/indexer/index_writer.rs

@@ -106,7 +106,7 @@ pub fn open_index_writer(
     heap_size_in_bytes_per_thread: usize,
     directory_lock: DirectoryLock,
 ) -> Result<IndexWriter> {
-    if heap_size_in_bytes_per_thread <= HEAP_SIZE_LIMIT as usize {
+    if heap_size_in_bytes_per_thread < HEAP_SIZE_LIMIT as usize {
         panic!(format!(
             "The heap size per thread needs to be at least {}.",
             HEAP_SIZE_LIMIT

src/indexer/merger.rs

@@ -3,7 +3,6 @@ use core::SegmentReader;
 use core::Segment;
 use DocId;
 use core::SerializableSegment;
-use schema::FieldValue;
 use indexer::SegmentSerializer;
 use postings::InvertedIndexSerializer;
 use fastfield::U64FastFieldReader;

src/indexer/segment_writer.rs

@@ -8,7 +8,6 @@ use core::Segment;
 use core::SerializableSegment;
 use fastfield::FastFieldsWriter;
 use schema::Field;
-use schema::FieldValue;
 use schema::FieldType;
 use indexer::segment_serializer::SegmentSerializer;
 use std::collections::HashMap;
@@ -230,10 +229,6 @@ impl<'a> SegmentWriter<'a> {
         doc.filter_fields(|field| {
             schema.get_field_entry(field).is_stored()
         });
-        let stored_fieldvalues: Vec<&FieldValue> = doc.field_values()
-            .iter()
-            .filter(|field_value| schema.get_field_entry(field_value.field()).is_stored())
-            .collect();
         let doc_writer = self.segment_serializer.get_store_writer();
         doc_writer.store(&doc)?;
         self.max_doc += 1;

src/schema/term.rs

@@ -96,15 +96,6 @@ impl Term {
         self.0.resize(4, 0u8);
         self.0.extend(text.as_bytes());
     }
-
-    /// Builds a term from its byte representation.
-    ///
-    /// If you want to build a field for a given `str`,
-    /// you want to use `from_field_text`.
-    #[cfg(test)]
-    pub(crate) fn from_bytes(data: &[u8]) -> Term {
-        Term(Vec::from(data))
-    }
 }
 
 impl<B> Term<B>

src/store/reader.rs

@@ -4,7 +4,6 @@ use directory::ReadOnlySource;
 use std::cell::RefCell;
 use DocId;
 use schema::Document;
-use schema::FieldValue;
 use common::BinarySerializable;
 use std::mem::size_of;
 use std::io::{self, Read};

src/store/writer.rs

@@ -1,6 +1,5 @@
 use directory::WritePtr;
 use DocId;
-use schema::FieldValue;
 use common::BinarySerializable;
 use std::io::{self, Write};
 use super::StoreReader;
@@ -50,7 +49,8 @@ impl StoreWriter {
     ///
     pub fn store<'a>(&mut self, stored_document: &Document) -> io::Result<()> {
         self.intermediary_buffer.clear();
-        bincode::serialize_into(&mut self.intermediary_buffer, stored_document, bincode::Infinite);
+        bincode::serialize_into(&mut self.intermediary_buffer, stored_document, bincode::Infinite)
+            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
         let doc_num_bytes = self.intermediary_buffer.len() as u32;
         <u32 as BinarySerializable>::serialize(&doc_num_bytes, &mut self.current_block)?;
         self.current_block.write_all(&self.intermediary_buffer[..])?;