diff --git a/src/compute/comparison/primitive.rs b/src/compute/comparison/primitive.rs index 7a400f5f850..05e5254f44a 100644 --- a/src/compute/comparison/primitive.rs +++ b/src/compute/comparison/primitive.rs @@ -331,8 +331,8 @@ mod tests { #[test] fn test_primitive_array_eq_with_slice() { - let a = Int64Array::from_slice(&[6, 7, 8, 8, 10]); - let b = Int64Array::from_slice(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); + let a = Int64Array::from_slice([6, 7, 8, 8, 10]); + let b = Int64Array::from_slice([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); let c = b.slice(5, 5); let d = eq(&c, &a); assert_eq!( diff --git a/src/compute/sort/primitive/indices.rs b/src/compute/sort/primitive/indices.rs index a3ff6969b5d..ec12e16b0c5 100644 --- a/src/compute/sort/primitive/indices.rs +++ b/src/compute/sort/primitive/indices.rs @@ -48,7 +48,7 @@ mod tests { T: NativeType + std::cmp::Ord, { let input = PrimitiveArray::::from(data).to(data_type); - let expected = Int32Array::from_slice(&expected_data); + let expected = Int32Array::from_slice(expected_data); let output = indices_sorted_unstable_by::(&input, ord::total_cmp, &options, limit); assert_eq!(output, expected) diff --git a/src/io/json/read/deserialize.rs b/src/io/json/read/deserialize.rs index 84ad5bea984..ea5d25a0a5d 100644 --- a/src/io/json/read/deserialize.rs +++ b/src/io/json/read/deserialize.rs @@ -42,7 +42,7 @@ fn build_extract(data_type: &DataType) -> Extract { Box::new(move |value| { let integer = match value { Value::Number(number) => Some(deserialize_int_single::(*number)), - Value::Bool(number) => Some(if *number { 1i64 } else { 0i64 }), + Value::Bool(number) => Some(i64::from(*number)), _ => None, }; integer.map(|integer| { @@ -208,9 +208,9 @@ fn deserialize_utf8_into<'a, O: Offset, A: Borrow>>( Value::Number(number) => match number { Number::Integer(number, exponent) | Number::Float(number, exponent) => { scratch.clear(); - scratch.extend_from_slice(*number); + scratch.extend_from_slice(number); scratch.push(b'e'); - scratch.extend_from_slice(*exponent); + scratch.extend_from_slice(exponent); } }, Value::Bool(v) => target.push(Some(if *v { "true" } else { "false" })), diff --git a/src/io/parquet/write/nested/rep.rs b/src/io/parquet/write/nested/rep.rs index 744fab39ecc..68c7609acae 100644 --- a/src/io/parquet/write/nested/rep.rs +++ b/src/io/parquet/write/nested/rep.rs @@ -35,7 +35,7 @@ pub fn num_values(nested: &[Nested]) -> usize { .sum::() } else { lengths - .map(|length| if length == 0 { 1 } else { 0 }) + .map(|length| usize::from(length == 0)) .sum::() } }) diff --git a/src/io/parquet/write/pages.rs b/src/io/parquet/write/pages.rs index 0e8dcf3d69d..5e0c80112da 100644 --- a/src/io/parquet/write/pages.rs +++ b/src/io/parquet/write/pages.rs @@ -234,8 +234,8 @@ mod tests { #[test] fn test_struct() { - let boolean = BooleanArray::from_slice(&[false, false, true, true]).boxed(); - let int = Int32Array::from_slice(&[42, 28, 19, 31]).boxed(); + let boolean = BooleanArray::from_slice([false, false, true, true]).boxed(); + let int = Int32Array::from_slice([42, 28, 19, 31]).boxed(); let fields = vec![ Field::new("b", DataType::Boolean, false), @@ -298,8 +298,8 @@ mod tests { #[test] fn test_struct_struct() { - let boolean = BooleanArray::from_slice(&[false, false, true, true]).boxed(); - let int = Int32Array::from_slice(&[42, 28, 19, 31]).boxed(); + let boolean = BooleanArray::from_slice([false, false, true, true]).boxed(); + let int = Int32Array::from_slice([42, 28, 19, 31]).boxed(); let fields = vec![ Field::new("b", DataType::Boolean, false), @@ -401,8 +401,8 @@ mod tests { #[test] fn test_list_struct() { - let boolean = BooleanArray::from_slice(&[false, false, true, true]).boxed(); - let int = Int32Array::from_slice(&[42, 28, 19, 31]).boxed(); + let boolean = BooleanArray::from_slice([false, false, true, true]).boxed(); + let int = Int32Array::from_slice([42, 28, 19, 31]).boxed(); let fields = vec![ Field::new("b", DataType::Boolean, false), diff --git a/tests/it/array/binary/mod.rs b/tests/it/array/binary/mod.rs index d26cf4ad3f4..03cee86be1b 100644 --- a/tests/it/array/binary/mod.rs +++ b/tests/it/array/binary/mod.rs @@ -23,7 +23,7 @@ fn basics() { assert_eq!(array.offsets().as_slice(), &[0, 5, 5, 11]); assert_eq!( array.validity(), - Some(&Bitmap::from_u8_slice(&[0b00000101], 3)) + Some(&Bitmap::from_u8_slice([0b00000101], 3)) ); assert!(array.is_valid(0)); assert!(!array.is_valid(1)); @@ -55,7 +55,7 @@ fn empty() { #[test] fn from() { - let array = BinaryArray::::from(&[Some(b"hello".as_ref()), Some(b" ".as_ref()), None]); + let array = BinaryArray::::from([Some(b"hello".as_ref()), Some(b" ".as_ref()), None]); let a = array.validity().unwrap(); assert_eq!(a, &Bitmap::from([true, true, false])); @@ -87,7 +87,7 @@ fn from_iter() { #[test] fn with_validity() { - let array = BinaryArray::::from(&[Some(b"hello".as_ref()), Some(b" ".as_ref()), None]); + let array = BinaryArray::::from([Some(b"hello".as_ref()), Some(b" ".as_ref()), None]); let array = array.with_validity(None); @@ -150,7 +150,7 @@ fn value_unchecked_with_wrong_offsets_panics() { #[test] fn debug() { - let array = BinaryArray::::from(&[Some([1, 2].as_ref()), Some(&[]), None]); + let array = BinaryArray::::from([Some([1, 2].as_ref()), Some(&[]), None]); assert_eq!(format!("{:?}", array), "BinaryArray[[1, 2], [], None]"); } @@ -197,7 +197,7 @@ fn into_mut_4() { #[test] fn rev_iter() { - let array = BinaryArray::::from(&[Some("hello".as_bytes()), Some(" ".as_bytes()), None]); + let array = BinaryArray::::from([Some("hello".as_bytes()), Some(" ".as_bytes()), None]); assert_eq!( array.into_iter().rev().collect::>(), @@ -207,7 +207,7 @@ fn rev_iter() { #[test] fn iter_nth() { - let array = BinaryArray::::from(&[Some("hello"), Some(" "), None]); + let array = BinaryArray::::from([Some("hello"), Some(" "), None]); assert_eq!(array.iter().nth(1), Some(Some(" ".as_bytes()))); assert_eq!(array.iter().nth(10), None); diff --git a/tests/it/array/binary/mutable.rs b/tests/it/array/binary/mutable.rs index 74addaac939..8968d1cb15c 100644 --- a/tests/it/array/binary/mutable.rs +++ b/tests/it/array/binary/mutable.rs @@ -131,7 +131,7 @@ fn extend_trusted_len_values() { assert_eq!(array.offsets().as_slice(), &[0, 5, 11, 16, 16, 22]); assert_eq!( array.validity(), - Some(&Bitmap::from_u8_slice(&[0b00010111], 5)) + Some(&Bitmap::from_u8_slice([0b00010111], 5)) ); } @@ -148,13 +148,13 @@ fn extend_trusted_len() { assert_eq!(array.offsets().as_slice(), &[0, 5, 11, 11, 16]); assert_eq!( array.validity(), - Some(&Bitmap::from_u8_slice(&[0b00001011], 4)) + Some(&Bitmap::from_u8_slice([0b00001011], 4)) ); } #[test] fn extend_from_self() { - let mut a = MutableBinaryArray::::from(&[Some(b"aa"), None]); + let mut a = MutableBinaryArray::::from([Some(b"aa"), None]); a.try_extend_from_self(&a.clone()).unwrap(); diff --git a/tests/it/array/binary/to_mutable.rs b/tests/it/array/binary/to_mutable.rs index e828244abb5..b553d85d050 100644 --- a/tests/it/array/binary/to_mutable.rs +++ b/tests/it/array/binary/to_mutable.rs @@ -2,7 +2,7 @@ use arrow2::{array::BinaryArray, bitmap::Bitmap, buffer::Buffer, datatypes::Data #[test] fn not_shared() { - let array = BinaryArray::::from(&[Some("hello"), Some(" "), None]); + let array = BinaryArray::::from([Some("hello"), Some(" "), None]); assert!(array.into_mut().is_right()); } @@ -62,6 +62,6 @@ fn shared_offsets() { #[test] #[allow(clippy::redundant_clone)] fn shared_all() { - let array = BinaryArray::::from(&[Some("hello"), Some(" "), None]); + let array = BinaryArray::::from([Some("hello"), Some(" "), None]); assert!(array.clone().into_mut().is_left()) } diff --git a/tests/it/array/boolean/mod.rs b/tests/it/array/boolean/mod.rs index 63c1efd7869..a38b59a07cb 100644 --- a/tests/it/array/boolean/mod.rs +++ b/tests/it/array/boolean/mod.rs @@ -18,10 +18,10 @@ fn basics() { assert!(!array.value(1)); assert!(!array.value(2)); assert!(!unsafe { array.value_unchecked(2) }); - assert_eq!(array.values(), &Bitmap::from_u8_slice(&[0b00000001], 3)); + assert_eq!(array.values(), &Bitmap::from_u8_slice([0b00000001], 3)); assert_eq!( array.validity(), - Some(&Bitmap::from_u8_slice(&[0b00000101], 3)) + Some(&Bitmap::from_u8_slice([0b00000101], 3)) ); assert!(array.is_valid(0)); assert!(!array.is_valid(1)); diff --git a/tests/it/array/dictionary/mod.rs b/tests/it/array/dictionary/mod.rs index f436e2685db..84c16b49cde 100644 --- a/tests/it/array/dictionary/mod.rs +++ b/tests/it/array/dictionary/mod.rs @@ -4,7 +4,7 @@ use arrow2::{array::*, datatypes::DataType}; #[test] fn try_new_ok() { - let values = Utf8Array::::from_slice(&["a", "aa"]); + let values = Utf8Array::::from_slice(["a", "aa"]); let data_type = DataType::Dictionary(i32::KEY_TYPE, Box::new(values.data_type().clone()), false); let array = DictionaryArray::try_new( @@ -16,7 +16,7 @@ fn try_new_ok() { assert_eq!(array.keys(), &PrimitiveArray::from_vec(vec![1i32, 0])); assert_eq!( - &Utf8Array::::from_slice(&["a", "aa"]) as &dyn Array, + &Utf8Array::::from_slice(["a", "aa"]) as &dyn Array, array.values().as_ref(), ); assert!(!array.is_ordered()); @@ -26,7 +26,7 @@ fn try_new_ok() { #[test] fn try_new_incorrect_key() { - let values = Utf8Array::::from_slice(&["a", "aa"]); + let values = Utf8Array::::from_slice(["a", "aa"]); let data_type = DataType::Dictionary(i16::KEY_TYPE, Box::new(values.data_type().clone()), false); @@ -42,7 +42,7 @@ fn try_new_incorrect_key() { #[test] fn try_new_incorrect_dt() { - let values = Utf8Array::::from_slice(&["a", "aa"]); + let values = Utf8Array::::from_slice(["a", "aa"]); let data_type = DataType::Int32; let r = DictionaryArray::try_new( @@ -57,7 +57,7 @@ fn try_new_incorrect_dt() { #[test] fn try_new_incorrect_values_dt() { - let values = Utf8Array::::from_slice(&["a", "aa"]); + let values = Utf8Array::::from_slice(["a", "aa"]); let data_type = DataType::Dictionary(i32::KEY_TYPE, Box::new(DataType::LargeUtf8), false); let r = DictionaryArray::try_new( @@ -72,7 +72,7 @@ fn try_new_incorrect_values_dt() { #[test] fn try_new_out_of_bounds() { - let values = Utf8Array::::from_slice(&["a", "aa"]); + let values = Utf8Array::::from_slice(["a", "aa"]); let r = DictionaryArray::try_from_keys(PrimitiveArray::from_vec(vec![2, 0]), values.boxed()) .is_err(); @@ -82,7 +82,7 @@ fn try_new_out_of_bounds() { #[test] fn try_new_out_of_bounds_neg() { - let values = Utf8Array::::from_slice(&["a", "aa"]); + let values = Utf8Array::::from_slice(["a", "aa"]); let r = DictionaryArray::try_from_keys(PrimitiveArray::from_vec(vec![-1, 0]), values.boxed()) .is_err(); @@ -108,7 +108,7 @@ fn new_empty() { #[test] fn with_validity() { - let values = Utf8Array::::from_slice(&["a", "aa"]); + let values = Utf8Array::::from_slice(["a", "aa"]); let array = DictionaryArray::try_from_keys(PrimitiveArray::from_vec(vec![1, 0]), values.boxed()) .unwrap(); @@ -120,7 +120,7 @@ fn with_validity() { #[test] fn rev_iter() { - let values = Utf8Array::::from_slice(&["a", "aa"]); + let values = Utf8Array::::from_slice(["a", "aa"]); let array = DictionaryArray::try_from_keys(PrimitiveArray::from_vec(vec![1, 0]), values.boxed()) .unwrap(); @@ -132,7 +132,7 @@ fn rev_iter() { #[test] fn iter_values() { - let values = Utf8Array::::from_slice(&["a", "aa"]); + let values = Utf8Array::::from_slice(["a", "aa"]); let array = DictionaryArray::try_from_keys(PrimitiveArray::from_vec(vec![1, 0]), values.boxed()) .unwrap(); @@ -144,7 +144,7 @@ fn iter_values() { #[test] fn keys_values_iter() { - let values = Utf8Array::::from_slice(&["a", "aa"]); + let values = Utf8Array::::from_slice(["a", "aa"]); let array = DictionaryArray::try_from_keys(PrimitiveArray::from_vec(vec![1, 0]), values.boxed()) .unwrap(); diff --git a/tests/it/array/dictionary/mutable.rs b/tests/it/array/dictionary/mutable.rs index 24b40f0a6f3..b6103dcccfc 100644 --- a/tests/it/array/dictionary/mutable.rs +++ b/tests/it/array/dictionary/mutable.rs @@ -55,7 +55,7 @@ fn push_utf8() { MutableUtf8Array::::from_iter_values(["A", "B", "C"].into_iter()).values() ); - let mut expected_keys = MutablePrimitiveArray::::from_slice(&[0, 1]); + let mut expected_keys = MutablePrimitiveArray::::from_slice([0, 1]); expected_keys.push(None); expected_keys.push(Some(2)); expected_keys.push(Some(0)); diff --git a/tests/it/array/equal/fixed_size_list.rs b/tests/it/array/equal/fixed_size_list.rs index 2ef0280790c..14591ce5cd0 100644 --- a/tests/it/array/equal/fixed_size_list.rs +++ b/tests/it/array/equal/fixed_size_list.rs @@ -22,11 +22,11 @@ fn create_fixed_size_list_array, T: AsRef<[Option]>>( #[test] fn test_fixed_size_list_equal() { - let a = create_fixed_size_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 6])]); - let b = create_fixed_size_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 6])]); + let a = create_fixed_size_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 6])]); + let b = create_fixed_size_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 6])]); test_equal(&a, &b, true); - let b = create_fixed_size_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 7])]); + let b = create_fixed_size_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 7])]); test_equal(&a, &b, false); } @@ -34,7 +34,7 @@ fn test_fixed_size_list_equal() { #[test] fn test_fixed_list_null() { let a = - create_fixed_size_list_array(&[Some(&[1, 2, 3]), None, None, Some(&[4, 5, 6]), None, None]); + create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[4, 5, 6]), None, None]); /* let b = create_fixed_size_list_array(&[ Some(&[1, 2, 3]), @@ -58,7 +58,7 @@ fn test_fixed_list_null() { */ let b = - create_fixed_size_list_array(&[Some(&[1, 2, 3]), None, None, Some(&[3, 6, 9]), None, None]); + create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[3, 6, 9]), None, None]); test_equal(&a, &b, false); } @@ -66,9 +66,9 @@ fn test_fixed_list_null() { fn test_fixed_list_offsets() { // Test the case where offset != 0 let a = - create_fixed_size_list_array(&[Some(&[1, 2, 3]), None, None, Some(&[4, 5, 6]), None, None]); + create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[4, 5, 6]), None, None]); let b = - create_fixed_size_list_array(&[Some(&[1, 2, 3]), None, None, Some(&[3, 6, 9]), None, None]); + create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[3, 6, 9]), None, None]); let a_slice = a.slice(0, 3); let b_slice = b.slice(0, 3); diff --git a/tests/it/array/equal/list.rs b/tests/it/array/equal/list.rs index 343b7514e77..17427946383 100644 --- a/tests/it/array/equal/list.rs +++ b/tests/it/array/equal/list.rs @@ -17,22 +17,22 @@ fn create_list_array, T: AsRef<[Option]>>(data: T) -> ListArr #[test] fn test_list_equal() { - let a = create_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 6])]); - let b = create_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 6])]); + let a = create_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 6])]); + let b = create_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 6])]); test_equal(&a, &b, true); - let b = create_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 7])]); + let b = create_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 7])]); test_equal(&a, &b, false); } // Test the case where null_count > 0 #[test] fn test_list_null() { - let a = create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]); - let b = create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]); + let a = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]); + let b = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]); test_equal(&a, &b, true); - let b = create_list_array(&[ + let b = create_list_array([ Some(&[1, 2]), None, Some(&[5, 6]), @@ -42,15 +42,15 @@ fn test_list_null() { ]); test_equal(&a, &b, false); - let b = create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 5]), None, None]); + let b = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 5]), None, None]); test_equal(&a, &b, false); } // Test the case where offset != 0 #[test] fn test_list_offsets() { - let a = create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]); - let b = create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 5]), None, None]); + let a = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]); + let b = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 5]), None, None]); let a_slice = a.slice(0, 3); let b_slice = b.slice(0, 3); diff --git a/tests/it/array/growable/binary.rs b/tests/it/array/growable/binary.rs index 4451e141c9a..3ca9d80deb2 100644 --- a/tests/it/array/growable/binary.rs +++ b/tests/it/array/growable/binary.rs @@ -5,7 +5,7 @@ use arrow2::array::{ #[test] fn no_offsets() { - let array = BinaryArray::::from(&[Some("a"), Some("bc"), None, Some("defh")]); + let array = BinaryArray::::from([Some("a"), Some("bc"), None, Some("defh")]); let mut a = GrowableBinary::new(vec![&array], false, 0); @@ -13,7 +13,7 @@ fn no_offsets() { let result: BinaryArray = a.into(); - let expected = BinaryArray::::from(&[Some("bc"), None]); + let expected = BinaryArray::::from([Some("bc"), None]); assert_eq!(result, expected); } @@ -21,7 +21,7 @@ fn no_offsets() { /// with an offset and nulls #[test] fn with_offsets() { - let array = BinaryArray::::from(&[Some("a"), Some("bc"), None, Some("defh")]); + let array = BinaryArray::::from([Some("a"), Some("bc"), None, Some("defh")]); let array = array.slice(1, 3); let mut a = GrowableBinary::new(vec![&array], false, 0); @@ -30,13 +30,13 @@ fn with_offsets() { let result: BinaryArray = a.into(); - let expected = BinaryArray::::from(&[Some("bc"), None, Some("defh")]); + let expected = BinaryArray::::from([Some("bc"), None, Some("defh")]); assert_eq!(result, expected); } #[test] fn test_string_offsets() { - let array = BinaryArray::::from(&[Some("a"), Some("bc"), None, Some("defh")]); + let array = BinaryArray::::from([Some("a"), Some("bc"), None, Some("defh")]); let array = array.slice(1, 3); let mut a = GrowableBinary::new(vec![&array], false, 0); @@ -45,14 +45,14 @@ fn test_string_offsets() { let result: BinaryArray = a.into(); - let expected = BinaryArray::::from(&[Some("bc"), None, Some("defh")]); + let expected = BinaryArray::::from([Some("bc"), None, Some("defh")]); assert_eq!(result, expected); } #[test] fn test_multiple_with_validity() { - let array1 = BinaryArray::::from_slice(&[b"hello", b"world"]); - let array2 = BinaryArray::::from(&[Some("1"), None]); + let array1 = BinaryArray::::from_slice([b"hello", b"world"]); + let array2 = BinaryArray::::from([Some("1"), None]); let mut a = GrowableBinary::new(vec![&array1, &array2], false, 5); @@ -61,13 +61,13 @@ fn test_multiple_with_validity() { let result: BinaryArray = a.into(); - let expected = BinaryArray::::from(&[Some("hello"), Some("world"), Some("1"), None]); + let expected = BinaryArray::::from([Some("hello"), Some("world"), Some("1"), None]); assert_eq!(result, expected); } #[test] fn test_string_null_offset_validity() { - let array = BinaryArray::::from(&[Some("a"), Some("bc"), None, Some("defh")]); + let array = BinaryArray::::from([Some("a"), Some("bc"), None, Some("defh")]); let array = array.slice(1, 3); let mut a = GrowableBinary::new(vec![&array], true, 0); @@ -77,6 +77,6 @@ fn test_string_null_offset_validity() { let result: BinaryArray = a.into(); - let expected = BinaryArray::::from(&[None, Some("defh"), None]); + let expected = BinaryArray::::from([None, Some("defh"), None]); assert_eq!(result, expected); } diff --git a/tests/it/array/growable/dictionary.rs b/tests/it/array/growable/dictionary.rs index 5d0eeef226d..6d7a34dfffd 100644 --- a/tests/it/array/growable/dictionary.rs +++ b/tests/it/array/growable/dictionary.rs @@ -48,7 +48,7 @@ fn test_multi() -> Result<()> { original_data1.extend(original_data2.iter().cloned()); let expected = DictionaryArray::try_from_keys( PrimitiveArray::from(&[Some(1), None, Some(3), None]), - Utf8Array::::from_slice(&["a", "b", "c", "b", "a"]).boxed(), + Utf8Array::::from_slice(["a", "b", "c", "b", "a"]).boxed(), ) .unwrap(); diff --git a/tests/it/array/growable/struct_.rs b/tests/it/array/growable/struct_.rs index b10ad5a4717..55b5f4b0979 100644 --- a/tests/it/array/growable/struct_.rs +++ b/tests/it/array/growable/struct_.rs @@ -6,7 +6,7 @@ use arrow2::bitmap::Bitmap; use arrow2::datatypes::{DataType, Field}; fn some_values() -> (DataType, Vec>) { - let strings: Box = Box::new(Utf8Array::::from(&[ + let strings: Box = Box::new(Utf8Array::::from([ Some("a"), Some("aa"), None, @@ -73,7 +73,7 @@ fn nulls() { let array = StructArray::from_data( fields.clone(), values.clone(), - Some(Bitmap::from_u8_slice(&[0b00000010], 5)), + Some(Bitmap::from_u8_slice([0b00000010], 5)), ); let mut a = GrowableStruct::new(vec![&array], false, 0); @@ -84,7 +84,7 @@ fn nulls() { let expected = StructArray::from_data( fields, vec![values[0].slice(1, 2), values[1].slice(1, 2)], - Some(Bitmap::from_u8_slice(&[0b00000010], 5).slice(1, 2)), + Some(Bitmap::from_u8_slice([0b00000010], 5).slice(1, 2)), ); assert_eq!(result, expected) @@ -103,7 +103,7 @@ fn many() { mutable.extend_validity(1); let result = mutable.as_box(); - let expected_string: Box = Box::new(Utf8Array::::from(&[ + let expected_string: Box = Box::new(Utf8Array::::from([ Some("aa"), None, Some("a"), diff --git a/tests/it/array/growable/union.rs b/tests/it/array/growable/union.rs index c8f99a0f82d..d4581f4685c 100644 --- a/tests/it/array/growable/union.rs +++ b/tests/it/array/growable/union.rs @@ -17,7 +17,7 @@ fn sparse() -> Result<()> { let types = vec![0, 0, 1].into(); let fields = vec![ Int32Array::from(&[Some(1), None, Some(2)]).boxed(), - Utf8Array::::from(&[Some("a"), Some("b"), Some("c")]).boxed(), + Utf8Array::::from([Some("a"), Some("b"), Some("c")]).boxed(), ]; let array = UnionArray::from_data(data_type, types, fields, None); @@ -47,7 +47,7 @@ fn dense() -> Result<()> { let types = vec![0, 0, 1].into(); let fields = vec![ Int32Array::from(&[Some(1), None, Some(2)]).boxed(), - Utf8Array::::from(&[Some("c")]).boxed(), + Utf8Array::::from([Some("c")]).boxed(), ]; let offsets = Some(vec![0, 1, 0].into()); diff --git a/tests/it/array/growable/utf8.rs b/tests/it/array/growable/utf8.rs index feb4465a6f8..5e4308b5778 100644 --- a/tests/it/array/growable/utf8.rs +++ b/tests/it/array/growable/utf8.rs @@ -6,7 +6,7 @@ use arrow2::array::{ /// tests extending from a variable-sized (strings and binary) array w/ offset with nulls #[test] fn validity() { - let array = Utf8Array::::from(&[Some("a"), Some("bc"), None, Some("defh")]); + let array = Utf8Array::::from([Some("a"), Some("bc"), None, Some("defh")]); let mut a = GrowableUtf8::new(vec![&array], false, 0); @@ -14,7 +14,7 @@ fn validity() { let result: Utf8Array = a.into(); - let expected = Utf8Array::::from(&[Some("bc"), None]); + let expected = Utf8Array::::from([Some("bc"), None]); assert_eq!(result, expected); } @@ -22,7 +22,7 @@ fn validity() { /// with an offset and nulls #[test] fn offsets() { - let array = Utf8Array::::from(&[Some("a"), Some("bc"), None, Some("defh")]); + let array = Utf8Array::::from([Some("a"), Some("bc"), None, Some("defh")]); let array = array.slice(1, 3); let mut a = GrowableUtf8::new(vec![&array], false, 0); @@ -31,13 +31,13 @@ fn offsets() { let result: Utf8Array = a.into(); - let expected = Utf8Array::::from(&[Some("bc"), None, Some("defh")]); + let expected = Utf8Array::::from([Some("bc"), None, Some("defh")]); assert_eq!(result, expected); } #[test] fn offsets2() { - let array = Utf8Array::::from(&[Some("a"), Some("bc"), None, Some("defh")]); + let array = Utf8Array::::from([Some("a"), Some("bc"), None, Some("defh")]); let array = array.slice(1, 3); let mut a = GrowableUtf8::new(vec![&array], false, 0); @@ -46,14 +46,14 @@ fn offsets2() { let result: Utf8Array = a.into(); - let expected = Utf8Array::::from(&[Some("bc"), None, Some("defh")]); + let expected = Utf8Array::::from([Some("bc"), None, Some("defh")]); assert_eq!(result, expected); } #[test] fn multiple_with_validity() { - let array1 = Utf8Array::::from_slice(&["hello", "world"]); - let array2 = Utf8Array::::from(&[Some("1"), None]); + let array1 = Utf8Array::::from_slice(["hello", "world"]); + let array2 = Utf8Array::::from([Some("1"), None]); let mut a = GrowableUtf8::new(vec![&array1, &array2], false, 5); @@ -62,13 +62,13 @@ fn multiple_with_validity() { let result: Utf8Array = a.into(); - let expected = Utf8Array::::from(&[Some("hello"), Some("world"), Some("1"), None]); + let expected = Utf8Array::::from([Some("hello"), Some("world"), Some("1"), None]); assert_eq!(result, expected); } #[test] fn null_offset_validity() { - let array = Utf8Array::::from(&[Some("a"), Some("bc"), None, Some("defh")]); + let array = Utf8Array::::from([Some("a"), Some("bc"), None, Some("defh")]); let array = array.slice(1, 3); let mut a = GrowableUtf8::new(vec![&array], true, 0); @@ -78,6 +78,6 @@ fn null_offset_validity() { let result: Utf8Array = a.into(); - let expected = Utf8Array::::from(&[None, Some("defh"), None]); + let expected = Utf8Array::::from([None, Some("defh"), None]); assert_eq!(result, expected); } diff --git a/tests/it/array/mod.rs b/tests/it/array/mod.rs index 8b400901d70..9df7c53d02e 100644 --- a/tests/it/array/mod.rs +++ b/tests/it/array/mod.rs @@ -90,7 +90,7 @@ fn test_clone() { #[test] fn test_with_validity() { - let arr = PrimitiveArray::from_slice(&[1i32, 2, 3]); + let arr = PrimitiveArray::from_slice([1i32, 2, 3]); let validity = Bitmap::from(&[true, false, true]); let arr = arr.with_validity(Some(validity)); let arr_ref = arr.as_any().downcast_ref::>().unwrap(); diff --git a/tests/it/array/ord.rs b/tests/it/array/ord.rs index 9f5a07ed83b..3ce249af451 100644 --- a/tests/it/array/ord.rs +++ b/tests/it/array/ord.rs @@ -7,7 +7,7 @@ use arrow2::error::Result; #[test] fn i32() -> Result<()> { - let array = Int32Array::from_slice(&[1, 2]); + let array = Int32Array::from_slice([1, 2]); let cmp = build_compare(&array, &array)?; @@ -17,8 +17,8 @@ fn i32() -> Result<()> { #[test] fn i32_i32() -> Result<()> { - let array1 = Int32Array::from_slice(&[1]); - let array2 = Int32Array::from_slice(&[2]); + let array1 = Int32Array::from_slice([1]); + let array2 = Int32Array::from_slice([2]); let cmp = build_compare(&array1, &array2)?; @@ -28,7 +28,7 @@ fn i32_i32() -> Result<()> { #[test] fn f32() -> Result<()> { - let array = &Float32Array::from_slice(&[1.0, 2.0]); + let array = &Float32Array::from_slice([1.0, 2.0]); let cmp = build_compare(array, array)?; @@ -38,7 +38,7 @@ fn f32() -> Result<()> { #[test] fn f64() -> Result<()> { - let array = Float64Array::from_slice(&[1.0, 2.0]); + let array = Float64Array::from_slice([1.0, 2.0]); let cmp = build_compare(&array, &array)?; @@ -48,7 +48,7 @@ fn f64() -> Result<()> { #[test] fn f64_nan() -> Result<()> { - let array = Float64Array::from_slice(&[1.0, f64::NAN]); + let array = Float64Array::from_slice([1.0, f64::NAN]); let cmp = build_compare(&array, &array)?; @@ -58,7 +58,7 @@ fn f64_nan() -> Result<()> { #[test] fn f64_zeros() -> Result<()> { - let array = Float64Array::from_slice(&[-0.0, 0.0]); + let array = Float64Array::from_slice([-0.0, 0.0]); let cmp = build_compare(&array, &array)?; @@ -70,7 +70,7 @@ fn f64_zeros() -> Result<()> { #[test] fn decimal() -> Result<()> { - let array = Int128Array::from_slice(&[1, 2]).to(DataType::Decimal(38, 0)); + let array = Int128Array::from_slice([1, 2]).to(DataType::Decimal(38, 0)); let cmp = build_compare(&array, &array)?; diff --git a/tests/it/array/primitive/mod.rs b/tests/it/array/primitive/mod.rs index 5189d4e3275..270a141742c 100644 --- a/tests/it/array/primitive/mod.rs +++ b/tests/it/array/primitive/mod.rs @@ -18,7 +18,7 @@ fn basics() { assert_eq!(array.values().as_slice(), &[1, 0, 10]); assert_eq!( array.validity(), - Some(&Bitmap::from_u8_slice(&[0b00000101], 3)) + Some(&Bitmap::from_u8_slice([0b00000101], 3)) ); assert!(array.is_valid(0)); assert!(!array.is_valid(1)); @@ -79,7 +79,7 @@ fn months_days_ns_from_slice() { months_days_ns::new(2, 3, 3), ]; - let array = MonthsDaysNsArray::from_slice(&data); + let array = MonthsDaysNsArray::from_slice(data); let a = array.values().as_slice(); assert_eq!(a, data.as_ref()); diff --git a/tests/it/array/primitive/mutable.rs b/tests/it/array/primitive/mutable.rs index 69c7e47dafd..46f9c190254 100644 --- a/tests/it/array/primitive/mutable.rs +++ b/tests/it/array/primitive/mutable.rs @@ -138,19 +138,19 @@ fn from_iter() { #[test] fn natural_arc() { - let a = MutablePrimitiveArray::::from_slice(&[0, 1]).into_arc(); + let a = MutablePrimitiveArray::::from_slice([0, 1]).into_arc(); assert_eq!(a.len(), 2); } #[test] fn as_arc() { - let a = MutablePrimitiveArray::::from_slice(&[0, 1]).as_arc(); + let a = MutablePrimitiveArray::::from_slice([0, 1]).as_arc(); assert_eq!(a.len(), 2); } #[test] fn as_box() { - let a = MutablePrimitiveArray::::from_slice(&[0, 1]).as_box(); + let a = MutablePrimitiveArray::::from_slice([0, 1]).as_box(); assert_eq!(a.len(), 2); } diff --git a/tests/it/array/struct_/iterator.rs b/tests/it/array/struct_/iterator.rs index 03c1368a199..4c1638390c2 100644 --- a/tests/it/array/struct_/iterator.rs +++ b/tests/it/array/struct_/iterator.rs @@ -4,8 +4,8 @@ use arrow2::scalar::new_scalar; #[test] fn test_simple_iter() { - let boolean = BooleanArray::from_slice(&[false, false, true, true]).boxed(); - let int = Int32Array::from_slice(&[42, 28, 19, 31]).boxed(); + let boolean = BooleanArray::from_slice([false, false, true, true]).boxed(); + let int = Int32Array::from_slice([42, 28, 19, 31]).boxed(); let fields = vec![ Field::new("b", DataType::Boolean, false), diff --git a/tests/it/array/struct_/mod.rs b/tests/it/array/struct_/mod.rs index 8869c215e5f..5e8495ca3c7 100644 --- a/tests/it/array/struct_/mod.rs +++ b/tests/it/array/struct_/mod.rs @@ -7,8 +7,8 @@ use arrow2::datatypes::*; #[test] fn debug() { - let boolean = BooleanArray::from_slice(&[false, false, true, true]).boxed(); - let int = Int32Array::from_slice(&[42, 28, 19, 31]).boxed(); + let boolean = BooleanArray::from_slice([false, false, true, true]).boxed(); + let int = Int32Array::from_slice([42, 28, 19, 31]).boxed(); let fields = vec![ Field::new("b", DataType::Boolean, false), diff --git a/tests/it/array/union.rs b/tests/it/array/union.rs index e1c681301b8..93622b415ad 100644 --- a/tests/it/array/union.rs +++ b/tests/it/array/union.rs @@ -29,7 +29,7 @@ fn sparse_debug() -> Result<()> { let types = vec![0, 0, 1].into(); let fields = vec![ Int32Array::from(&[Some(1), None, Some(2)]).boxed(), - Utf8Array::::from(&[Some("a"), Some("b"), Some("c")]).boxed(), + Utf8Array::::from([Some("a"), Some("b"), Some("c")]).boxed(), ]; let array = UnionArray::from_data(data_type, types, fields, None); @@ -49,7 +49,7 @@ fn dense_debug() -> Result<()> { let types = vec![0, 0, 1].into(); let fields = vec![ Int32Array::from(&[Some(1), None, Some(2)]).boxed(), - Utf8Array::::from(&[Some("c")]).boxed(), + Utf8Array::::from([Some("c")]).boxed(), ]; let offsets = Some(vec![0, 1, 0].into()); @@ -70,7 +70,7 @@ fn slice() -> Result<()> { let types = Buffer::from(vec![0, 0, 1]); let fields = vec![ Int32Array::from(&[Some(1), None, Some(2)]).boxed(), - Utf8Array::::from(&[Some("a"), Some("b"), Some("c")]).boxed(), + Utf8Array::::from([Some("a"), Some("b"), Some("c")]).boxed(), ]; let array = UnionArray::from_data(data_type.clone(), types, fields.clone(), None); @@ -80,7 +80,7 @@ fn slice() -> Result<()> { let sliced_types = Buffer::from(vec![0, 1]); let sliced_fields = vec![ Int32Array::from(&[None, Some(2)]).boxed(), - Utf8Array::::from(&[Some("b"), Some("c")]).boxed(), + Utf8Array::::from([Some("b"), Some("c")]).boxed(), ]; let expected = UnionArray::from_data(data_type, sliced_types, sliced_fields, None); @@ -98,7 +98,7 @@ fn iter_sparse() -> Result<()> { let types = Buffer::from(vec![0, 0, 1]); let fields = vec![ Int32Array::from(&[Some(1), None, Some(2)]).boxed(), - Utf8Array::::from(&[Some("a"), Some("b"), Some("c")]).boxed(), + Utf8Array::::from([Some("a"), Some("b"), Some("c")]).boxed(), ]; let array = UnionArray::from_data(data_type, types, fields.clone(), None); @@ -132,7 +132,7 @@ fn iter_dense() -> Result<()> { let offsets = Buffer::::from(vec![0, 1, 0]); let fields = vec![ Int32Array::from(&[Some(1), None]).boxed(), - Utf8Array::::from(&[Some("c")]).boxed(), + Utf8Array::::from([Some("c")]).boxed(), ]; let array = UnionArray::from_data(data_type, types, fields.clone(), Some(offsets)); @@ -165,7 +165,7 @@ fn iter_sparse_slice() -> Result<()> { let types = Buffer::from(vec![0, 0, 1]); let fields = vec![ Int32Array::from(&[Some(1), Some(3), Some(2)]).boxed(), - Utf8Array::::from(&[Some("a"), Some("b"), Some("c")]).boxed(), + Utf8Array::::from([Some("a"), Some("b"), Some("c")]).boxed(), ]; let array = UnionArray::from_data(data_type, types, fields.clone(), None); @@ -192,7 +192,7 @@ fn iter_dense_slice() -> Result<()> { let offsets = Buffer::::from(vec![0, 1, 0]); let fields = vec![ Int32Array::from(&[Some(1), Some(3)]).boxed(), - Utf8Array::::from(&[Some("c")]).boxed(), + Utf8Array::::from([Some("c")]).boxed(), ]; let array = UnionArray::from_data(data_type, types, fields.clone(), Some(offsets)); @@ -219,7 +219,7 @@ fn scalar() -> Result<()> { let offsets = Buffer::::from(vec![0, 1, 0]); let fields = vec![ Int32Array::from(&[Some(1), None]).boxed(), - Utf8Array::::from(&[Some("c")]).boxed(), + Utf8Array::::from([Some("c")]).boxed(), ]; let array = UnionArray::from_data(data_type, types, fields.clone(), Some(offsets)); diff --git a/tests/it/array/utf8/mod.rs b/tests/it/array/utf8/mod.rs index daa2734faa8..8c9b41e8b92 100644 --- a/tests/it/array/utf8/mod.rs +++ b/tests/it/array/utf8/mod.rs @@ -18,7 +18,7 @@ fn basics() { assert_eq!(array.offsets().as_slice(), &[0, 5, 5, 11]); assert_eq!( array.validity(), - Some(&Bitmap::from_u8_slice(&[0b00000101], 3)) + Some(&Bitmap::from_u8_slice([0b00000101], 3)) ); assert!(array.is_valid(0)); assert!(!array.is_valid(1)); @@ -50,7 +50,7 @@ fn empty() { #[test] fn from() { - let array = Utf8Array::::from(&[Some("hello"), Some(" "), None]); + let array = Utf8Array::::from([Some("hello"), Some(" "), None]); let a = array.validity().unwrap(); assert_eq!(a, &Bitmap::from([true, true, false])); @@ -172,7 +172,7 @@ fn index_out_of_bounds_panics() { #[test] fn debug() { - let array = Utf8Array::::from(&[Some("aa"), Some(""), None]); + let array = Utf8Array::::from([Some("aa"), Some(""), None]); assert_eq!(format!("{:?}", array), "Utf8Array[aa, , None]"); } @@ -219,7 +219,7 @@ fn into_mut_4() { #[test] fn rev_iter() { - let array = Utf8Array::::from(&[Some("hello"), Some(" "), None]); + let array = Utf8Array::::from([Some("hello"), Some(" "), None]); assert_eq!( array.into_iter().rev().collect::>(), @@ -229,7 +229,7 @@ fn rev_iter() { #[test] fn iter_nth() { - let array = Utf8Array::::from(&[Some("hello"), Some(" "), None]); + let array = Utf8Array::::from([Some("hello"), Some(" "), None]); assert_eq!(array.iter().nth(1), Some(Some(" "))); assert_eq!(array.iter().nth(10), None); diff --git a/tests/it/array/utf8/mutable.rs b/tests/it/array/utf8/mutable.rs index 58932d1f6b9..57c188fb808 100644 --- a/tests/it/array/utf8/mutable.rs +++ b/tests/it/array/utf8/mutable.rs @@ -105,7 +105,7 @@ fn test_extend_trusted_len_values() { assert_eq!(array.offsets().as_slice(), &[0, 2, 7, 12, 17, 17]); assert_eq!( array.validity(), - Some(&Bitmap::from_u8_slice(&[0b00001111], 5)) + Some(&Bitmap::from_u8_slice([0b00001111], 5)) ); } @@ -123,7 +123,7 @@ fn test_extend_trusted_len() { assert_eq!(array.offsets().as_slice(), &[0, 2, 7, 7, 12, 17]); assert_eq!( array.validity(), - Some(&Bitmap::from_u8_slice(&[0b00011011], 5)) + Some(&Bitmap::from_u8_slice([0b00011011], 5)) ); } @@ -201,7 +201,7 @@ fn as_box_twice() { #[test] fn extend_from_self() { - let mut a = MutableUtf8Array::::from(&[Some("aa"), None]); + let mut a = MutableUtf8Array::::from([Some("aa"), None]); a.try_extend_from_self(&a.clone()).unwrap(); diff --git a/tests/it/array/utf8/to_mutable.rs b/tests/it/array/utf8/to_mutable.rs index e9956feffdb..c4c822b62d8 100644 --- a/tests/it/array/utf8/to_mutable.rs +++ b/tests/it/array/utf8/to_mutable.rs @@ -2,7 +2,7 @@ use arrow2::{array::Utf8Array, bitmap::Bitmap, buffer::Buffer, datatypes::DataTy #[test] fn not_shared() { - let array = Utf8Array::::from(&[Some("hello"), Some(" "), None]); + let array = Utf8Array::::from([Some("hello"), Some(" "), None]); assert!(array.into_mut().is_right()); } @@ -62,6 +62,6 @@ fn shared_offsets() { #[test] #[allow(clippy::redundant_clone)] fn shared_all() { - let array = Utf8Array::::from(&[Some("hello"), Some(" "), None]); + let array = Utf8Array::::from([Some("hello"), Some(" "), None]); assert!(array.clone().into_mut().is_left()) } diff --git a/tests/it/bitmap/immutable.rs b/tests/it/bitmap/immutable.rs index e6b13d76d94..96f0584c99a 100644 --- a/tests/it/bitmap/immutable.rs +++ b/tests/it/bitmap/immutable.rs @@ -23,7 +23,7 @@ fn as_slice_offset() { #[test] fn as_slice_offset_middle() { - let b = Bitmap::from_u8_slice(&[0, 0, 0, 0b00010101], 27); + let b = Bitmap::from_u8_slice([0, 0, 0, 0b00010101], 27); let b = b.slice(22, 5); let (slice, offset, length) = b.as_slice(); diff --git a/tests/it/bitmap/mutable.rs b/tests/it/bitmap/mutable.rs index ccd4fc83d8e..6d4efd290df 100644 --- a/tests/it/bitmap/mutable.rs +++ b/tests/it/bitmap/mutable.rs @@ -248,7 +248,7 @@ fn extend_from_bitmap() { #[test] fn extend_from_bitmap_offset() { - let other = Bitmap::from_u8_slice(&[0b00111111], 8); + let other = Bitmap::from_u8_slice([0b00111111], 8); let mut bitmap = MutableBitmap::from_vec(vec![1, 0, 0b00101010], 22); // call is optimized to perform a memcopy @@ -258,7 +258,7 @@ fn extend_from_bitmap_offset() { assert_eq!(bitmap.as_slice(), &[1, 0, 0b11101010, 0b00001111]); // more than one byte - let other = Bitmap::from_u8_slice(&[0b00111111, 0b00001111, 0b0001100], 20); + let other = Bitmap::from_u8_slice([0b00111111, 0b00001111, 0b0001100], 20); let mut bitmap = MutableBitmap::from_vec(vec![1, 0, 0b00101010], 22); // call is optimized to perform a memcopy diff --git a/tests/it/bitmap/utils/slice_iterator.rs b/tests/it/bitmap/utils/slice_iterator.rs index d34b99d09b5..97fca44c31e 100644 --- a/tests/it/bitmap/utils/slice_iterator.rs +++ b/tests/it/bitmap/utils/slice_iterator.rs @@ -119,7 +119,7 @@ fn bla() { #[test] fn past_end_should_not_be_returned() { - let values = Bitmap::from_u8_slice(&[0b11111010], 3); + let values = Bitmap::from_u8_slice([0b11111010], 3); let iter = SlicesIterator::new(&values); let count = iter.slots(); assert_eq!(values.unset_bits() + iter.slots(), values.len()); @@ -131,7 +131,7 @@ fn past_end_should_not_be_returned() { #[test] fn sliced() { - let values = Bitmap::from_u8_slice(&[0b11111010, 0b11111011], 16); + let values = Bitmap::from_u8_slice([0b11111010, 0b11111011], 16); let values = values.slice(8, 2); let iter = SlicesIterator::new(&values); @@ -143,7 +143,7 @@ fn sliced() { #[test] fn remainder_1() { - let values = Bitmap::from_u8_slice(&[0, 0, 0b00000000, 0b00010101], 27); + let values = Bitmap::from_u8_slice([0, 0, 0b00000000, 0b00010101], 27); let values = values.slice(22, 5); let iter = SlicesIterator::new(&values); let chunks = iter.collect::>(); diff --git a/tests/it/compute/aggregate/memory.rs b/tests/it/compute/aggregate/memory.rs index d38967571cc..b1a839319a2 100644 --- a/tests/it/compute/aggregate/memory.rs +++ b/tests/it/compute/aggregate/memory.rs @@ -2,18 +2,18 @@ use arrow2::{array::*, compute::aggregate::estimated_bytes_size}; #[test] fn primitive() { - let a = Int32Array::from_slice(&[1, 2, 3, 4, 5]); + let a = Int32Array::from_slice([1, 2, 3, 4, 5]); assert_eq!(5 * std::mem::size_of::(), estimated_bytes_size(&a)); } #[test] fn boolean() { - let a = BooleanArray::from_slice(&[true]); + let a = BooleanArray::from_slice([true]); assert_eq!(1, estimated_bytes_size(&a)); } #[test] fn utf8() { - let a = Utf8Array::::from_slice(&["aaa"]); + let a = Utf8Array::::from_slice(["aaa"]); assert_eq!(3 + 2 * std::mem::size_of::(), estimated_bytes_size(&a)); } diff --git a/tests/it/compute/aggregate/min_max.rs b/tests/it/compute/aggregate/min_max.rs index 3cfc8b675f0..ba27c73adeb 100644 --- a/tests/it/compute/aggregate/min_max.rs +++ b/tests/it/compute/aggregate/min_max.rs @@ -6,7 +6,7 @@ use arrow2::{array::*, datatypes::DataType}; #[test] fn test_primitive_array_min_max() { - let a = Int32Array::from_slice(&[5, 6, 7, 8, 9]); + let a = Int32Array::from_slice([5, 6, 7, 8, 9]); assert_eq!(5, min_primitive(&a).unwrap()); assert_eq!(9, max_primitive(&a).unwrap()); } @@ -114,28 +114,28 @@ fn min_max_f64_edge_cases() { #[test] fn test_string_min_max_with_nulls() { - let a = Utf8Array::::from(&[Some("b"), None, None, Some("a"), Some("c")]); + let a = Utf8Array::::from([Some("b"), None, None, Some("a"), Some("c")]); assert_eq!(Some("a"), min_string(&a)); assert_eq!(Some("c"), max_string(&a)); } #[test] fn test_string_min_max_all_nulls() { - let a = Utf8Array::::from(&[None::<&str>, None]); + let a = Utf8Array::::from([None::<&str>, None]); assert_eq!(None, min_string(&a)); assert_eq!(None, max_string(&a)); } #[test] fn test_string_min_max_no_null() { - let a = Utf8Array::::from(&[Some("abc"), Some("abd"), Some("bac"), Some("bbb")]); + let a = Utf8Array::::from([Some("abc"), Some("abd"), Some("bac"), Some("bbb")]); assert_eq!(Some("abc"), min_string(&a)); assert_eq!(Some("bbb"), max_string(&a)); } #[test] fn test_string_min_max_1() { - let a = Utf8Array::::from(&[None, None, Some("b"), Some("a")]); + let a = Utf8Array::::from([None, None, Some("b"), Some("a")]); assert_eq!(Some("a"), min_string(&a)); assert_eq!(Some("b"), max_string(&a)); } @@ -197,14 +197,14 @@ fn test_boolean_min_max_smaller() { #[test] fn test_binary_min_max_with_nulls() { - let a = BinaryArray::::from(&[Some(b"b"), None, None, Some(b"a"), Some(b"c")]); + let a = BinaryArray::::from([Some(b"b"), None, None, Some(b"a"), Some(b"c")]); assert_eq!(Some("a".as_bytes()), min_binary(&a)); assert_eq!(Some("c".as_bytes()), max_binary(&a)); } #[test] fn test_binary_min_max_no_null() { - let a = BinaryArray::::from(&[ + let a = BinaryArray::::from([ Some("abc".as_bytes()), Some(b"acd"), Some(b"aabd"), @@ -216,14 +216,14 @@ fn test_binary_min_max_no_null() { #[test] fn test_binary_min_max_all_nulls() { - let a = BinaryArray::::from(&[None::<&[u8]>, None]); + let a = BinaryArray::::from([None::<&[u8]>, None]); assert_eq!(None, min_binary(&a)); assert_eq!(None, max_binary(&a)); } #[test] fn test_binary_min_max_1() { - let a = BinaryArray::::from(&[None, None, Some(b"b"), Some(b"a")]); + let a = BinaryArray::::from([None, None, Some(b"b"), Some(b"a")]); assert_eq!(Some("a".as_bytes()), min_binary(&a)); assert_eq!(Some("b".as_bytes()), max_binary(&a)); } @@ -231,7 +231,7 @@ fn test_binary_min_max_1() { #[test] fn test_max_not_lexi() { let values = [0, 10, 0, 0, 0, 0, 0, 0, 1, 0]; - let arr = Int64Array::from_slice(&values); + let arr = Int64Array::from_slice(values); let maximum = 10; let out = max_primitive(&arr).unwrap(); diff --git a/tests/it/compute/aggregate/sum.rs b/tests/it/compute/aggregate/sum.rs index c1d8190359b..8c12d1d38c5 100644 --- a/tests/it/compute/aggregate/sum.rs +++ b/tests/it/compute/aggregate/sum.rs @@ -6,7 +6,7 @@ use arrow2::scalar::{PrimitiveScalar, Scalar}; #[test] fn test_primitive_array_sum() { - let a = Int32Array::from_slice(&[1, 2, 3, 4, 5]); + let a = Int32Array::from_slice([1, 2, 3, 4, 5]); assert_eq!( &PrimitiveScalar::::from(Some(15)) as &dyn Scalar, sum(&a).unwrap().as_ref() @@ -21,7 +21,7 @@ fn test_primitive_array_sum() { #[test] fn test_primitive_array_float_sum() { - let a = Float64Array::from_slice(&[1.1f64, 2.2, 3.3, 4.4, 5.5]); + let a = Float64Array::from_slice([1.1f64, 2.2, 3.3, 4.4, 5.5]); assert!((16.5 - sum_primitive(&a).unwrap()).abs() < f64::EPSILON); } diff --git a/tests/it/compute/arithmetics/basic/add.rs b/tests/it/compute/arithmetics/basic/add.rs index c02f4c7d71c..45a4945bd1b 100644 --- a/tests/it/compute/arithmetics/basic/add.rs +++ b/tests/it/compute/arithmetics/basic/add.rs @@ -8,8 +8,8 @@ use arrow2::compute::arithmetics::{ #[test] #[should_panic] fn test_add_mismatched_length() { - let a = Int32Array::from_slice(&[5, 6]); - let b = Int32Array::from_slice(&[5]); + let a = Int32Array::from_slice([5, 6]); + let b = Int32Array::from_slice([5]); add(&a, &b); } diff --git a/tests/it/compute/arithmetics/basic/div.rs b/tests/it/compute/arithmetics/basic/div.rs index 8547795842d..6160f2eea18 100644 --- a/tests/it/compute/arithmetics/basic/div.rs +++ b/tests/it/compute/arithmetics/basic/div.rs @@ -5,8 +5,8 @@ use arrow2::compute::arithmetics::{ArrayCheckedDiv, ArrayDiv}; #[test] #[should_panic] fn test_div_mismatched_length() { - let a = Int32Array::from_slice(&[5, 6]); - let b = Int32Array::from_slice(&[5]); + let a = Int32Array::from_slice([5, 6]); + let b = Int32Array::from_slice([5]); div(&a, &b); } diff --git a/tests/it/compute/arithmetics/basic/mul.rs b/tests/it/compute/arithmetics/basic/mul.rs index d202edecb15..b8416e3e0c2 100644 --- a/tests/it/compute/arithmetics/basic/mul.rs +++ b/tests/it/compute/arithmetics/basic/mul.rs @@ -8,8 +8,8 @@ use arrow2::compute::arithmetics::{ #[test] #[should_panic] fn test_mul_mismatched_length() { - let a = Int32Array::from_slice(&[5, 6]); - let b = Int32Array::from_slice(&[5]); + let a = Int32Array::from_slice([5, 6]); + let b = Int32Array::from_slice([5]); mul(&a, &b); } diff --git a/tests/it/compute/arithmetics/basic/rem.rs b/tests/it/compute/arithmetics/basic/rem.rs index 52f6db82702..666cb3fd624 100644 --- a/tests/it/compute/arithmetics/basic/rem.rs +++ b/tests/it/compute/arithmetics/basic/rem.rs @@ -5,8 +5,8 @@ use arrow2::compute::arithmetics::{ArrayCheckedRem, ArrayRem}; #[test] #[should_panic] fn test_rem_mismatched_length() { - let a = Int32Array::from_slice(&[5, 6]); - let b = Int32Array::from_slice(&[5]); + let a = Int32Array::from_slice([5, 6]); + let b = Int32Array::from_slice([5]); rem(&a, &b); } diff --git a/tests/it/compute/arithmetics/basic/sub.rs b/tests/it/compute/arithmetics/basic/sub.rs index c56719f64b4..3822bf705b9 100644 --- a/tests/it/compute/arithmetics/basic/sub.rs +++ b/tests/it/compute/arithmetics/basic/sub.rs @@ -8,8 +8,8 @@ use arrow2::compute::arithmetics::{ #[test] #[should_panic] fn test_sub_mismatched_length() { - let a = Int32Array::from_slice(&[5, 6]); - let b = Int32Array::from_slice(&[5]); + let a = Int32Array::from_slice([5, 6]); + let b = Int32Array::from_slice([5]); sub(&a, &b); } diff --git a/tests/it/compute/arithmetics/mod.rs b/tests/it/compute/arithmetics/mod.rs index a22f146d7b2..a7060ab3281 100644 --- a/tests/it/compute/arithmetics/mod.rs +++ b/tests/it/compute/arithmetics/mod.rs @@ -96,14 +96,14 @@ fn test_neg() { #[test] fn test_neg_dict() { let a = DictionaryArray::try_from_keys( - UInt8Array::from_slice(&[0, 0, 1]), - Int8Array::from_slice(&[1, 2]).boxed(), + UInt8Array::from_slice([0, 0, 1]), + Int8Array::from_slice([1, 2]).boxed(), ) .unwrap(); let result = neg(&a); let expected = DictionaryArray::try_from_keys( - UInt8Array::from_slice(&[0, 0, 1]), - Int8Array::from_slice(&[-1, -2]).boxed(), + UInt8Array::from_slice([0, 0, 1]), + Int8Array::from_slice([-1, -2]).boxed(), ) .unwrap(); assert_eq!(expected, result.as_ref()); diff --git a/tests/it/compute/boolean.rs b/tests/it/compute/boolean.rs index 37174f224a0..c8c743b806e 100644 --- a/tests/it/compute/boolean.rs +++ b/tests/it/compute/boolean.rs @@ -213,7 +213,7 @@ fn array_and_validity_offset() { #[test] fn test_nonnull_array_is_null() { - let a = Int32Array::from_slice(&[1, 2, 3, 4]); + let a = Int32Array::from_slice([1, 2, 3, 4]); let res = is_null(&a); @@ -236,7 +236,7 @@ fn test_nonnull_array_with_offset_is_null() { #[test] fn test_nonnull_array_is_not_null() { - let a = Int32Array::from_slice(&[1, 2, 3, 4]); + let a = Int32Array::from_slice([1, 2, 3, 4]); let res = is_not_null(&a); @@ -247,12 +247,12 @@ fn test_nonnull_array_is_not_null() { #[test] fn test_nonnull_array_with_offset_is_not_null() { - let a = Int32Array::from_slice(&[1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1]); + let a = Int32Array::from_slice([1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1]); let a = a.slice(8, 4); let res = is_not_null(&a); - let expected = BooleanArray::from_slice(&[true, true, true, true]); + let expected = BooleanArray::from_slice([true, true, true, true]); assert_eq!(expected, res); } @@ -341,18 +341,18 @@ fn test_nullable_array_with_offset_is_not_null() { #[test] fn array_and_scalar() { - let array = BooleanArray::from_slice(&[false, false, true, true]); + let array = BooleanArray::from_slice([false, false, true, true]); let scalar = BooleanScalar::new(Some(true)); let real = and_scalar(&array, &scalar); - let expected = BooleanArray::from_slice(&[false, false, true, true]); + let expected = BooleanArray::from_slice([false, false, true, true]); assert_eq!(real, expected); let scalar = BooleanScalar::new(Some(false)); let real = and_scalar(&array, &scalar); - let expected = BooleanArray::from_slice(&[false, false, false, false]); + let expected = BooleanArray::from_slice([false, false, false, false]); assert_eq!(real, expected); } @@ -373,7 +373,7 @@ fn array_and_scalar_validity() { let expected = BooleanArray::from(&[None; 3]); assert_eq!(real, expected); - let array = BooleanArray::from_slice(&[true, false, true]); + let array = BooleanArray::from_slice([true, false, true]); let real = and_scalar(&array, &scalar); let expected = BooleanArray::from(&[None; 3]); @@ -382,18 +382,18 @@ fn array_and_scalar_validity() { #[test] fn array_or_scalar() { - let array = BooleanArray::from_slice(&[false, false, true, true]); + let array = BooleanArray::from_slice([false, false, true, true]); let scalar = BooleanScalar::new(Some(true)); let real = or_scalar(&array, &scalar); - let expected = BooleanArray::from_slice(&[true, true, true, true]); + let expected = BooleanArray::from_slice([true, true, true, true]); assert_eq!(real, expected); let scalar = BooleanScalar::new(Some(false)); let real = or_scalar(&array, &scalar); - let expected = BooleanArray::from_slice(&[false, false, true, true]); + let expected = BooleanArray::from_slice([false, false, true, true]); assert_eq!(real, expected); } @@ -413,7 +413,7 @@ fn array_or_scalar_validity() { let expected = BooleanArray::from(&[None; 3]); assert_eq!(real, expected); - let array = BooleanArray::from_slice(&[true, false, true]); + let array = BooleanArray::from_slice([true, false, true]); let real = and_scalar(&array, &scalar); let expected = BooleanArray::from(&[None; 3]); diff --git a/tests/it/compute/boolean_kleene.rs b/tests/it/compute/boolean_kleene.rs index c1c034ca9fd..5c722b20bd8 100644 --- a/tests/it/compute/boolean_kleene.rs +++ b/tests/it/compute/boolean_kleene.rs @@ -86,7 +86,7 @@ fn or_generic() { #[test] fn or_right_nulls() { - let a = BooleanArray::from_slice(&[false, false, false, true, true, true]); + let a = BooleanArray::from_slice([false, false, false, true, true, true]); let b = BooleanArray::from(&[Some(true), Some(false), None, Some(true), Some(false), None]); @@ -115,7 +115,7 @@ fn or_left_nulls() { None, ]); - let b = BooleanArray::from_slice(&[false, false, false, true, true, true]); + let b = BooleanArray::from_slice([false, false, false, true, true, true]); let c = or(&a, &b); diff --git a/tests/it/compute/cast.rs b/tests/it/compute/cast.rs index ae5e2d46c12..7973ad798fa 100644 --- a/tests/it/compute/cast.rs +++ b/tests/it/compute/cast.rs @@ -5,7 +5,7 @@ use arrow2::types::{days_ms, months_days_ns, NativeType}; #[test] fn i32_to_f64() { - let array = Int32Array::from_slice(&[5, 6, 7, 8, 9]); + let array = Int32Array::from_slice([5, 6, 7, 8, 9]); let b = cast(&array, &DataType::Float64, CastOptions::default()).unwrap(); let c = b.as_any().downcast_ref::().unwrap(); assert!((5.0 - c.value(0)).abs() < f64::EPSILON); @@ -17,7 +17,7 @@ fn i32_to_f64() { #[test] fn i32_as_f64_no_overflow() { - let array = Int32Array::from_slice(&[5, 6, 7, 8, 9]); + let array = Int32Array::from_slice([5, 6, 7, 8, 9]); let b = cast( &array, &DataType::Float64, @@ -37,7 +37,7 @@ fn i32_as_f64_no_overflow() { #[test] fn u16_as_u8_overflow() { - let array = UInt16Array::from_slice(&[255, 256, 257, 258, 259]); + let array = UInt16Array::from_slice([255, 256, 257, 258, 259]); let b = cast( &array, &DataType::UInt8, @@ -55,7 +55,7 @@ fn u16_as_u8_overflow() { #[test] fn u16_as_u8_no_overflow() { - let array = UInt16Array::from_slice(&[1, 2, 3, 4, 5]); + let array = UInt16Array::from_slice([1, 2, 3, 4, 5]); let b = cast( &array, &DataType::UInt8, @@ -72,7 +72,7 @@ fn u16_as_u8_no_overflow() { #[test] fn f32_as_u8_overflow() { - let array = Float32Array::from_slice(&[1.1, 5000.0]); + let array = Float32Array::from_slice([1.1, 5000.0]); let b = cast(&array, &DataType::UInt8, CastOptions::default()).unwrap(); let expected = UInt8Array::from(&[Some(1), None]); assert_eq!(expected, b.as_ref()); @@ -92,7 +92,7 @@ fn f32_as_u8_overflow() { #[test] fn i32_to_u8() { - let array = Int32Array::from_slice(&[-5, 6, -7, 8, 100000000]); + let array = Int32Array::from_slice([-5, 6, -7, 8, 100000000]); let b = cast(&array, &DataType::UInt8, CastOptions::default()).unwrap(); let expected = UInt8Array::from(&[None, Some(6), None, Some(8), None]); let c = b.as_any().downcast_ref::().unwrap(); @@ -101,7 +101,7 @@ fn i32_to_u8() { #[test] fn i32_to_u8_sliced() { - let array = Int32Array::from_slice(&[-5, 6, -7, 8, 100000000]); + let array = Int32Array::from_slice([-5, 6, -7, 8, 100000000]); let array = array.slice(2, 3); let b = cast(&array, &DataType::UInt8, CastOptions::default()).unwrap(); let expected = UInt8Array::from(&[None, Some(8), None]); @@ -111,7 +111,7 @@ fn i32_to_u8_sliced() { #[test] fn i32_to_i32() { - let array = Int32Array::from_slice(&[5, 6, 7, 8, 9]); + let array = Int32Array::from_slice([5, 6, 7, 8, 9]); let b = cast(&array, &DataType::Int32, CastOptions::default()).unwrap(); let c = b.as_any().downcast_ref::().unwrap(); @@ -122,7 +122,7 @@ fn i32_to_i32() { #[test] fn i32_to_list_i32() { - let array = Int32Array::from_slice(&[5, 6, 7, 8, 9]); + let array = Int32Array::from_slice([5, 6, 7, 8, 9]); let b = cast( &array, &DataType::List(Box::new(Field::new("item", DataType::Int32, true))), @@ -138,7 +138,7 @@ fn i32_to_list_i32() { .downcast_ref::>() .unwrap(); - let expected = Int32Array::from_slice(&[5, 6, 7, 8, 9]); + let expected = Int32Array::from_slice([5, 6, 7, 8, 9]); assert_eq!(c, &expected); } @@ -190,16 +190,16 @@ fn i32_to_list_f64_nullable_sliced() { #[test] fn i32_to_binary() { - let array = Int32Array::from_slice(&[5, 6, 7]); + let array = Int32Array::from_slice([5, 6, 7]); let b = cast(&array, &DataType::Binary, CastOptions::default()).unwrap(); - let expected = BinaryArray::::from(&[Some(b"5"), Some(b"6"), Some(b"7")]); + let expected = BinaryArray::::from([Some(b"5"), Some(b"6"), Some(b"7")]); let c = b.as_any().downcast_ref::>().unwrap(); assert_eq!(c, &expected); } #[test] fn binary_to_i32() { - let array = BinaryArray::::from_slice(&["5", "6", "seven", "8", "9.1"]); + let array = BinaryArray::::from_slice(["5", "6", "seven", "8", "9.1"]); let b = cast(&array, &DataType::Int32, CastOptions::default()).unwrap(); let c = b.as_any().downcast_ref::>().unwrap(); @@ -210,7 +210,7 @@ fn binary_to_i32() { #[test] fn binary_to_i32_partial() { - let array = BinaryArray::::from_slice(&["5", "6", "123 abseven", "aaa", "9.1"]); + let array = BinaryArray::::from_slice(["5", "6", "123 abseven", "aaa", "9.1"]); let b = cast( &array, &DataType::Int32, @@ -229,7 +229,7 @@ fn binary_to_i32_partial() { #[test] fn utf8_to_i32() { - let array = Utf8Array::::from_slice(&["5", "6", "seven", "8", "9.1"]); + let array = Utf8Array::::from_slice(["5", "6", "seven", "8", "9.1"]); let b = cast(&array, &DataType::Int32, CastOptions::default()).unwrap(); let c = b.as_any().downcast_ref::>().unwrap(); @@ -362,7 +362,7 @@ fn decimal_to_integer() { #[test] fn utf8_to_i32_partial() { - let array = Utf8Array::::from_slice(&["5", "6", "seven", "8aa", "9.1aa"]); + let array = Utf8Array::::from_slice(["5", "6", "seven", "8aa", "9.1aa"]); let b = cast( &array, &DataType::Int32, @@ -407,7 +407,7 @@ fn bool_to_utf8() { let b = cast(&array, &DataType::Utf8, CastOptions::default()).unwrap(); let c = b.as_any().downcast_ref::>().unwrap(); - let expected = Utf8Array::::from(&[Some("1"), Some("0"), Some("0")]); + let expected = Utf8Array::::from([Some("1"), Some("0"), Some("0")]); assert_eq!(c, &expected); } @@ -417,7 +417,7 @@ fn bool_to_binary() { let b = cast(&array, &DataType::Binary, CastOptions::default()).unwrap(); let c = b.as_any().downcast_ref::>().unwrap(); - let expected = BinaryArray::::from(&[Some("1"), Some("0"), Some("0")]); + let expected = BinaryArray::::from([Some("1"), Some("0"), Some("0")]); assert_eq!(c, &expected); } @@ -631,7 +631,7 @@ fn timestamp_to_timestamp() { #[test] fn utf8_to_dict() { - let array = Utf8Array::::from(&[Some("one"), None, Some("three"), Some("one")]); + let array = Utf8Array::::from([Some("one"), None, Some("three"), Some("one")]); // Cast to a dictionary (same value type, Utf8) let cast_type = DataType::Dictionary(u8::KEY_TYPE, Box::new(DataType::Utf8), false); @@ -655,7 +655,7 @@ fn dict_to_utf8() { let result = cast(&array, &DataType::Utf8, CastOptions::default()).expect("cast failed"); - let expected = Utf8Array::::from(&[Some("one"), None, Some("three"), Some("one")]); + let expected = Utf8Array::::from([Some("one"), None, Some("three"), Some("one")]); assert_eq!(expected, result.as_ref()); } @@ -732,8 +732,8 @@ fn list_to_from_fixed_size_list() { fn timestamp_with_tz_to_utf8() { let tz = "-02:00".to_string(); let expected = - Utf8Array::::from_slice(&["1996-12-19T16:39:57-02:00", "1996-12-19T17:39:57-02:00"]); - let array = Int64Array::from_slice(&[851020797000000000, 851024397000000000]) + Utf8Array::::from_slice(["1996-12-19T16:39:57-02:00", "1996-12-19T17:39:57-02:00"]); + let array = Int64Array::from_slice([851020797000000000, 851024397000000000]) .to(DataType::Timestamp(TimeUnit::Nanosecond, Some(tz))); let result = cast(&array, expected.data_type(), CastOptions::default()).expect("cast failed"); @@ -744,9 +744,9 @@ fn timestamp_with_tz_to_utf8() { fn utf8_to_timestamp_with_tz() { let tz = "-02:00".to_string(); let array = - Utf8Array::::from_slice(&["1996-12-19T16:39:57-02:00", "1996-12-19T17:39:57-02:00"]); + Utf8Array::::from_slice(["1996-12-19T16:39:57-02:00", "1996-12-19T17:39:57-02:00"]); // the timezone is used to map the time to UTC. - let expected = Int64Array::from_slice(&[851020797000000000, 851024397000000000]) + let expected = Int64Array::from_slice([851020797000000000, 851024397000000000]) .to(DataType::Timestamp(TimeUnit::Nanosecond, Some(tz))); let result = cast(&array, expected.data_type(), CastOptions::default()).expect("cast failed"); @@ -756,9 +756,9 @@ fn utf8_to_timestamp_with_tz() { #[test] fn utf8_to_naive_timestamp() { let array = - Utf8Array::::from_slice(&["1996-12-19T16:39:57-02:00", "1996-12-19T17:39:57-02:00"]); + Utf8Array::::from_slice(["1996-12-19T16:39:57-02:00", "1996-12-19T17:39:57-02:00"]); // the timezone is disregarded from the string and we assume UTC - let expected = Int64Array::from_slice(&[851013597000000000, 851017197000000000]) + let expected = Int64Array::from_slice([851013597000000000, 851017197000000000]) .to(DataType::Timestamp(TimeUnit::Nanosecond, None)); let result = cast(&array, expected.data_type(), CastOptions::default()).expect("cast failed"); @@ -767,10 +767,10 @@ fn utf8_to_naive_timestamp() { #[test] fn naive_timestamp_to_utf8() { - let array = Int64Array::from_slice(&[851013597000000000, 851017197000000000]) + let array = Int64Array::from_slice([851013597000000000, 851017197000000000]) .to(DataType::Timestamp(TimeUnit::Nanosecond, None)); - let expected = Utf8Array::::from_slice(&["1996-12-19 16:39:57", "1996-12-19 17:39:57"]); + let expected = Utf8Array::::from_slice(["1996-12-19 16:39:57", "1996-12-19 17:39:57"]); let result = cast(&array, expected.data_type(), CastOptions::default()).expect("cast failed"); assert_eq!(expected, result.as_ref()); @@ -817,22 +817,22 @@ fn null_array_from_and_to_others() { #[test] fn utf8_to_date32() { - let array = Utf8Array::::from_slice(&["1970-01-01", "1970-01-02"]); + let array = Utf8Array::::from_slice(["1970-01-01", "1970-01-02"]); let b = cast(&array, &DataType::Date32, CastOptions::default()).unwrap(); let c = b.as_any().downcast_ref::().unwrap(); - let expected = Int32Array::from_slice(&[0, 1]).to(DataType::Date32); + let expected = Int32Array::from_slice([0, 1]).to(DataType::Date32); assert_eq!(&expected, c); } #[test] fn utf8_to_date64() { - let array = Utf8Array::::from_slice(&["1970-01-01", "1970-01-02"]); + let array = Utf8Array::::from_slice(["1970-01-01", "1970-01-02"]); let b = cast(&array, &DataType::Date64, CastOptions::default()).unwrap(); let c = b.as_any().downcast_ref::().unwrap(); - let expected = Int64Array::from_slice(&[0, 86400000]).to(DataType::Date64); + let expected = Int64Array::from_slice([0, 86400000]).to(DataType::Date64); assert_eq!(&expected, c); } diff --git a/tests/it/compute/comparison.rs b/tests/it/compute/comparison.rs index eb5058d337a..bc9e5a2319d 100644 --- a/tests/it/compute/comparison.rs +++ b/tests/it/compute/comparison.rs @@ -112,11 +112,11 @@ fn test_eq_scalar() { #[test] fn test_eq_with_slice() { - let a = BooleanArray::from_slice(&[true, true, false]); - let b = BooleanArray::from_slice(&[true, true, true, true, false]); + let a = BooleanArray::from_slice([true, true, false]); + let b = BooleanArray::from_slice([true, true, true, true, false]); let c = b.slice(2, 3); let d = eq(&c, &a); - assert_eq!(d, BooleanArray::from_slice(&[true, true, true])); + assert_eq!(d, BooleanArray::from_slice([true, true, true])); } #[test] diff --git a/tests/it/compute/contains.rs b/tests/it/compute/contains.rs index ac789628b1d..cfbdd9946e0 100644 --- a/tests/it/compute/contains.rs +++ b/tests/it/compute/contains.rs @@ -43,7 +43,7 @@ fn test_contains_binary() { Some(vec![Some(b"a"), Some(b"b"), None]), None, ]; - let values = BinaryArray::::from(&[Some(b"a"), Some(b"c"), None, Some(b"a")]); + let values = BinaryArray::::from([Some(b"a"), Some(b"c"), None, Some(b"a")]); let expected = BooleanArray::from(vec![ Some(true), Some(false), diff --git a/tests/it/compute/filter.rs b/tests/it/compute/filter.rs index f5f2cbc18ed..4ad80c49aee 100644 --- a/tests/it/compute/filter.rs +++ b/tests/it/compute/filter.rs @@ -4,11 +4,11 @@ use arrow2::compute::filter::*; #[test] fn array_slice() { - let a = Int32Array::from_slice(&[5, 6, 7, 8, 9]).slice(1, 4); + let a = Int32Array::from_slice([5, 6, 7, 8, 9]).slice(1, 4); let b = BooleanArray::from_slice(vec![true, true, false, false, true]).slice(1, 4); let c = filter(&a, &b).unwrap(); - let expected = Int32Array::from_slice(&[6, 9]); + let expected = Int32Array::from_slice([6, 9]); assert_eq!(expected, c.as_ref()); } @@ -25,7 +25,7 @@ fn array_low_density() { let b = BooleanArray::from_slice(filter_values); let c = filter(&a, &b).unwrap(); - let expected = Int32Array::from_slice(&[65, 67]); + let expected = Int32Array::from_slice([65, 67]); assert_eq!(expected, c.as_ref()); } @@ -57,8 +57,8 @@ fn array_high_density() { #[test] fn string_array_simple() { - let a = Utf8Array::::from_slice(&["hello", " ", "world", "!"]); - let b = BooleanArray::from_slice(&[true, false, true, false]); + let a = Utf8Array::::from_slice(["hello", " ", "world", "!"]); + let b = BooleanArray::from_slice([true, false, true, false]); let c = filter(&a, &b).unwrap(); let d = c .as_ref() @@ -115,15 +115,15 @@ fn binary_array_with_null() { #[test] fn masked_true_values() { - let a = Int32Array::from_slice(&[1, 2, 3]); - let b = BooleanArray::from_slice(&[true, false, true]); + let a = Int32Array::from_slice([1, 2, 3]); + let b = BooleanArray::from_slice([true, false, true]); let validity = Bitmap::from(&[true, false, false]); let b = b.with_validity(Some(validity)); let c = filter(&a, &b).unwrap(); - let expected = Int32Array::from_slice(&[1]); + let expected = Int32Array::from_slice([1]); assert_eq!(expected, c.as_ref()); } diff --git a/tests/it/compute/if_then_else.rs b/tests/it/compute/if_then_else.rs index 35e280eb4bf..842ac7374b6 100644 --- a/tests/it/compute/if_then_else.rs +++ b/tests/it/compute/if_then_else.rs @@ -4,12 +4,12 @@ use arrow2::error::Result; #[test] fn basics() -> Result<()> { - let lhs = Int32Array::from_slice(&[1, 2, 3]); - let rhs = Int32Array::from_slice(&[4, 5, 6]); + let lhs = Int32Array::from_slice([1, 2, 3]); + let rhs = Int32Array::from_slice([4, 5, 6]); let predicate = BooleanArray::from_slice(vec![true, false, true]); let c = if_then_else(&predicate, &lhs, &rhs)?; - let expected = Int32Array::from_slice(&[1, 5, 3]); + let expected = Int32Array::from_slice([1, 5, 3]); assert_eq!(expected, c.as_ref()); Ok(()) @@ -30,8 +30,8 @@ fn basics_nulls() -> Result<()> { #[test] fn basics_nulls_pred() -> Result<()> { - let lhs = Int32Array::from_slice(&[1, 2, 3]); - let rhs = Int32Array::from_slice(&[4, 5, 6]); + let lhs = Int32Array::from_slice([1, 2, 3]); + let rhs = Int32Array::from_slice([4, 5, 6]); let predicate = BooleanArray::from(&[Some(true), None, Some(false)]); let result = if_then_else(&predicate, &lhs, &rhs)?; diff --git a/tests/it/compute/like.rs b/tests/it/compute/like.rs index 3bd4c6aaf3d..c7026be7cac 100644 --- a/tests/it/compute/like.rs +++ b/tests/it/compute/like.rs @@ -4,77 +4,77 @@ use arrow2::error::Result; #[test] fn test_like_binary() -> Result<()> { - let strings = BinaryArray::::from_slice(&["Arrow", "Arrow", "Arrow", "Arrow", "Ar"]); - let patterns = BinaryArray::::from_slice(&["A%", "B%", "%r_ow", "A_", "A_"]); + let strings = BinaryArray::::from_slice(["Arrow", "Arrow", "Arrow", "Arrow", "Ar"]); + let patterns = BinaryArray::::from_slice(["A%", "B%", "%r_ow", "A_", "A_"]); let result = like_binary(&strings, &patterns).unwrap(); assert_eq!( result, - BooleanArray::from_slice(&[true, false, true, false, true]) + BooleanArray::from_slice([true, false, true, false, true]) ); Ok(()) } #[test] fn test_nlike_binary() -> Result<()> { - let strings = BinaryArray::::from_slice(&["Arrow", "Arrow", "Arrow", "Arrow", "Ar"]); - let patterns = BinaryArray::::from_slice(&["A%", "B%", "%r_ow", "A_", "A_"]); + let strings = BinaryArray::::from_slice(["Arrow", "Arrow", "Arrow", "Arrow", "Ar"]); + let patterns = BinaryArray::::from_slice(["A%", "B%", "%r_ow", "A_", "A_"]); let result = nlike_binary(&strings, &patterns).unwrap(); assert_eq!( result, - BooleanArray::from_slice(&[false, true, false, true, false]) + BooleanArray::from_slice([false, true, false, true, false]) ); Ok(()) } #[test] fn test_like_binary_scalar() -> Result<()> { - let array = BinaryArray::::from_slice(&["Arrow", "Arrow", "Arrow", "BA"]); + let array = BinaryArray::::from_slice(["Arrow", "Arrow", "Arrow", "BA"]); let result = like_binary_scalar(&array, b"A%").unwrap(); - assert_eq!(result, BooleanArray::from_slice(&[true, true, true, false])); + assert_eq!(result, BooleanArray::from_slice([true, true, true, false])); let result = like_binary_scalar(&array, b"Arrow").unwrap(); - assert_eq!(result, BooleanArray::from_slice(&[true, true, true, false])); + assert_eq!(result, BooleanArray::from_slice([true, true, true, false])); Ok(()) } #[test] fn test_like_utf8_scalar() -> Result<()> { - let array = Utf8Array::::from_slice(&["Arrow", "Arrow", "Arrow", "BA"]); + let array = Utf8Array::::from_slice(["Arrow", "Arrow", "Arrow", "BA"]); let result = like_utf8_scalar(&array, "A%").unwrap(); - assert_eq!(result, BooleanArray::from_slice(&[true, true, true, false])); + assert_eq!(result, BooleanArray::from_slice([true, true, true, false])); let result = like_utf8_scalar(&array, "Arrow").unwrap(); - assert_eq!(result, BooleanArray::from_slice(&[true, true, true, false])); + assert_eq!(result, BooleanArray::from_slice([true, true, true, false])); - let array = Utf8Array::::from_slice(&["A%", "Arrow"]); + let array = Utf8Array::::from_slice(["A%", "Arrow"]); let result = like_utf8_scalar(&array, "A\\%").unwrap(); - assert_eq!(result, BooleanArray::from_slice(&[true, false])); + assert_eq!(result, BooleanArray::from_slice([true, false])); - let array = Utf8Array::::from_slice(&["A_row", "Arrow"]); + let array = Utf8Array::::from_slice(["A_row", "Arrow"]); let result = like_utf8_scalar(&array, "A\\_row").unwrap(); - assert_eq!(result, BooleanArray::from_slice(&[true, false])); + assert_eq!(result, BooleanArray::from_slice([true, false])); Ok(()) } #[test] fn test_nlike_binary_scalar() -> Result<()> { - let array = BinaryArray::::from_slice(&["Arrow", "Arrow", "Arrow", "BA"]); + let array = BinaryArray::::from_slice(["Arrow", "Arrow", "Arrow", "BA"]); let result = nlike_binary_scalar(&array, "A%".as_bytes()).unwrap(); assert_eq!( result, - BooleanArray::from_slice(&[false, false, false, true]) + BooleanArray::from_slice([false, false, false, true]) ); let result = nlike_binary_scalar(&array, "Arrow".as_bytes()).unwrap(); assert_eq!( result, - BooleanArray::from_slice(&[false, false, false, true]) + BooleanArray::from_slice([false, false, false, true]) ); Ok(()) diff --git a/tests/it/compute/limit.rs b/tests/it/compute/limit.rs index 30a43e5ce2a..545d546fe3e 100644 --- a/tests/it/compute/limit.rs +++ b/tests/it/compute/limit.rs @@ -3,9 +3,9 @@ use arrow2::compute::limit::limit; #[test] fn limit_array() { - let a = Int32Array::from_slice(&[5, 6, 7, 8, 9]); + let a = Int32Array::from_slice([5, 6, 7, 8, 9]); let b = limit(&a, 3); let c = b.as_ref().as_any().downcast_ref::().unwrap(); - let expected = Int32Array::from_slice(&[5, 6, 7]); + let expected = Int32Array::from_slice([5, 6, 7]); assert_eq!(&expected, c); } diff --git a/tests/it/compute/merge_sort.rs b/tests/it/compute/merge_sort.rs index e50a41d77e2..3adabb803a6 100644 --- a/tests/it/compute/merge_sort.rs +++ b/tests/it/compute/merge_sort.rs @@ -7,8 +7,8 @@ use arrow2::error::Result; #[test] fn merge_u32() -> Result<()> { - let a0: &dyn Array = &Int32Array::from_slice(&[0, 1, 2, 3]); - let a1: &dyn Array = &Int32Array::from_slice(&[2, 3, 4, 5]); + let a0: &dyn Array = &Int32Array::from_slice([0, 1, 2, 3]); + let a1: &dyn Array = &Int32Array::from_slice([2, 3, 4, 5]); let options = SortOptions::default(); let arrays = vec![a0, a1]; @@ -36,8 +36,8 @@ fn merge_u32() -> Result<()> { #[test] fn merge_with_limit() -> Result<()> { - let a0: &dyn Array = &Int32Array::from_slice(&[0, 2, 4, 6, 8]); - let a1: &dyn Array = &Int32Array::from_slice(&[1, 3, 5, 7, 9]); + let a0: &dyn Array = &Int32Array::from_slice([0, 2, 4, 6, 8]); + let a1: &dyn Array = &Int32Array::from_slice([1, 3, 5, 7, 9]); let options = SortOptions::default(); let arrays = vec![a0, a1]; @@ -48,7 +48,7 @@ fn merge_with_limit() -> Result<()> { // thus, they can be used to take from the arrays let array = take_arrays(&arrays, slices, Some(5)); - let expected = Int32Array::from_slice(&[0, 1, 2, 3, 4]); + let expected = Int32Array::from_slice([0, 1, 2, 3, 4]); // values are right assert_eq!(expected, array.as_ref()); Ok(()) @@ -56,8 +56,8 @@ fn merge_with_limit() -> Result<()> { #[test] fn merge_slices_to_vec() -> Result<()> { - let a0: &dyn Array = &Int32Array::from_slice(&[0, 2, 4, 6, 8]); - let a1: &dyn Array = &Int32Array::from_slice(&[1, 3, 5, 7, 9]); + let a0: &dyn Array = &Int32Array::from_slice([0, 2, 4, 6, 8]); + let a1: &dyn Array = &Int32Array::from_slice([1, 3, 5, 7, 9]); let options = SortOptions::default(); let arrays = vec![a0, a1]; @@ -72,10 +72,10 @@ fn merge_slices_to_vec() -> Result<()> { #[test] fn merge_4_i32() -> Result<()> { - let a0: &dyn Array = &Int32Array::from_slice(&[0, 1]); - let a1: &dyn Array = &Int32Array::from_slice(&[2, 6]); - let a2: &dyn Array = &Int32Array::from_slice(&[3, 5]); - let a3: &dyn Array = &Int32Array::from_slice(&[4, 7]); + let a0: &dyn Array = &Int32Array::from_slice([0, 1]); + let a1: &dyn Array = &Int32Array::from_slice([2, 6]); + let a2: &dyn Array = &Int32Array::from_slice([3, 5]); + let a3: &dyn Array = &Int32Array::from_slice([4, 7]); let options = SortOptions::default(); let arrays = vec![a0, a1, a2, a3]; @@ -99,7 +99,7 @@ fn merge_4_i32() -> Result<()> { // thus, they can be used to take from the arrays let array = take_arrays(&arrays, slices, None); - let expected = Int32Array::from_slice(&[0, 1, 2, 3, 4, 5, 6, 7]); + let expected = Int32Array::from_slice([0, 1, 2, 3, 4, 5, 6, 7]); // values are right assert_eq!(expected, array.as_ref()); @@ -108,8 +108,8 @@ fn merge_4_i32() -> Result<()> { #[test] fn merge_binary() -> Result<()> { - let a0: &dyn Array = &BinaryArray::::from_slice(&[b"a", b"c", b"d", b"e"]); - let a1: &dyn Array = &BinaryArray::::from_slice(&[b"b", b"y", b"z", b"z"]); + let a0: &dyn Array = &BinaryArray::::from_slice([b"a", b"c", b"d", b"e"]); + let a1: &dyn Array = &BinaryArray::::from_slice([b"b", b"y", b"z", b"z"]); let options = SortOptions::default(); let arrays = vec![a0, a1]; @@ -139,8 +139,8 @@ fn merge_binary() -> Result<()> { #[test] fn merge_string() -> Result<()> { - let a0: &dyn Array = &Utf8Array::::from_slice(&["a", "c", "d", "e"]); - let a1: &dyn Array = &Utf8Array::::from_slice(&["b", "y", "z", "z"]); + let a0: &dyn Array = &Utf8Array::::from_slice(["a", "c", "d", "e"]); + let a1: &dyn Array = &Utf8Array::::from_slice(["b", "y", "z", "z"]); let options = SortOptions::default(); let arrays = vec![a0, a1]; @@ -171,17 +171,17 @@ fn merge_string() -> Result<()> { #[test] fn merge_sort_many() -> Result<()> { // column 1 - let a00: &dyn Array = &Int32Array::from_slice(&[0, 1, 2, 3]); - let a01: &dyn Array = &Int32Array::from_slice(&[2, 3, 4]); + let a00: &dyn Array = &Int32Array::from_slice([0, 1, 2, 3]); + let a01: &dyn Array = &Int32Array::from_slice([2, 3, 4]); // column 2 - let a10: &dyn Array = &Utf8Array::::from_slice(&["a", "c", "d", "e"]); - let a11: &dyn Array = &Utf8Array::::from_slice(&["b", "y", "z"]); + let a10: &dyn Array = &Utf8Array::::from_slice(["a", "c", "d", "e"]); + let a11: &dyn Array = &Utf8Array::::from_slice(["b", "y", "z"]); // column 3 // arrays to be sorted via the columns above - let array0: &dyn Array = &Int32Array::from_slice(&[0, 1, 2, 3]); - let array1: &dyn Array = &Int32Array::from_slice(&[4, 5, 6]); + let array0: &dyn Array = &Int32Array::from_slice([0, 1, 2, 3]); + let array1: &dyn Array = &Int32Array::from_slice([4, 5, 6]); - let expected = Int32Array::from_slice(&[ + let expected = Int32Array::from_slice([ 0, // 0 (a00) < 2 (a01) 1, // 1 (a00) < 2 (a01) 4, // 2 (a00) == 2 (a01), "d" (a10) > "b" (a11) diff --git a/tests/it/compute/partition.rs b/tests/it/compute/partition.rs index 3b390ac6406..1e064633197 100644 --- a/tests/it/compute/partition.rs +++ b/tests/it/compute/partition.rs @@ -16,7 +16,7 @@ fn lexicographical_partition_ranges_empty() { #[test] fn lexicographical_partition_ranges_unaligned_rows() { let values1 = Int64Array::from([None, Some(-1)]); - let values2 = Utf8Array::::from(&[Some("foo")]); + let values2 = Utf8Array::::from([Some("foo")]); let input = vec![ SortColumn { values: &values1, @@ -35,7 +35,7 @@ fn lexicographical_partition_ranges_unaligned_rows() { #[test] fn lexicographical_partition_single_column() -> Result<()> { - let values = Int64Array::from_slice(&[1, 2, 2, 2, 2, 2, 2, 2, 9]); + let values = Int64Array::from_slice([1, 2, 2, 2, 2, 2, 2, 2, 9]); let input = vec![SortColumn { values: &values, options: Some(SortOptions { diff --git a/tests/it/compute/take.rs b/tests/it/compute/take.rs index ce17581a0db..0e1719fb4eb 100644 --- a/tests/it/compute/take.rs +++ b/tests/it/compute/take.rs @@ -22,7 +22,7 @@ where #[test] fn test_take_primitive_non_null_indices() { - let indices = Int32Array::from_slice(&[0, 5, 3, 1, 4, 2]); + let indices = Int32Array::from_slice([0, 5, 3, 1, 4, 2]); test_take_primitive::( &[None, Some(2), Some(4), Some(6), Some(8), None], &indices, @@ -61,8 +61,8 @@ fn test_take_primitive_null_values() { } fn create_test_struct() -> StructArray { - let boolean = BooleanArray::from_slice(&[true, false, false, true]); - let int = Int32Array::from_slice(&[42, 28, 19, 31]); + let boolean = BooleanArray::from_slice([true, false, false, true]); + let int = Int32Array::from_slice([42, 28, 19, 31]); let validity = vec![true, true, false, true] .into_iter() .collect::() @@ -154,7 +154,7 @@ fn consistency() { #[test] fn empty() { - let indices = Int32Array::from_slice(&[]); + let indices = Int32Array::from_slice([]); let values = BooleanArray::from(vec![Some(true), Some(false)]); let a = take(&values, &indices).unwrap(); assert_eq!(a.len(), 0) @@ -162,7 +162,7 @@ fn empty() { #[test] fn unsigned_take() { - let indices = UInt32Array::from_slice(&[]); + let indices = UInt32Array::from_slice([]); let values = BooleanArray::from(vec![Some(true), Some(false)]); let a = take(&values, &indices).unwrap(); assert_eq!(a.len(), 0) diff --git a/tests/it/ffi/data.rs b/tests/it/ffi/data.rs index 337326b6319..1f8606aee8c 100644 --- a/tests/it/ffi/data.rs +++ b/tests/it/ffi/data.rs @@ -47,7 +47,7 @@ fn bool_nullable() -> Result<()> { #[test] fn bool() -> Result<()> { - let data = BooleanArray::from_slice(&[true, true, false]); + let data = BooleanArray::from_slice([true, true, false]); test_round_trip(data) } @@ -66,7 +66,7 @@ fn u32_nullable() -> Result<()> { #[test] fn u32() -> Result<()> { - let data = Int32Array::from_slice(&[2, 0, 1, 0]); + let data = Int32Array::from_slice([2, 0, 1, 0]); test_round_trip(data) } @@ -79,7 +79,7 @@ fn u32_sliced() -> Result<()> { #[test] fn decimal() -> Result<()> { - let data = Int128Array::from_slice(&[1, 0, 2, 0]); + let data = Int128Array::from_slice([1, 0, 2, 0]); test_round_trip(data) } @@ -106,7 +106,7 @@ fn utf8_nullable() -> Result<()> { #[test] fn utf8() -> Result<()> { - let data = Utf8Array::::from_slice(&["a", "", "bb", ""]); + let data = Utf8Array::::from_slice(["a", "", "bb", ""]); test_round_trip(data) } @@ -137,7 +137,7 @@ fn binary_nullable() -> Result<()> { #[test] fn binary() -> Result<()> { - let data = BinaryArray::::from_slice(&[b"a".as_ref(), b"", b"bb", b""]); + let data = BinaryArray::::from_slice([b"a".as_ref(), b"", b"bb", b""]); test_round_trip(data) } diff --git a/tests/it/io/avro/write.rs b/tests/it/io/avro/write.rs index 091da09c75b..ffb71dcfc23 100644 --- a/tests/it/io/avro/write.rs +++ b/tests/it/io/avro/write.rs @@ -191,8 +191,8 @@ fn large_format_schema() -> Schema { fn large_format_data() -> Chunk> { let columns = vec![ - Box::new(Utf8Array::::from_slice(&["a", "b"])) as Box, - Box::new(Utf8Array::::from(&[Some("a"), None])), + Box::new(Utf8Array::::from_slice(["a", "b"])) as Box, + Box::new(Utf8Array::::from([Some("a"), None])), Box::new(BinaryArray::::from_slice([b"foo", b"bar"])), Box::new(BinaryArray::::from([Some(b"foo"), None])), ]; @@ -210,8 +210,8 @@ fn large_format_expected_schema() -> Schema { fn large_format_expected_data() -> Chunk> { let columns = vec![ - Box::new(Utf8Array::::from_slice(&["a", "b"])) as Box, - Box::new(Utf8Array::::from(&[Some("a"), None])), + Box::new(Utf8Array::::from_slice(["a", "b"])) as Box, + Box::new(Utf8Array::::from([Some("a"), None])), Box::new(BinaryArray::::from_slice([b"foo", b"bar"])), Box::new(BinaryArray::::from([Some(b"foo"), None])), ]; diff --git a/tests/it/io/csv/read.rs b/tests/it/io/csv/read.rs index e7e732a506c..975c3f3fab1 100644 --- a/tests/it/io/csv/read.rs +++ b/tests/it/io/csv/read.rs @@ -100,7 +100,7 @@ fn test_deserialize(input: &str, data_type: DataType) -> Result> #[test] fn utf8() -> Result<()> { let data = "1,\n,\n3,"; - let expected = Utf8Array::::from(&[Some("1"), Some(""), Some("3")]); + let expected = Utf8Array::::from([Some("1"), Some(""), Some("3")]); let result = test_deserialize(data, expected.data_type().clone())?; assert_eq!(expected, result.as_ref()); @@ -110,7 +110,7 @@ fn utf8() -> Result<()> { #[test] fn large_utf8() -> Result<()> { let data = "1,\n,\n3,"; - let expected = Utf8Array::::from(&[Some("1"), Some(""), Some("3")]); + let expected = Utf8Array::::from([Some("1"), Some(""), Some("3")]); let result = test_deserialize(data, expected.data_type().clone())?; assert_eq!(expected, result.as_ref()); @@ -120,7 +120,7 @@ fn large_utf8() -> Result<()> { #[test] fn binary() -> Result<()> { let data = "1,\n,\n3,"; - let expected = BinaryArray::::from(&[Some(b"1".as_ref()), Some(b"".as_ref()), Some(b"3")]); + let expected = BinaryArray::::from([Some(b"1".as_ref()), Some(b"".as_ref()), Some(b"3")]); let result = test_deserialize(data, expected.data_type().clone())?; assert_eq!(expected, result.as_ref()); @@ -130,7 +130,7 @@ fn binary() -> Result<()> { #[test] fn large_binary() -> Result<()> { let data = "1,\n,\n3,"; - let expected = BinaryArray::::from(&[Some(b"1".as_ref()), Some(b"".as_ref()), Some(b"3")]); + let expected = BinaryArray::::from([Some(b"1".as_ref()), Some(b"".as_ref()), Some(b"3")]); let result = test_deserialize(data, expected.data_type().clone())?; assert_eq!(expected, result.as_ref()); @@ -220,7 +220,7 @@ fn i64() -> Result<()> { #[test] fn ts_ns() -> Result<()> { let data = "1970-01-01T00:00:00.000000001\n"; - let expected = Int64Array::from_slice(&[1]).to(DataType::Timestamp(TimeUnit::Nanosecond, None)); + let expected = Int64Array::from_slice([1]).to(DataType::Timestamp(TimeUnit::Nanosecond, None)); let result = test_deserialize(data, expected.data_type().clone())?; assert_eq!(expected, result.as_ref()); @@ -230,8 +230,7 @@ fn ts_ns() -> Result<()> { #[test] fn ts_us() -> Result<()> { let data = "1970-01-01T00:00:00.000001\n"; - let expected = - Int64Array::from_slice(&[1]).to(DataType::Timestamp(TimeUnit::Microsecond, None)); + let expected = Int64Array::from_slice([1]).to(DataType::Timestamp(TimeUnit::Microsecond, None)); let result = test_deserialize(data, expected.data_type().clone())?; assert_eq!(expected, result.as_ref()); @@ -241,8 +240,7 @@ fn ts_us() -> Result<()> { #[test] fn ts_ms() -> Result<()> { let data = "1970-01-01T00:00:00.001\n"; - let expected = - Int64Array::from_slice(&[1]).to(DataType::Timestamp(TimeUnit::Millisecond, None)); + let expected = Int64Array::from_slice([1]).to(DataType::Timestamp(TimeUnit::Millisecond, None)); let result = test_deserialize(data, expected.data_type().clone())?; assert_eq!(expected, result.as_ref()); @@ -252,7 +250,7 @@ fn ts_ms() -> Result<()> { #[test] fn ts_s() -> Result<()> { let data = "1970-01-01T00:00:01\n"; - let expected = Int64Array::from_slice(&[1]).to(DataType::Timestamp(TimeUnit::Second, None)); + let expected = Int64Array::from_slice([1]).to(DataType::Timestamp(TimeUnit::Second, None)); let result = test_deserialize(data, expected.data_type().clone())?; assert_eq!(expected, result.as_ref()); diff --git a/tests/it/io/csv/write.rs b/tests/it/io/csv/write.rs index 80d7212175f..87a83170e03 100644 --- a/tests/it/io/csv/write.rs +++ b/tests/it/io/csv/write.rs @@ -9,13 +9,13 @@ use arrow2::io::csv::write::*; fn data() -> Chunk> { let c1 = Utf8Array::::from_slice(["a b", "c", "d"]); let c2 = Float64Array::from([Some(123.564532), None, Some(-556132.25)]); - let c3 = UInt32Array::from_slice(&[3, 2, 1]); + let c3 = UInt32Array::from_slice([3, 2, 1]); let c4 = BooleanArray::from(&[Some(true), Some(false), None]); let c5 = PrimitiveArray::::from([None, Some(1555584887378), Some(1555555555555)]) .to(DataType::Timestamp(TimeUnit::Millisecond, None)); let c6 = PrimitiveArray::::from_vec(vec![1234, 24680, 85563]) .to(DataType::Time32(TimeUnit::Second)); - let keys = UInt32Array::from_slice(&[2, 0, 1]); + let keys = UInt32Array::from_slice([2, 0, 1]); let c7 = DictionaryArray::try_from_keys(keys, Box::new(c1.clone())).unwrap(); Chunk::new(vec![ @@ -103,39 +103,39 @@ fn data_array(column: &str) -> (Chunk>, Vec<&'static str>) { vec!["a b", "c", "d"], ), "i8" => ( - Int8Array::from_slice(&[3, 2, 1]).boxed(), + Int8Array::from_slice([3, 2, 1]).boxed(), vec!["3", "2", "1"], ), "i16" => ( - Int16Array::from_slice(&[3, 2, 1]).boxed(), + Int16Array::from_slice([3, 2, 1]).boxed(), vec!["3", "2", "1"], ), "i32" => ( - Int32Array::from_slice(&[3, 2, 1]).boxed(), + Int32Array::from_slice([3, 2, 1]).boxed(), vec!["3", "2", "1"], ), "i64" => ( - Int64Array::from_slice(&[3, 2, 1]).boxed(), + Int64Array::from_slice([3, 2, 1]).boxed(), vec!["3", "2", "1"], ), "u8" => ( - UInt8Array::from_slice(&[3, 2, 1]).boxed(), + UInt8Array::from_slice([3, 2, 1]).boxed(), vec!["3", "2", "1"], ), "u16" => ( - UInt16Array::from_slice(&[3, 2, 1]).boxed(), + UInt16Array::from_slice([3, 2, 1]).boxed(), vec!["3", "2", "1"], ), "u32" => ( - UInt32Array::from_slice(&[3, 2, 1]).boxed(), + UInt32Array::from_slice([3, 2, 1]).boxed(), vec!["3", "2", "1"], ), "u64" => ( - UInt64Array::from_slice(&[3, 2, 1]).boxed(), + UInt64Array::from_slice([3, 2, 1]).boxed(), vec!["3", "2", "1"], ), - "f32" => (Float32Array::from_slice(&[3.1]).boxed(), vec!["3.1"]), - "f64" => (Float64Array::from_slice(&[3.1]).boxed(), vec!["3.1"]), + "f32" => (Float32Array::from_slice([3.1]).boxed(), vec!["3.1"]), + "f64" => (Float64Array::from_slice([3.1]).boxed(), vec!["3.1"]), "date32" => { let array = PrimitiveArray::::from_vec(vec![1]).to(DataType::Date32); (array.boxed(), vec!["1970-01-02 00:00:00"]) @@ -254,13 +254,13 @@ fn data_array(column: &str) -> (Chunk>, Vec<&'static str>) { ) } "dictionary[u32]" => { - let keys = UInt32Array::from_slice(&[2, 1, 0]); + let keys = UInt32Array::from_slice([2, 1, 0]); let values = Utf8Array::::from_slice(["a b", "c", "d"]).boxed(); let array = DictionaryArray::try_from_keys(keys, values).unwrap(); (array.boxed(), vec!["d", "c", "a b"]) } "dictionary[u64]" => { - let keys = UInt64Array::from_slice(&[2, 1, 0]); + let keys = UInt64Array::from_slice([2, 1, 0]); let values = Utf8Array::::from_slice(["a b", "c", "d"]).boxed(); let array = DictionaryArray::try_from_keys(keys, values).unwrap(); (array.boxed(), vec!["d", "c", "a b"]) @@ -398,8 +398,8 @@ fn test_generic(chunk: Chunk>, expected: &str) { #[test] fn write_empty_and_missing() { - let a = Utf8Array::::from(&[Some(""), None]); - let b = Utf8Array::::from(&[None, Some("")]); + let a = Utf8Array::::from([Some(""), None]); + let b = Utf8Array::::from([None, Some("")]); let chunk = Chunk::new(vec![a.boxed(), b.boxed()]); test_generic(chunk, "\"\",\n,\"\"\n"); } @@ -412,12 +412,12 @@ fn write_escaping_resize_local_buf() { "bar,1234567890123456789012345678901234567890123456789012345678900293480293847", "This is the mail system at host smtp.sciprofiles.com.I'm sorry to have to inform you that your message could notbe delivered to one or more recipients. It's attached below.For further assistance,bar", ] { - let a = Utf8Array::::from_slice(&[payload]); + let a = Utf8Array::::from_slice([payload]); let chunk = Chunk::new(vec![a.boxed()]); test_generic(chunk, &format!("\"{}\"\n", payload)); - let a = Utf8Array::::from_slice(&[payload]); + let a = Utf8Array::::from_slice([payload]); let chunk = Chunk::new(vec![a.boxed()]); test_generic(chunk, &format!("\"{}\"\n", payload)); diff --git a/tests/it/io/json/write.rs b/tests/it/io/json/write.rs index 8c7830f8ef7..8555f0081c6 100644 --- a/tests/it/io/json/write.rs +++ b/tests/it/io/json/write.rs @@ -326,7 +326,7 @@ fn list_of_struct() -> Result<()> { Some(Bitmap::from_u8_slice([0b00000101], 3)), ); - let c2 = Int32Array::from_slice(&[1, 2, 3]); + let c2 = Int32Array::from_slice([1, 2, 3]); let data_type = DataType::Struct(vec![ Field::new("c1", c1.data_type().clone(), true), diff --git a/tests/it/io/ndjson/mod.rs b/tests/it/io/ndjson/mod.rs index 0f90da3c14f..632d3015383 100644 --- a/tests/it/io/ndjson/mod.rs +++ b/tests/it/io/ndjson/mod.rs @@ -81,7 +81,7 @@ fn case_list() -> (String, Box) { .unwrap(); let c: ListArray = c.into(); - let d = Utf8Array::::from(&[Some("4"), None, Some("text")]); + let d = Utf8Array::::from([Some("4"), None, Some("text")]); let array = StructArray::from_data( data_type, @@ -153,10 +153,10 @@ fn case_basics() -> (String, Box) { let array = StructArray::from_data( data_type, vec![ - Int64Array::from_slice(&[1, -10, 100000000]).boxed(), - Float64Array::from_slice(&[2.0, -3.5, 0.6]).boxed(), + Int64Array::from_slice([1, -10, 100000000]).boxed(), + Float64Array::from_slice([2.0, -3.5, 0.6]).boxed(), BooleanArray::from(&[Some(false), Some(true), None]).boxed(), - Utf8Array::::from(&[Some("4"), None, Some("text")]).boxed(), + Utf8Array::::from([Some("4"), None, Some("text")]).boxed(), ], None, ); @@ -178,10 +178,10 @@ fn case_projection() -> (String, Box) { let array = StructArray::from_data( data_type, vec![ - UInt32Array::from_slice(&[1, 10, 100000000]).boxed(), - Float32Array::from_slice(&[2.0, -3.5, 0.6]).boxed(), + UInt32Array::from_slice([1, 10, 100000000]).boxed(), + Float32Array::from_slice([2.0, -3.5, 0.6]).boxed(), BooleanArray::from(&[Some(false), Some(true), None]).boxed(), - BinaryArray::::from(&[Some(b"4".as_ref()), Some(b"text".as_ref()), None]).boxed(), + BinaryArray::::from([Some(b"4".as_ref()), Some(b"text".as_ref()), None]).boxed(), ], None, ); diff --git a/tests/it/io/ndjson/read.rs b/tests/it/io/ndjson/read.rs index 8837402d018..d7aa3b3feb2 100644 --- a/tests/it/io/ndjson/read.rs +++ b/tests/it/io/ndjson/read.rs @@ -230,7 +230,7 @@ fn line_break_in_values() -> Result<()> { let data_type = DataType::Utf8; let arrays = read_and_deserialize(ndjson, &data_type, 1000)?; - let expected = Utf8Array::::from(&[Some("aa\n\n"), Some("aa\n"), None]); + let expected = Utf8Array::::from([Some("aa\n\n"), Some("aa\n"), None]); assert_eq!(expected, arrays[0].as_ref()); Ok(()) diff --git a/tests/it/io/parquet/mod.rs b/tests/it/io/parquet/mod.rs index b1bab1b84ae..0681fac1bf7 100644 --- a/tests/it/io/parquet/mod.rs +++ b/tests/it/io/parquet/mod.rs @@ -536,10 +536,10 @@ pub fn pyarrow_required(column: &str) -> Box { match column { "int64" => Box::new(PrimitiveArray::::from(i64_values)), - "bool" => Box::new(BooleanArray::from_slice(&[ + "bool" => Box::new(BooleanArray::from_slice([ true, true, false, false, false, true, true, true, true, true, ])), - "string" => Box::new(Utf8Array::::from_slice(&[ + "string" => Box::new(Utf8Array::::from_slice([ "Hello", "bbb", "aa", "", "bbb", "abc", "bbb", "bbb", "def", "aaa", ])), "decimal_9" => { diff --git a/tests/it/io/parquet/read_indexes.rs b/tests/it/io/parquet/read_indexes.rs index bfa5f2a3c3b..c30d28ea965 100644 --- a/tests/it/io/parquet/read_indexes.rs +++ b/tests/it/io/parquet/read_indexes.rs @@ -284,7 +284,7 @@ fn indexed_dict() -> Result<()> { let values = PrimitiveArray::from_slice([4i32, 6i32]).boxed(); let array = DictionaryArray::try_from_keys(indices, values).unwrap(); - let indices = PrimitiveArray::from_slice(&[0u64]); + let indices = PrimitiveArray::from_slice([0u64]); let values = PrimitiveArray::from_slice([4i32, 6i32]).boxed(); let expected = DictionaryArray::try_from_keys(indices, values).unwrap(); diff --git a/tests/it/io/print.rs b/tests/it/io/print.rs index 6e37836d6b8..f96af000fee 100644 --- a/tests/it/io/print.rs +++ b/tests/it/io/print.rs @@ -322,7 +322,7 @@ fn write_struct() -> Result<()> { ]; let values = vec![ Int32Array::from(&[Some(1), None, Some(2)]).boxed(), - Utf8Array::::from(&[Some("a"), Some("b"), Some("c")]).boxed(), + Utf8Array::::from([Some("a"), Some("b"), Some("c")]).boxed(), ]; let validity = Some(Bitmap::from(&[true, false, true])); @@ -360,7 +360,7 @@ fn write_union() -> Result<()> { let types = Buffer::from(vec![0, 0, 1]); let fields = vec![ Int32Array::from(&[Some(1), None, Some(2)]).boxed(), - Utf8Array::::from(&[Some("a"), Some("b"), Some("c")]).boxed(), + Utf8Array::::from([Some("a"), Some("b"), Some("c")]).boxed(), ]; let array = UnionArray::from_data(data_type, types, fields, None); diff --git a/tests/it/temporal_conversions.rs b/tests/it/temporal_conversions.rs index 7f8e7313882..91dd1ba8efc 100644 --- a/tests/it/temporal_conversions.rs +++ b/tests/it/temporal_conversions.rs @@ -7,7 +7,7 @@ use arrow2::types::months_days_ns; fn naive() { let expected = "Timestamp(Nanosecond, None)[1996-12-19 16:39:57, 1996-12-19 13:39:57, None]"; let fmt = "%Y-%m-%dT%H:%M:%S:z"; - let array = Utf8Array::::from_slice(&[ + let array = Utf8Array::::from_slice([ "1996-12-19T16:39:57-02:00", "1996-12-19T13:39:57-03:00", "1996-12-19 13:39:57-03:00", // missing T @@ -16,7 +16,7 @@ fn naive() { assert_eq!(format!("{:?}", r), expected); let fmt = "%Y-%m-%dT%H:%M:%S"; // no tz info - let array = Utf8Array::::from_slice(&[ + let array = Utf8Array::::from_slice([ "1996-12-19T16:39:57-02:00", "1996-12-19T13:39:57-03:00", "1996-12-19 13:39:57-03:00", // missing T @@ -29,7 +29,7 @@ fn naive() { fn naive_no_tz() { let expected = "Timestamp(Nanosecond, None)[1996-12-19 16:39:57, 1996-12-19 13:39:57, None]"; let fmt = "%Y-%m-%dT%H:%M:%S"; // no tz info - let array = Utf8Array::::from_slice(&[ + let array = Utf8Array::::from_slice([ "1996-12-19T16:39:57", "1996-12-19T13:39:57", "1996-12-19 13:39:57", // missing T @@ -44,7 +44,7 @@ fn tz_aware() { let expected = "Timestamp(Nanosecond, Some(\"-02:00\"))[1996-12-19 16:39:57 -02:00, 1996-12-19 17:39:57 -02:00, None]"; let fmt = "%Y-%m-%dT%H:%M:%S%.f%:z"; - let array = Utf8Array::::from_slice(&[ + let array = Utf8Array::::from_slice([ "1996-12-19T16:39:57.0-02:00", "1996-12-19T16:39:57.0-03:00", // same time at a different TZ "1996-12-19 13:39:57.0-03:00", @@ -58,7 +58,7 @@ fn tz_aware_no_timezone() { let tz = "-02:00".to_string(); let expected = "Timestamp(Nanosecond, Some(\"-02:00\"))[None, None, None]"; let fmt = "%Y-%m-%dT%H:%M:%S%.f"; - let array = Utf8Array::::from_slice(&[ + let array = Utf8Array::::from_slice([ "1996-12-19T16:39:57.0", "1996-12-19T17:39:57.0", "1996-12-19 13:39:57.0",