From b1894ad3c838f13f64f6e5c3f69cd8ee22dd2edd Mon Sep 17 00:00:00 2001
From: my-vegetable-has-exploded <wy1109468038@gmail.com>
Date: Mon, 18 Dec 2023 22:57:00 +0800
Subject: [PATCH] add some tests

---
 arrow-cast/src/cast.rs | 67 ++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 64 insertions(+), 3 deletions(-)

diff --git a/arrow-cast/src/cast.rs b/arrow-cast/src/cast.rs
index 9e774b51dbce..e32e60739649 100644
--- a/arrow-cast/src/cast.rs
+++ b/arrow-cast/src/cast.rs
@@ -1144,15 +1144,15 @@ pub fn cast_with_options(
                 ))),
             }
         }
-        (Struct(_), Struct(fields_r)) => {
+        (Struct(_), Struct(to_fields)) => {
             let array = array.as_any().downcast_ref::<StructArray>().unwrap();
             let fields = array
                 .columns()
                 .iter()
-                .zip(fields_r.iter())
+                .zip(to_fields.iter())
                 .map(|(l, field)| cast_with_options(l, field.data_type(), cast_options))
                 .collect::<Result<Vec<ArrayRef>, ArrowError>>()?;
-            let array = StructArray::new(fields_r.clone(), fields, array.nulls().cloned());
+            let array = StructArray::new(to_fields.clone(), fields, array.nulls().cloned());
             Ok(Arc::new(array) as ArrayRef)
         }
         (Struct(_), _) => Err(ArrowError::CastError(
@@ -9464,4 +9464,65 @@ mod tests {
             );
         }
     }
+    #[test]
+    fn test_cast_struct_to_struct() {
+        let struct_type = DataType::Struct(
+            vec![
+                Field::new("a", DataType::Boolean, false),
+                Field::new("b", DataType::Int32, false),
+            ]
+            .into(),
+        );
+        let to_type = DataType::Struct(
+            vec![
+                Field::new("a", DataType::Utf8, false),
+                Field::new("b", DataType::Utf8, false),
+            ]
+            .into(),
+        );
+        let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
+        let int = Arc::new(Int32Array::from(vec![42, 28, 19, 31]));
+        let struct_array = StructArray::from(vec![
+            (
+                Arc::new(Field::new("b", DataType::Boolean, false)),
+                boolean.clone() as ArrayRef,
+            ),
+            (
+                Arc::new(Field::new("c", DataType::Int32, false)),
+                int.clone() as ArrayRef,
+            ),
+        ]);
+        let casted_array = cast(&struct_array, &to_type).unwrap();
+        let casted_array = casted_array.as_struct();
+        assert_eq!(casted_array.data_type(), &to_type);
+        let casted_boolean_array = casted_array
+            .column(0)
+            .as_string::<i32>()
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
+        let casted_int_array = casted_array
+            .column(1)
+            .as_string::<i32>()
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
+        assert_eq!(casted_boolean_array, vec!["false", "false", "true", "true"]);
+        assert_eq!(casted_int_array, vec!["42", "28", "19", "31"]);
+
+        // test for can't cast
+        let to_type = DataType::Struct(
+            vec![
+                Field::new("a", DataType::Date32, false),
+                Field::new("b", DataType::Utf8, false),
+            ]
+            .into(),
+        );
+        assert_eq!(can_cast_types(&struct_type, &to_type), false);
+        let result = cast(&struct_array, &to_type);
+        assert_eq!(
+            "Cast error: Casting from Boolean to Date32 not supported",
+            result.unwrap_err().to_string()
+        );
+    }
 }