move tests to slt file

Author: JeelRajodiya

datafusion/spark/src/function/string/encode.rs

@@ -337,9 +337,8 @@ impl ScalarUDFImpl for SparkEncode {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use arrow::array::{Array, BinaryArray, StringArray, StringViewArray};
+    use arrow::array::{BinaryArray, StringViewArray};
     use datafusion_common::config::ConfigOptions;
-    use datafusion_expr::ScalarUDF;
 
     /// Helper to invoke encode as a scalar with two literal string arguments.
     fn eval_encode_scalar_with_ansi(
@@ -376,37 +375,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_encode_utf8() {
-        let result =
-            eval_encode_scalar(ScalarValue::Utf8(Some("Spark SQL".into())), "UTF-8")
-                .unwrap();
-        let bytes = expect_binary_scalar(result);
-        assert_eq!(bytes, b"Spark SQL");
-    }
-
-    #[test]
-    fn test_encode_us_ascii() {
-        let result =
-            eval_encode_scalar(ScalarValue::Utf8(Some("Hello".into())), "US-ASCII")
-                .unwrap();
-        assert_eq!(expect_binary_scalar(result), b"Hello");
-    }
-
-    #[test]
-    fn test_encode_iso_8859_1() {
-        // "naïve" — U+00EF (ï) is 0xEF in ISO-8859-1
-        let result = eval_encode_scalar(
-            ScalarValue::Utf8(Some("na\u{00EF}ve".into())),
-            "ISO-8859-1",
-        )
-        .unwrap();
-        assert_eq!(
-            expect_binary_scalar(result),
-            vec![0x6E, 0x61, 0xEF, 0x76, 0x65]
-        );
-    }
-
     #[test]
     fn test_encode_utf16() {
         let result =
@@ -420,40 +388,13 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_encode_utf16be() {
-        let result =
-            eval_encode_scalar(ScalarValue::Utf8(Some("AB".into())), "UTF-16BE").unwrap();
-        assert_eq!(expect_binary_scalar(result), vec![0x00, 0x41, 0x00, 0x42]);
-    }
-
     #[test]
     fn test_encode_utf16le() {
         let result =
             eval_encode_scalar(ScalarValue::Utf8(Some("AB".into())), "UTF-16LE").unwrap();
         assert_eq!(expect_binary_scalar(result), vec![0x41, 0x00, 0x42, 0x00]);
     }
 
-    #[test]
-    fn test_encode_case_insensitive_charset() {
-        let result =
-            eval_encode_scalar(ScalarValue::Utf8(Some("hello".into())), "utf-8").unwrap();
-        assert_eq!(expect_binary_scalar(result), b"hello");
-    }
-
-    #[test]
-    fn test_encode_unsupported_charset() {
-        let result =
-            eval_encode_scalar(ScalarValue::Utf8(Some("hello".into())), "EBCDIC");
-        assert!(result.is_err());
-        assert!(
-            result
-                .unwrap_err()
-                .to_string()
-                .contains("Unsupported charset")
-        );
-    }
-
     #[test]
     fn test_encode_ascii_unmappable_legacy_mode() {
         // Legacy mode: non-ASCII chars replaced with '?'
@@ -500,34 +441,6 @@ mod tests {
         assert!(result.unwrap_err().to_string().contains("cannot encode"));
     }
 
-    #[test]
-    fn test_encode_null_input() {
-        let func = SparkEncode::new();
-        let arr: ArrayRef =
-            Arc::new(StringArray::from(vec![Some("hello"), None, Some("world")]));
-        let result = func
-            .invoke_with_args(ScalarFunctionArgs {
-                args: vec![
-                    ColumnarValue::Array(arr),
-                    ColumnarValue::Scalar(ScalarValue::Utf8(Some("UTF-8".into()))),
-                ],
-                arg_fields: vec![
-                    Arc::new(Field::new("input", DataType::Utf8, true)),
-                    Arc::new(Field::new("charset", DataType::Utf8, false)),
-                ],
-                number_rows: 3,
-                return_field: Arc::new(Field::new("encode", DataType::Binary, true)),
-                config_options: Arc::new(ConfigOptions::default()),
-            })
-            .unwrap();
-
-        let arr = result.into_array(3).unwrap();
-        let binary = arr.as_any().downcast_ref::<BinaryArray>().unwrap();
-        assert_eq!(binary.value(0), b"hello");
-        assert!(binary.is_null(1));
-        assert_eq!(binary.value(2), b"world");
-    }
-
     #[test]
     fn test_encode_utf8view_column() {
         let func = SparkEncode::new();
@@ -579,7 +492,7 @@ mod tests {
     }
 
     #[test]
-    fn test_return_field_nullable() {
+    fn test_encode_return_field_nullable() {
         let func = SparkEncode::new();
 
         let nullable = func
@@ -606,18 +519,6 @@ mod tests {
         assert!(!non_nullable.is_nullable());
     }
 
-    #[test]
-    fn test_function_name() {
-        let func = SparkEncode::new();
-        assert_eq!(func.name(), "encode");
-    }
-
-    #[test]
-    fn test_udf_registration() {
-        let udf = ScalarUDF::from(SparkEncode::new());
-        assert_eq!(udf.name(), "encode");
-    }
-
     #[test]
     fn test_encode_large_binary_input() {
         let result = eval_encode_scalar(
@@ -671,17 +572,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_encode_utf32be() {
-        // 'A' = U+0041 → 00 00 00 41, 'B' = U+0042 → 00 00 00 42
-        let result =
-            eval_encode_scalar(ScalarValue::Utf8(Some("AB".into())), "UTF-32BE").unwrap();
-        assert_eq!(
-            expect_binary_scalar(result),
-            vec![0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x42]
-        );
-    }
-
     #[test]
     fn test_encode_utf32le() {
         // 'A' = U+0041 → 41 00 00 00, 'B' = U+0042 → 42 00 00 00

datafusion/sqllogictest/test_files/spark/string/encode.slt

@@ -15,13 +15,60 @@
 # specific language governing permissions and limitations
 # under the License.
 
-# This file was originally created by a porting script from:
-#   https://github.com/lakehq/sail/tree/43b6ed8221de5c4c4adbedbb267ae1351158b43c/crates/sail-spark-connect/tests/gold_data/function
-# This file is part of the implementation of the datafusion-spark function library.
-# For more information, please see:
-#   https://github.com/apache/datafusion/issues/15914
-
-## Original Query: SELECT encode('abc', 'utf-8');
-## PySpark 3.5.5 Result: {'encode(abc, utf-8)': bytearray(b'abc'), 'typeof(encode(abc, utf-8))': 'binary', 'typeof(abc)': 'string', 'typeof(utf-8)': 'string'}
-#query
-#SELECT encode('abc'::string, 'utf-8'::string);
+# UTF-8 encoding
+query ?
+SELECT encode('Spark SQL'::string, 'utf-8'::string);
+----
+537061726b2053514c
+
+# US-ASCII encoding
+query ?
+SELECT encode('Hello'::string, 'us-ascii'::string);
+----
+48656c6c6f
+
+# ISO-8859-1 encoding (ï = 0xEF in ISO-8859-1)
+query ?
+SELECT encode('naïve'::string, 'iso-8859-1'::string);
+----
+6e61ef7665
+
+# UTF-16BE encoding
+query ?
+SELECT encode('AB'::string, 'utf-16be'::string);
+----
+00410042
+
+# UTF-32BE encoding
+query ?
+SELECT encode('A'::string, 'utf-32be'::string);
+----
+00000041
+
+# Case-insensitive charset
+query ?
+SELECT encode('hello'::string, 'Utf-8'::string);
+----
+68656c6c6f
+
+# NULL input
+query ?
+SELECT encode(NULL::string, 'utf-8'::string);
+----
+NULL
+
+# Array input with NULLs
+query ?
+SELECT encode(s, 'utf-8'::string) FROM (VALUES ('hello'::string), (NULL::string), ('world'::string)) AS t(s);
+----
+68656c6c6f
+NULL
+776f726c64
+
+# Error: unsupported charset
+statement error Unsupported charset for encode
+SELECT encode('hello'::string, 'EBCDIC'::string);
+
+# Error: no arguments
+statement error 'encode' does not support zero arguments
+SELECT encode();