Added tests to scalar API (#300)

README.md

@@ -1,6 +1,7 @@
 # Arrow2: Transmute-free Arrow
 
 [![test](/~https://github.com/jorgecarleitao/arrow2/actions/workflows/test.yml/badge.svg)](/~https://github.com/jorgecarleitao/arrow2/actions/workflows/Build.yml)
+[![codecov](https://codecov.io/gh/jorgecarleitao/arrow2/branch/main/graph/badge.svg?token=AgyTF60R3D)](https://codecov.io/gh/jorgecarleitao/arrow2)
 [![](https://img.shields.io/crates/d/arrow2.svg)](https://crates.io/crates/arrow2)
 [![](https://img.shields.io/crates/dv/arrow2.svg)](https://crates.io/crates/arrow2)
 [![](https://docs.rs/arrow2/badge.svg)](https://docs.rs/arrow2/)

src/scalar/binary.rs

@@ -61,35 +61,3 @@ impl<O: Offset> Scalar for BinaryScalar<O> {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[allow(clippy::eq_op)]
-    #[test]
-    fn equal() {
-        let a = BinaryScalar::<i32>::from(Some("a"));
-        let b = BinaryScalar::<i32>::from(None::<&str>);
-        assert_eq!(a, a);
-        assert_eq!(b, b);
-        assert!(a != b);
-        let b = BinaryScalar::<i32>::from(Some("b"));
-        assert!(a != b);
-        assert_eq!(b, b);
-    }
-
-    #[test]
-    fn basics() {
-        let a = BinaryScalar::<i32>::from(Some("a"));
-
-        assert_eq!(a.value(), b"a");
-        assert_eq!(a.data_type(), &DataType::Binary);
-        assert!(a.is_valid());
-
-        let a = BinaryScalar::<i64>::from(None::<&str>);
-
-        assert_eq!(a.data_type(), &DataType::LargeBinary);
-        assert!(!a.is_valid());
-    }
-}

src/scalar/boolean.rs

@@ -53,30 +53,3 @@ impl From<Option<bool>> for BooleanScalar {
         Self::new(v)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[allow(clippy::eq_op)]
-    #[test]
-    fn equal() {
-        let a = BooleanScalar::from(Some(true));
-        let b = BooleanScalar::from(None);
-        assert_eq!(a, a);
-        assert_eq!(b, b);
-        assert!(a != b);
-        let b = BooleanScalar::from(Some(false));
-        assert!(a != b);
-        assert_eq!(b, b);
-    }
-
-    #[test]
-    fn basics() {
-        let a = BooleanScalar::new(Some(true));
-
-        assert!(a.value());
-        assert_eq!(a.data_type(), &DataType::Boolean);
-        assert!(a.is_valid());
-    }
-}

src/scalar/primitive.rs

@@ -73,41 +73,3 @@ impl<T: NativeType> Scalar for PrimitiveScalar<T> {
         &self.data_type
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[allow(clippy::eq_op)]
-    #[test]
-    fn equal() {
-        let a = PrimitiveScalar::from(Some(2i32));
-        let b = PrimitiveScalar::<i32>::from(None);
-        assert_eq!(a, a);
-        assert_eq!(b, b);
-        assert!(a != b);
-        let b = PrimitiveScalar::<i32>::from(Some(1i32));
-        assert!(a != b);
-        assert_eq!(b, b);
-    }
-
-    #[test]
-    fn basics() {
-        let a = PrimitiveScalar::from(Some(2i32));
-
-        assert_eq!(a.value(), 2i32);
-        assert_eq!(a.data_type(), &DataType::Int32);
-        assert!(a.is_valid());
-
-        let a = a.to(DataType::Date32);
-        assert_eq!(a.data_type(), &DataType::Date32);
-
-        let a = PrimitiveScalar::<i32>::from(None);
-
-        assert_eq!(a.data_type(), &DataType::Int32);
-        assert!(!a.is_valid());
-
-        let a = a.to(DataType::Date32);
-        assert_eq!(a.data_type(), &DataType::Date32);
-    }
-}

src/scalar/utf8.rs

@@ -61,35 +61,3 @@ impl<O: Offset> Scalar for Utf8Scalar<O> {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[allow(clippy::eq_op)]
-    #[test]
-    fn equal() {
-        let a = Utf8Scalar::<i32>::from(Some("a"));
-        let b = Utf8Scalar::<i32>::from(None::<&str>);
-        assert_eq!(a, a);
-        assert_eq!(b, b);
-        assert!(a != b);
-        let b = Utf8Scalar::<i32>::from(Some("b"));
-        assert!(a != b);
-        assert_eq!(b, b);
-    }
-
-    #[test]
-    fn basics() {
-        let a = Utf8Scalar::<i32>::from(Some("a"));
-
-        assert_eq!(a.value(), "a");
-        assert_eq!(a.data_type(), &DataType::Utf8);
-        assert!(a.is_valid());
-
-        let a = Utf8Scalar::<i64>::from(None::<&str>);
-
-        assert_eq!(a.data_type(), &DataType::LargeUtf8);
-        assert!(!a.is_valid());
-    }
-}

tests/it/array/boolean/mutable.rs

@@ -1,4 +1,5 @@
 use arrow2::array::{MutableArray, MutableBooleanArray};
+use arrow2::bitmap::MutableBitmap;
 use arrow2::error::Result;
 
 #[test]
@@ -10,7 +11,8 @@ fn set() {
     assert_eq!(
         a,
         MutableBooleanArray::from([Some(true), None, Some(false)])
-    )
+    );
+    assert_eq!(a.values(), &MutableBitmap::from([true, false, false]));
 }
 
 #[test]
@@ -42,7 +44,18 @@ fn from_iter() {
 
 #[test]
 fn try_from_trusted_len_iter() {
-    let iter = std::iter::repeat(Some(true)).take(2).map(Result::Ok);
+    let iter = vec![Some(true), Some(true), None]
+        .into_iter()
+        .map(Result::Ok);
     let a = MutableBooleanArray::try_from_trusted_len_iter(iter).unwrap();
-    assert_eq!(a, MutableBooleanArray::from([Some(true), Some(true)]));
+    assert_eq!(a, MutableBooleanArray::from([Some(true), Some(true), None]));
+}
+
+#[test]
+fn reserve() {
+    let mut a = MutableBooleanArray::from_data(MutableBitmap::new(), Some(MutableBitmap::new()));
+
+    a.reserve(10);
+    assert!(a.validity().as_ref().unwrap().capacity() > 0);
+    assert!(a.values().capacity() > 0)
 }

tests/it/array/growable/struct_.rs

@@ -98,22 +98,32 @@ fn many() {
 
     let array = StructArray::from_data(fields.clone(), values.clone(), None);
 
-    let mut mutable = GrowableStruct::new(vec![&array, &array], false, 0);
+    let mut mutable = GrowableStruct::new(vec![&array, &array], true, 0);
 
     mutable.extend(0, 1, 2);
     mutable.extend(1, 0, 2);
-    let result: StructArray = mutable.into();
+    mutable.extend_validity(1);
+    let result = mutable.as_box();
 
     let expected_string: Arc<dyn Array> = Arc::new(Utf8Array::<i32>::from(&[
         Some("aa"),
         None,
         Some("a"),
         Some("aa"),
+        None,
+    ]));
+    let expected_int: Arc<dyn Array> = Arc::new(PrimitiveArray::<i32>::from(vec![
+        Some(2),
+        Some(3),
+        Some(1),
+        Some(2),
+        None,
     ]));
-    let expected_int: Arc<dyn Array> = Arc::new(
-        PrimitiveArray::<i32>::from(vec![Some(2), Some(3), Some(1), Some(2)]).to(DataType::Int32),
-    );
 
-    let expected = StructArray::from_data(fields, vec![expected_string, expected_int], None);
-    assert_eq!(result, expected)
+    let expected = StructArray::from_data(
+        fields,
+        vec![expected_string, expected_int],
+        Some(Bitmap::from([true, true, true, true, false])),
+    );
+    assert_eq!(expected, result.as_ref())
 }

tests/it/main.rs

@@ -3,8 +3,10 @@ mod array;
 mod bitmap;
 mod buffer;
 mod ffi;
+mod scalar;
 
 mod io;
 mod test_util;
 
+#[cfg(feature = "compute")]
 mod compute;

tests/it/scalar/binary.rs

@@ -0,0 +1,33 @@
+use arrow2::{
+    datatypes::DataType,
+    scalar::{BinaryScalar, Scalar},
+};
+
+#[allow(clippy::eq_op)]
+#[test]
+fn equal() {
+    let a = BinaryScalar::<i32>::from(Some("a"));
+    let b = BinaryScalar::<i32>::from(None::<&str>);
+    assert_eq!(a, a);
+    assert_eq!(b, b);
+    assert!(a != b);
+    let b = BinaryScalar::<i32>::from(Some("b"));
+    assert!(a != b);
+    assert_eq!(b, b);
+}
+
+#[test]
+fn basics() {
+    let a = BinaryScalar::<i32>::from(Some("a"));
+
+    assert_eq!(a.value(), b"a");
+    assert_eq!(a.data_type(), &DataType::Binary);
+    assert!(a.is_valid());
+
+    let a = BinaryScalar::<i64>::from(None::<&str>);
+
+    assert_eq!(a.data_type(), &DataType::LargeBinary);
+    assert!(!a.is_valid());
+
+    let _: &dyn std::any::Any = a.as_any();
+}

tests/it/scalar/boolean.rs

@@ -0,0 +1,28 @@
+use arrow2::{
+    datatypes::DataType,
+    scalar::{BooleanScalar, Scalar},
+};
+
+#[allow(clippy::eq_op)]
+#[test]
+fn equal() {
+    let a = BooleanScalar::from(Some(true));
+    let b = BooleanScalar::from(None);
+    assert_eq!(a, a);
+    assert_eq!(b, b);
+    assert!(a != b);
+    let b = BooleanScalar::from(Some(false));
+    assert!(a != b);
+    assert_eq!(b, b);
+}
+
+#[test]
+fn basics() {
+    let a = BooleanScalar::new(Some(true));
+
+    assert!(a.value());
+    assert_eq!(a.data_type(), &DataType::Boolean);
+    assert!(a.is_valid());
+
+    let _: &dyn std::any::Any = a.as_any();
+}

tests/it/scalar/list.rs

@@ -0,0 +1,42 @@
+use std::sync::Arc;
+
+use arrow2::{
+    array::{Array, BooleanArray},
+    datatypes::{DataType, Field},
+    scalar::{ListScalar, Scalar},
+};
+
+#[allow(clippy::eq_op)]
+#[test]
+fn equal() {
+    let dt = DataType::List(Box::new(Field::new("a", DataType::Boolean, true)));
+    let a = ListScalar::<i32>::new(
+        dt.clone(),
+        Some(Arc::new(BooleanArray::from_slice([true, false])) as Arc<dyn Array>),
+    );
+    let b = ListScalar::<i32>::new(dt.clone(), None);
+    assert_eq!(a, a);
+    assert_eq!(b, b);
+    assert!(a != b);
+    let b = ListScalar::<i32>::new(
+        dt,
+        Some(Arc::new(BooleanArray::from_slice([true, true])) as Arc<dyn Array>),
+    );
+    assert!(a != b);
+    assert_eq!(b, b);
+}
+
+#[test]
+fn basics() {
+    let dt = DataType::List(Box::new(Field::new("a", DataType::Boolean, true)));
+    let a = ListScalar::<i32>::new(
+        dt.clone(),
+        Some(Arc::new(BooleanArray::from_slice([true, false])) as Arc<dyn Array>),
+    );
+
+    assert_eq!(BooleanArray::from_slice([true, false]), a.values().as_ref());
+    assert_eq!(a.data_type(), &dt);
+    assert!(a.is_valid());
+
+    let _: &dyn std::any::Any = a.as_any();
+}

tests/it/scalar/mod.rs

@@ -0,0 +1,7 @@
+mod binary;
+mod boolean;
+mod list;
+mod null;
+mod primitive;
+mod struct_;
+mod utf8;

tests/it/scalar/null.rs

@@ -0,0 +1,21 @@
+use arrow2::{
+    datatypes::DataType,
+    scalar::{NullScalar, Scalar},
+};
+
+#[allow(clippy::eq_op)]
+#[test]
+fn equal() {
+    let a = NullScalar::new();
+    assert_eq!(a, a);
+}
+
+#[test]
+fn basics() {
+    let a = NullScalar::default();
+
+    assert_eq!(a.data_type(), &DataType::Null);
+    assert!(!a.is_valid());
+
+    let _: &dyn std::any::Any = a.as_any();
+}