From 2d3acea44264b7b2711eb3dfb72e3dd43879f1ce Mon Sep 17 00:00:00 2001 From: "Jorge C. Leitao" Date: Thu, 19 Aug 2021 06:37:25 +0000 Subject: [PATCH 1/4] Improved coverage. --- src/array/growable/fixed_binary.rs | 5 ++--- tests/it/array/growable/struct_.rs | 24 +++++++++++++++++------- tests/it/main.rs | 1 + 3 files changed, 20 insertions(+), 10 deletions(-) diff --git a/src/array/growable/fixed_binary.rs b/src/array/growable/fixed_binary.rs index 945786968b8..3a4ca15e90a 100644 --- a/src/array/growable/fixed_binary.rs +++ b/src/array/growable/fixed_binary.rs @@ -69,12 +69,11 @@ impl<'a> Growable<'a> for GrowableFixedSizeBinary<'a> { let values = array.values(); self.values - .extend_from_slice(&values[start * self.size..start * self.size + len * self.size]); + .extend_from_slice(&values[start * self.size..(start + len) * self.size]); } fn extend_validity(&mut self, additional: usize) { - self.values - .extend_from_slice(&vec![0; self.size * additional]); + self.values.extend_constant(self.size * additional, 0); self.validity.extend_constant(additional, false); } 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..be8785d5afa 100644 --- a/tests/it/main.rs +++ b/tests/it/main.rs @@ -7,4 +7,5 @@ mod ffi; mod io; mod test_util; +#[cfg(feature = "compute")] mod compute; From a9387827d674a0e32ecb0754bcc07fcfb7292ce1 Mon Sep 17 00:00:00 2001 From: "Jorge C. Leitao" Date: Thu, 19 Aug 2021 07:34:06 +0000 Subject: [PATCH 2/4] Added more tests. --- src/scalar/binary.rs | 32 ---------------------- src/scalar/boolean.rs | 27 ------------------- src/scalar/list.rs | 14 +++++----- src/scalar/primitive.rs | 38 -------------------------- src/scalar/utf8.rs | 32 ---------------------- tests/it/array/boolean/mutable.rs | 19 ++++++++++--- tests/it/main.rs | 1 + 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 +++++++++++++++++++++++ 15 files changed, 272 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/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/list.rs b/src/scalar/list.rs index 4623711a5b2..3439df9fe28 100644 --- a/src/scalar/list.rs +++ b/src/scalar/list.rs @@ -9,7 +9,7 @@ use super::Scalar; /// [`Array`]. The only difference is that this has only one element. #[derive(Debug, Clone)] pub struct ListScalar { - values: Arc, + value: Arc, is_valid: bool, phantom: std::marker::PhantomData, data_type: DataType, @@ -19,7 +19,7 @@ impl PartialEq for ListScalar { fn eq(&self, other: &Self) -> bool { (self.data_type == other.data_type) && (self.is_valid == other.is_valid) - && ((!self.is_valid) | (self.values.as_ref() == other.values.as_ref())) + && ((!self.is_valid) | (self.value.as_ref() == other.value.as_ref())) } } @@ -29,9 +29,9 @@ impl ListScalar { /// * the `data_type` is not `List` or `LargeList` (depending on this scalar's offset `O`) /// * the child of the `data_type` is not equal to the `values` #[inline] - pub fn new(data_type: DataType, values: Option>) -> Self { + pub fn new(data_type: DataType, value: Option>) -> Self { let inner_data_type = ListArray::::get_child_type(&data_type); - let (is_valid, values) = match values { + let (is_valid, value) = match value { Some(values) => { assert_eq!(inner_data_type, values.data_type()); (true, values) @@ -39,15 +39,15 @@ impl ListScalar { None => (false, new_empty_array(inner_data_type.clone()).into()), }; Self { - values, + value, is_valid, phantom: std::marker::PhantomData, data_type, } } - pub fn values(&self) -> &Arc { - &self.values + pub fn value(&self) -> &Arc { + &self.value } } 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/main.rs b/tests/it/main.rs index be8785d5afa..ad9a9b97353 100644 --- a/tests/it/main.rs +++ b/tests/it/main.rs @@ -3,6 +3,7 @@ mod array; mod bitmap; mod buffer; mod ffi; +mod scalar; mod io; mod test_util; 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..523b75b3bc8 --- /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.value().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(); +} From beaf307c4804693d8580a354364acf3313b35b44 Mon Sep 17 00:00:00 2001 From: "Jorge C. Leitao" Date: Thu, 19 Aug 2021 07:48:20 +0000 Subject: [PATCH 3/4] Reverted. --- src/array/growable/fixed_binary.rs | 5 +++-- src/scalar/list.rs | 14 +++++++------- tests/it/scalar/list.rs | 2 +- 3 files changed, 11 insertions(+), 10 deletions(-) diff --git a/src/array/growable/fixed_binary.rs b/src/array/growable/fixed_binary.rs index 3a4ca15e90a..945786968b8 100644 --- a/src/array/growable/fixed_binary.rs +++ b/src/array/growable/fixed_binary.rs @@ -69,11 +69,12 @@ impl<'a> Growable<'a> for GrowableFixedSizeBinary<'a> { let values = array.values(); self.values - .extend_from_slice(&values[start * self.size..(start + len) * self.size]); + .extend_from_slice(&values[start * self.size..start * self.size + len * self.size]); } fn extend_validity(&mut self, additional: usize) { - self.values.extend_constant(self.size * additional, 0); + self.values + .extend_from_slice(&vec![0; self.size * additional]); self.validity.extend_constant(additional, false); } diff --git a/src/scalar/list.rs b/src/scalar/list.rs index 3439df9fe28..4623711a5b2 100644 --- a/src/scalar/list.rs +++ b/src/scalar/list.rs @@ -9,7 +9,7 @@ use super::Scalar; /// [`Array`]. The only difference is that this has only one element. #[derive(Debug, Clone)] pub struct ListScalar { - value: Arc, + values: Arc, is_valid: bool, phantom: std::marker::PhantomData, data_type: DataType, @@ -19,7 +19,7 @@ impl PartialEq for ListScalar { fn eq(&self, other: &Self) -> bool { (self.data_type == other.data_type) && (self.is_valid == other.is_valid) - && ((!self.is_valid) | (self.value.as_ref() == other.value.as_ref())) + && ((!self.is_valid) | (self.values.as_ref() == other.values.as_ref())) } } @@ -29,9 +29,9 @@ impl ListScalar { /// * the `data_type` is not `List` or `LargeList` (depending on this scalar's offset `O`) /// * the child of the `data_type` is not equal to the `values` #[inline] - pub fn new(data_type: DataType, value: Option>) -> Self { + pub fn new(data_type: DataType, values: Option>) -> Self { let inner_data_type = ListArray::::get_child_type(&data_type); - let (is_valid, value) = match value { + let (is_valid, values) = match values { Some(values) => { assert_eq!(inner_data_type, values.data_type()); (true, values) @@ -39,15 +39,15 @@ impl ListScalar { None => (false, new_empty_array(inner_data_type.clone()).into()), }; Self { - value, + values, is_valid, phantom: std::marker::PhantomData, data_type, } } - pub fn value(&self) -> &Arc { - &self.value + pub fn values(&self) -> &Arc { + &self.values } } diff --git a/tests/it/scalar/list.rs b/tests/it/scalar/list.rs index 523b75b3bc8..9475a30a580 100644 --- a/tests/it/scalar/list.rs +++ b/tests/it/scalar/list.rs @@ -34,7 +34,7 @@ fn basics() { Some(Arc::new(BooleanArray::from_slice([true, false])) as Arc), ); - assert_eq!(BooleanArray::from_slice([true, false]), a.value().as_ref()); + assert_eq!(BooleanArray::from_slice([true, false]), a.values().as_ref()); assert_eq!(a.data_type(), &dt); assert!(a.is_valid()); From 273f6f6660aac8054af008999a41e8b7541657ed Mon Sep 17 00:00:00 2001 From: "Jorge C. Leitao" Date: Thu, 19 Aug 2021 08:15:36 +0000 Subject: [PATCH 4/4] Added coverage badge. --- README.md | 1 + 1 file changed, 1 insertion(+) 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/)