Added more tests (increase coverage) (#1027)

src/array/binary/mutable.rs

@@ -163,6 +163,7 @@ impl<O: Offset> MutableBinaryArray<O> {
         let a: BinaryArray<O> = self.into();
         Arc::new(a)
     }
+
     /// Shrinks the capacity of the [`MutableBinaryArray`] to fit its current length.
     pub fn shrink_to_fit(&mut self) {
         self.values.shrink_to_fit();

src/array/fixed_size_binary/mod.rs

@@ -125,7 +125,7 @@ impl FixedSizeBinaryArray {
         let values = self
             .values
             .clone()
-            .slice_unchecked(offset * self.size as usize, length * self.size as usize);
+            .slice_unchecked(offset * self.size, length * self.size);
         Self {
             data_type: self.data_type.clone(),
             size: self.size,

src/ffi/schema.rs

@@ -306,6 +306,7 @@ unsafe fn to_data_type(schema: &ArrowSchema) -> Result<DataType> {
                     let size = size_raw
                         .parse::<usize>()
                         .map_err(|_| Error::OutOfSpec("size is not a valid integer".to_string()))?;
+                    println!("schema: {}", size);
                     DataType::FixedSizeBinary(size)
                 }
                 ["+w", size_raw] => {

src/trusted_len.rs

@@ -21,6 +21,12 @@ where
     T: Copy,
 {
 }
+unsafe impl<'a, I, T: 'a> TrustedLen for std::iter::Cloned<I>
+where
+    I: TrustedLen<Item = &'a T>,
+    T: Clone,
+{
+}
 
 unsafe impl<I> TrustedLen for std::iter::Enumerate<I> where I: TrustedLen {}
 

tests/it/array/binary/mod.rs

@@ -66,6 +66,16 @@ fn from_trusted_len_iter() {
     assert_eq!(a.len(), 2);
 }
 
+#[test]
+fn try_from_trusted_len_iter() {
+    let iter = std::iter::repeat(b"hello".as_ref())
+        .take(2)
+        .map(Some)
+        .map(arrow2::error::Result::Ok);
+    let a = BinaryArray::<i32>::try_from_trusted_len_iter(iter).unwrap();
+    assert_eq!(a.len(), 2);
+}
+
 #[test]
 fn from_iter() {
     let iter = std::iter::repeat(b"hello").take(2).map(Some);

tests/it/array/binary/mutable.rs

@@ -35,30 +35,26 @@ fn from_iter() {
 
 #[test]
 fn from_trusted_len_iter() {
-    let iter = (0..3u8).map(|x| vec![x; x as usize]);
-    let a: MutableBinaryArray<i32> = iter.clone().map(Some).collect();
+    let data = vec![vec![0; 0], vec![1; 1], vec![2; 2]];
+    let a: MutableBinaryArray<i32> = data.iter().cloned().map(Some).collect();
     assert_eq!(a.values().deref(), &[1u8, 2, 2]);
     assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]);
     assert_eq!(a.validity(), None);
 
-    let a = unsafe {
-        MutableBinaryArray::<i32>::from_trusted_len_iter_unchecked(iter.clone().map(Some))
-    };
+    let a = MutableBinaryArray::<i32>::from_trusted_len_iter(data.iter().cloned().map(Some));
     assert_eq!(a.values().deref(), &[1u8, 2, 2]);
     assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]);
     assert_eq!(a.validity(), None);
 
-    let a = unsafe {
-        MutableBinaryArray::<i32>::try_from_trusted_len_iter_unchecked::<Error, _, _>(
-            iter.clone().map(Some).map(Ok),
-        )
-    }
+    let a = MutableBinaryArray::<i32>::try_from_trusted_len_iter::<Error, _, _>(
+        data.iter().cloned().map(Some).map(Ok),
+    )
     .unwrap();
     assert_eq!(a.values().deref(), &[1u8, 2, 2]);
     assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]);
     assert_eq!(a.validity(), None);
 
-    let a = unsafe { MutableBinaryArray::<i32>::from_trusted_len_values_iter_unchecked(iter) };
+    let a = MutableBinaryArray::<i32>::from_trusted_len_values_iter(data.iter().cloned());
     assert_eq!(a.values().deref(), &[1u8, 2, 2]);
     assert_eq!(a.offsets().deref(), &[0, 0, 1, 3]);
     assert_eq!(a.validity(), None);

tests/it/array/boolean/mod.rs

@@ -39,6 +39,15 @@ fn basics() {
     assert!(!array.value(1));
 }
 
+#[test]
+fn try_new_invalid() {
+    assert!(BooleanArray::try_new(DataType::Int32, [true].into(), None).is_err());
+    assert!(
+        BooleanArray::try_new(DataType::Boolean, [true].into(), Some([false, true].into()))
+            .is_err()
+    );
+}
+
 #[test]
 fn with_validity() {
     let bitmap = Bitmap::from([true, false, true]);
@@ -58,14 +67,25 @@ fn into_mut_valid() {
     let bitmap = Bitmap::from([true, false, true]);
     let a = BooleanArray::from_data(DataType::Boolean, bitmap, None);
     let _ = a.into_mut().right().unwrap();
+
+    let bitmap = Bitmap::from([true, false, true]);
+    let validity = Bitmap::from([true, false, true]);
+    let a = BooleanArray::from_data(DataType::Boolean, bitmap, Some(validity));
+    let _ = a.into_mut().right().unwrap();
 }
 
 #[test]
 fn into_mut_invalid() {
     let bitmap = Bitmap::from([true, false, true]);
-    let _other = bitmap.clone(); // values are shared
+    let _other = bitmap.clone(); // values is shared
     let a = BooleanArray::from_data(DataType::Boolean, bitmap, None);
     let _ = a.into_mut().left().unwrap();
+
+    let bitmap = Bitmap::from([true, false, true]);
+    let validity = Bitmap::from([true, false, true]);
+    let _other = validity.clone(); // validity is shared
+    let a = BooleanArray::from_data(DataType::Boolean, bitmap, Some(validity));
+    let _ = a.into_mut().left().unwrap();
 }
 
 #[test]
@@ -78,7 +98,30 @@ fn empty() {
 #[test]
 fn from_trusted_len_iter() {
     let iter = std::iter::repeat(true).take(2).map(Some);
-    let a = BooleanArray::from_trusted_len_iter(iter);
+    let a = BooleanArray::from_trusted_len_iter(iter.clone());
+    assert_eq!(a.len(), 2);
+    let a = unsafe { BooleanArray::from_trusted_len_iter_unchecked(iter) };
+    assert_eq!(a.len(), 2);
+}
+
+#[test]
+fn try_from_trusted_len_iter() {
+    let iter = std::iter::repeat(true)
+        .take(2)
+        .map(Some)
+        .map(arrow2::error::Result::Ok);
+    let a = BooleanArray::try_from_trusted_len_iter(iter.clone()).unwrap();
+    assert_eq!(a.len(), 2);
+    let a = unsafe { BooleanArray::try_from_trusted_len_iter_unchecked(iter).unwrap() };
+    assert_eq!(a.len(), 2);
+}
+
+#[test]
+fn from_trusted_len_values_iter() {
+    let iter = std::iter::repeat(true).take(2);
+    let a = BooleanArray::from_trusted_len_values_iter(iter.clone());
+    assert_eq!(a.len(), 2);
+    let a = unsafe { BooleanArray::from_trusted_len_values_iter_unchecked(iter) };
     assert_eq!(a.len(), 2);
 }
 

tests/it/array/boolean/mutable.rs

@@ -142,3 +142,23 @@ fn extend_trusted_len_values() {
     );
     assert_eq!(a.values(), &MutableBitmap::from([false, true, false]));
 }
+
+#[test]
+fn into_iter() {
+    let ve = MutableBitmap::from([true, false])
+        .into_iter()
+        .collect::<Vec<_>>();
+    assert_eq!(ve, vec![true, false]);
+    let ve = MutableBitmap::from([true, false])
+        .iter()
+        .collect::<Vec<_>>();
+    assert_eq!(ve, vec![true, false]);
+}
+
+#[test]
+fn shrink_to_fit() {
+    let mut a = MutableBitmap::with_capacity(100);
+    a.push(true);
+    a.shrink_to_fit();
+    assert_eq!(a.capacity(), 8);
+}

tests/it/bitmap/mutable.rs

@@ -7,6 +7,32 @@ fn from_slice() {
     assert_eq!(a.iter().collect::<Vec<_>>(), slice);
 }
 
+#[test]
+fn from_len_zeroed() {
+    let a = MutableBitmap::from_len_zeroed(10);
+    assert_eq!(a.len(), 10);
+    assert_eq!(a.null_count(), 10);
+}
+
+#[test]
+fn from_len_set() {
+    let a = MutableBitmap::from_len_set(10);
+    assert_eq!(a.len(), 10);
+    assert_eq!(a.null_count(), 0);
+}
+
+#[test]
+fn try_new_invalid() {
+    assert!(MutableBitmap::try_new(vec![], 2).is_err());
+}
+
+#[test]
+fn clear() {
+    let mut a = MutableBitmap::from_len_zeroed(10);
+    a.clear();
+    assert_eq!(a.len(), 0);
+}
+
 #[test]
 fn trusted_len() {
     let data = vec![true; 65];