From bbe607ccbf3d7079c1fac6ad53fc6e5d4368e165 Mon Sep 17 00:00:00 2001 From: Jorge Leitao Date: Thu, 19 Aug 2021 10:07:04 +0100 Subject: [PATCH] Added tests to scalar API (#300) --- README.md | 1 + src/scalar/binary.rs | 32 --------------------- src/scalar/boolean.rs | 27 ------------------ src/scalar/primitive.rs | 38 ------------------------- src/scalar/utf8.rs | 32 --------------------- tests/it/array/boolean/mutable.rs | 19 +++++++++++-- tests/it/array/growable/struct_.rs | 24 +++++++++++----- tests/it/main.rs | 2 ++ tests/it/scalar/binary.rs | 33 ++++++++++++++++++++++ tests/it/scalar/boolean.rs | 28 +++++++++++++++++++ tests/it/scalar/list.rs | 42 ++++++++++++++++++++++++++++ tests/it/scalar/mod.rs | 7 +++++ tests/it/scalar/null.rs | 21 ++++++++++++++ tests/it/scalar/primitive.rs | 39 ++++++++++++++++++++++++++ tests/it/scalar/struct_.rs | 45 ++++++++++++++++++++++++++++++ tests/it/scalar/utf8.rs | 33 ++++++++++++++++++++++ 16 files changed, 284 insertions(+), 139 deletions(-) create mode 100644 tests/it/scalar/binary.rs create mode 100644 tests/it/scalar/boolean.rs create mode 100644 tests/it/scalar/list.rs create mode 100644 tests/it/scalar/mod.rs create mode 100644 tests/it/scalar/null.rs create mode 100644 tests/it/scalar/primitive.rs create mode 100644 tests/it/scalar/struct_.rs create mode 100644 tests/it/scalar/utf8.rs diff --git a/README.md b/README.md index 61a5c5439d8..18b946ae63f 100644 --- a/README.md +++ b/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/) diff --git a/src/scalar/binary.rs b/src/scalar/binary.rs index fbd769f9d5c..f847e8f0c88 100644 --- a/src/scalar/binary.rs +++ b/src/scalar/binary.rs @@ -61,35 +61,3 @@ impl Scalar for BinaryScalar { } } } - -#[cfg(test)] -mod tests { - use super::*; - - #[allow(clippy::eq_op)] - #[test] - fn equal() { - let a = BinaryScalar::::from(Some("a")); - let b = BinaryScalar::::from(None::<&str>); - assert_eq!(a, a); - assert_eq!(b, b); - assert!(a != b); - let b = BinaryScalar::::from(Some("b")); - assert!(a != b); - assert_eq!(b, b); - } - - #[test] - fn basics() { - let a = BinaryScalar::::from(Some("a")); - - assert_eq!(a.value(), b"a"); - assert_eq!(a.data_type(), &DataType::Binary); - assert!(a.is_valid()); - - let a = BinaryScalar::::from(None::<&str>); - - assert_eq!(a.data_type(), &DataType::LargeBinary); - assert!(!a.is_valid()); - } -} diff --git a/src/scalar/boolean.rs b/src/scalar/boolean.rs index 67137c752f1..7f0ffdaa0de 100644 --- a/src/scalar/boolean.rs +++ b/src/scalar/boolean.rs @@ -53,30 +53,3 @@ impl From> 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()); - } -} diff --git a/src/scalar/primitive.rs b/src/scalar/primitive.rs index b204a774ef8..90265bf7cb0 100644 --- a/src/scalar/primitive.rs +++ b/src/scalar/primitive.rs @@ -73,41 +73,3 @@ impl Scalar for PrimitiveScalar { &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::::from(None); - assert_eq!(a, a); - assert_eq!(b, b); - assert!(a != b); - let b = PrimitiveScalar::::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::::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); - } -} diff --git a/src/scalar/utf8.rs b/src/scalar/utf8.rs index 32fe5d7f1bb..207fe084f0c 100644 --- a/src/scalar/utf8.rs +++ b/src/scalar/utf8.rs @@ -61,35 +61,3 @@ impl Scalar for Utf8Scalar { } } } - -#[cfg(test)] -mod tests { - use super::*; - - #[allow(clippy::eq_op)] - #[test] - fn equal() { - let a = Utf8Scalar::::from(Some("a")); - let b = Utf8Scalar::::from(None::<&str>); - assert_eq!(a, a); - assert_eq!(b, b); - assert!(a != b); - let b = Utf8Scalar::::from(Some("b")); - assert!(a != b); - assert_eq!(b, b); - } - - #[test] - fn basics() { - let a = Utf8Scalar::::from(Some("a")); - - assert_eq!(a.value(), "a"); - assert_eq!(a.data_type(), &DataType::Utf8); - assert!(a.is_valid()); - - let a = Utf8Scalar::::from(None::<&str>); - - assert_eq!(a.data_type(), &DataType::LargeUtf8); - assert!(!a.is_valid()); - } -} diff --git a/tests/it/array/boolean/mutable.rs b/tests/it/array/boolean/mutable.rs index 07c4a7e54e7..70ca6845f29 100644 --- a/tests/it/array/boolean/mutable.rs +++ b/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) } diff --git a/tests/it/array/growable/struct_.rs b/tests/it/array/growable/struct_.rs index ed5e715c46e..f26e4c08ae4 100644 --- a/tests/it/array/growable/struct_.rs +++ b/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 = Arc::new(Utf8Array::::from(&[ Some("aa"), None, Some("a"), Some("aa"), + None, + ])); + let expected_int: Arc = Arc::new(PrimitiveArray::::from(vec![ + Some(2), + Some(3), + Some(1), + Some(2), + None, ])); - let expected_int: Arc = Arc::new( - PrimitiveArray::::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()) } diff --git a/tests/it/main.rs b/tests/it/main.rs index b1501a9f243..ad9a9b97353 100644 --- a/tests/it/main.rs +++ b/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; diff --git a/tests/it/scalar/binary.rs b/tests/it/scalar/binary.rs new file mode 100644 index 00000000000..5abaf7a3a7a --- /dev/null +++ b/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::::from(Some("a")); + let b = BinaryScalar::::from(None::<&str>); + assert_eq!(a, a); + assert_eq!(b, b); + assert!(a != b); + let b = BinaryScalar::::from(Some("b")); + assert!(a != b); + assert_eq!(b, b); +} + +#[test] +fn basics() { + let a = BinaryScalar::::from(Some("a")); + + assert_eq!(a.value(), b"a"); + assert_eq!(a.data_type(), &DataType::Binary); + assert!(a.is_valid()); + + let a = BinaryScalar::::from(None::<&str>); + + assert_eq!(a.data_type(), &DataType::LargeBinary); + assert!(!a.is_valid()); + + let _: &dyn std::any::Any = a.as_any(); +} diff --git a/tests/it/scalar/boolean.rs b/tests/it/scalar/boolean.rs new file mode 100644 index 00000000000..a98b72210ca --- /dev/null +++ b/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(); +} diff --git a/tests/it/scalar/list.rs b/tests/it/scalar/list.rs new file mode 100644 index 00000000000..9475a30a580 --- /dev/null +++ b/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::::new( + dt.clone(), + Some(Arc::new(BooleanArray::from_slice([true, false])) as Arc), + ); + let b = ListScalar::::new(dt.clone(), None); + assert_eq!(a, a); + assert_eq!(b, b); + assert!(a != b); + let b = ListScalar::::new( + dt, + Some(Arc::new(BooleanArray::from_slice([true, true])) as Arc), + ); + 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::::new( + dt.clone(), + Some(Arc::new(BooleanArray::from_slice([true, false])) as Arc), + ); + + 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(); +} diff --git a/tests/it/scalar/mod.rs b/tests/it/scalar/mod.rs new file mode 100644 index 00000000000..f5fe233dd40 --- /dev/null +++ b/tests/it/scalar/mod.rs @@ -0,0 +1,7 @@ +mod binary; +mod boolean; +mod list; +mod null; +mod primitive; +mod struct_; +mod utf8; diff --git a/tests/it/scalar/null.rs b/tests/it/scalar/null.rs new file mode 100644 index 00000000000..685b237b803 --- /dev/null +++ b/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(); +} diff --git a/tests/it/scalar/primitive.rs b/tests/it/scalar/primitive.rs new file mode 100644 index 00000000000..c248689f3ec --- /dev/null +++ b/tests/it/scalar/primitive.rs @@ -0,0 +1,39 @@ +use arrow2::{ + datatypes::DataType, + scalar::{PrimitiveScalar, Scalar}, +}; + +#[allow(clippy::eq_op)] +#[test] +fn equal() { + let a = PrimitiveScalar::from(Some(2i32)); + let b = PrimitiveScalar::::from(None); + assert_eq!(a, a); + assert_eq!(b, b); + assert!(a != b); + let b = PrimitiveScalar::::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::::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); + + let _: &dyn std::any::Any = a.as_any(); +} diff --git a/tests/it/scalar/struct_.rs b/tests/it/scalar/struct_.rs new file mode 100644 index 00000000000..9209afee8c9 --- /dev/null +++ b/tests/it/scalar/struct_.rs @@ -0,0 +1,45 @@ +use std::sync::Arc; + +use arrow2::{ + datatypes::{DataType, Field}, + scalar::{BooleanScalar, Scalar, StructScalar}, +}; + +#[allow(clippy::eq_op)] +#[test] +fn equal() { + let dt = DataType::Struct(vec![Field::new("a", DataType::Boolean, true)]); + let a = StructScalar::new( + dt.clone(), + Some(vec![ + Arc::new(BooleanScalar::from(Some(true))) as Arc + ]), + ); + let b = StructScalar::new(dt.clone(), None); + assert_eq!(a, a); + assert_eq!(b, b); + assert!(a != b); + let b = StructScalar::new( + dt, + Some(vec![ + Arc::new(BooleanScalar::from(Some(false))) as Arc + ]), + ); + assert!(a != b); + assert_eq!(b, b); +} + +#[test] +fn basics() { + let dt = DataType::Struct(vec![Field::new("a", DataType::Boolean, true)]); + + let values = vec![Arc::new(BooleanScalar::from(Some(true))) as Arc]; + + let a = StructScalar::new(dt.clone(), Some(values.clone())); + + assert_eq!(a.values(), &values); + assert_eq!(a.data_type(), &dt); + assert!(a.is_valid()); + + let _: &dyn std::any::Any = a.as_any(); +} diff --git a/tests/it/scalar/utf8.rs b/tests/it/scalar/utf8.rs new file mode 100644 index 00000000000..edd95c6e24b --- /dev/null +++ b/tests/it/scalar/utf8.rs @@ -0,0 +1,33 @@ +use arrow2::{ + datatypes::DataType, + scalar::{Scalar, Utf8Scalar}, +}; + +#[allow(clippy::eq_op)] +#[test] +fn equal() { + let a = Utf8Scalar::::from(Some("a")); + let b = Utf8Scalar::::from(None::<&str>); + assert_eq!(a, a); + assert_eq!(b, b); + assert!(a != b); + let b = Utf8Scalar::::from(Some("b")); + assert!(a != b); + assert_eq!(b, b); +} + +#[test] +fn basics() { + let a = Utf8Scalar::::from(Some("a")); + + assert_eq!(a.value(), "a"); + assert_eq!(a.data_type(), &DataType::Utf8); + assert!(a.is_valid()); + + let a = Utf8Scalar::::from(None::<&str>); + + assert_eq!(a.data_type(), &DataType::LargeUtf8); + assert!(!a.is_valid()); + + let _: &dyn std::any::Any = a.as_any(); +}