Added more tests

jorgecarleitao · Mar 13, 2022 · 34f9eab · 34f9eab
1 parent 8b504d9
commit 34f9eab
Show file tree

Hide file tree

Showing 3 changed files with 81 additions and 32 deletions.
diff --git a/src/array/utf8/mod.rs b/src/array/utf8/mod.rs
@@ -341,24 +341,30 @@ impl<O: Offset> Utf8Array<O> {
             }
         } else {
             match (self.values.into_mut(), self.offsets.into_mut()) {
-                (Left(immutable_values), Left(immutable_offsets)) => Left(Utf8Array::from_data(
-                    self.data_type,
-                    immutable_offsets,
-                    immutable_values,
-                    None,
-                )),
-                (Left(immutable_values), Right(mutable_offsets)) => Left(Utf8Array::from_data(
-                    self.data_type,
-                    mutable_offsets.into(),
-                    immutable_values,
-                    None,
-                )),
-                (Right(mutable_values), Left(immutable_offsets)) => Left(Utf8Array::from_data(
-                    self.data_type,
-                    immutable_offsets,
-                    mutable_values.into(),
-                    None,
-                )),
+                (Left(immutable_values), Left(immutable_offsets)) => Left(unsafe {
+                    Utf8Array::new_unchecked(
+                        self.data_type,
+                        immutable_offsets,
+                        immutable_values,
+                        None,
+                    )
+                }),
+                (Left(immutable_values), Right(mutable_offsets)) => Left(unsafe {
+                    Utf8Array::new_unchecked(
+                        self.data_type,
+                        mutable_offsets.into(),
+                        immutable_values,
+                        None,
+                    )
+                }),
+                (Right(mutable_values), Left(immutable_offsets)) => Left(unsafe {
+                    Utf8Array::from_data(
+                        self.data_type,
+                        immutable_offsets,
+                        mutable_values.into(),
+                        None,
+                    )
+                }),
                 (Right(mutable_values), Right(mutable_offsets)) => {
                     Right(MutableUtf8Array::from_data(
                         self.data_type,

diff --git a/tests/it/array/primitive/mod.rs b/tests/it/array/primitive/mod.rs
@@ -204,6 +204,19 @@ fn debug_timestamp_tz_ns() {
     );
 }
 
+#[cfg(feature = "chrono-tz")]
+#[test]
+fn debug_timestamp_tz1_ns() {
+    let array = Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Timestamp(
+        TimeUnit::Nanosecond,
+        Some("Europe/Lisbon".to_string()),
+    ));
+    assert_eq!(
+        format!("{:?}", array),
+        "Timestamp(Nanosecond, Some(\"Europe/Lisbon\"))[1970-01-01 01:00:00.000000001 CET, None, 1970-01-01 02:00:00.000000002 CET]"
+    );
+}
+
 #[test]
 fn debug_duration_ms() {
     let array =

diff --git a/tests/it/array/utf8/mod.rs b/tests/it/array/utf8/mod.rs
@@ -110,60 +110,53 @@ fn try_from_trusted_len_iter() {
 }
 
 #[test]
-#[should_panic]
 fn not_utf8() {
     let offsets = Buffer::from_slice([0, 4]);
     let values = Buffer::from_slice([0, 159, 146, 150]); // invalid utf8
-    Utf8Array::<i32>::from_data(DataType::Utf8, offsets, values, None);
+    assert!(Utf8Array::<i32>::try_new(DataType::Utf8, offsets, values, None).is_err());
 }
 
 #[test]
-#[should_panic]
 fn not_utf8_individually() {
     let offsets = Buffer::from_slice([0, 1, 2]);
     let values = Buffer::from_slice([207, 128]); // each is invalid utf8, but together is valid
-    Utf8Array::<i32>::from_data(DataType::Utf8, offsets, values, None);
+    assert!(Utf8Array::<i32>::try_new(DataType::Utf8, offsets, values, None).is_err());
 }
 
 #[test]
-#[should_panic]
 fn wrong_offsets() {
     let offsets = Buffer::from_slice([0, 5, 4]); // invalid offsets
     let values = Buffer::from_slice(b"abbbbb");
-    Utf8Array::<i32>::from_data(DataType::Utf8, offsets, values, None);
+    assert!(Utf8Array::<i32>::try_new(DataType::Utf8, offsets, values, None).is_err());
 }
 
 #[test]
-#[should_panic]
 fn wrong_data_type() {
     let offsets = Buffer::from_slice([0, 4]);
     let values = Buffer::from_slice(b"abbb");
-    Utf8Array::<i32>::from_data(DataType::Int8, offsets, values, None);
+    assert!(Utf8Array::<i32>::try_new(DataType::Int32, offsets, values, None).is_err());
 }
 
 #[test]
-#[should_panic]
 fn out_of_bounds_offsets_panics() {
     // the 10 is out of bounds
     let offsets = Buffer::from_slice([0, 10, 11]);
     let values = Buffer::from_slice(b"abbb");
-    let _ = Utf8Array::<i32>::from_data(DataType::Utf8, offsets, values, None);
+    assert!(Utf8Array::<i32>::try_new(DataType::Utf8, offsets, values, None).is_err());
 }
 
 #[test]
-#[should_panic]
 fn decreasing_offset_and_ascii_panics() {
     let offsets = Buffer::from_slice([0, 2, 1]);
     let values = Buffer::from_slice(b"abbb");
-    let _ = Utf8Array::<i32>::from_data(DataType::Utf8, offsets, values, None);
+    assert!(Utf8Array::<i32>::try_new(DataType::Utf8, offsets, values, None).is_err());
 }
 
 #[test]
-#[should_panic]
 fn decreasing_offset_and_utf8_panics() {
     let offsets = Buffer::from_slice([0, 2, 4, 2]); // not increasing
     let values = Buffer::from_slice([207, 128, 207, 128, 207, 128]); // valid utf8
-    let _ = Utf8Array::<i32>::from_data(DataType::Utf8, offsets, values, None);
+    assert!(Utf8Array::<i32>::try_new(DataType::Utf8, offsets, values, None).is_err());
 }
 
 #[test]
@@ -182,3 +175,40 @@ fn debug() {
 
     assert_eq!(format!("{:?}", array), "Utf8Array[aa, , None]");
 }
+
+#[test]
+fn into_mut_1() {
+    let offsets = Buffer::from_slice([0, 1]);
+    let values = Buffer::from_slice(b"a");
+    let a = values.clone(); // cloned values
+    let array = Utf8Array::<i32>::from_data(DataType::Utf8, offsets, values, None);
+    assert!(array.into_mut().is_left());
+}
+
+#[test]
+fn into_mut_2() {
+    let offsets = Buffer::from_slice([0, 1]);
+    let values = Buffer::from_slice(b"a");
+    let a = offsets.clone(); // cloned offsets
+    let array = Utf8Array::<i32>::from_data(DataType::Utf8, offsets, values, None);
+    assert!(array.into_mut().is_left());
+}
+
+#[test]
+fn into_mut_3() {
+    let offsets = Buffer::from_slice([0, 1]);
+    let values = Buffer::from_slice(b"a");
+    let validity = Some([true].into());
+    let a = validity.clone(); // cloned validity
+    let array = Utf8Array::<i32>::new(DataType::Utf8, offsets, values, validity);
+    assert!(array.into_mut().is_left());
+}
+
+#[test]
+fn into_mut_4() {
+    let offsets = Buffer::from_slice([0, 1]);
+    let values = Buffer::from_slice(b"a");
+    let validity = Some([true].into());
+    let array = Utf8Array::<i32>::new(DataType::Utf8, offsets, values, validity);
+    assert!(array.into_mut().is_right());
+}