test: move tests to slt

Author: cht42

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

@@ -42,7 +42,6 @@ make_udf_function!(luhn_check::SparkLuhnCheck, luhn_check);
 make_udf_function!(format_string::FormatStringFunc, format_string);
 make_udf_function!(space::SparkSpace, space);
 make_udf_function!(substring::SparkSubstring, substring);
-make_udf_function!(substring::SparkSubstring, substr);
 
 pub mod expr_fn {
     use datafusion_functions::export_functions;

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

@@ -162,12 +162,12 @@ fn spark_substring(args: &[ArrayRef]) -> Result<ArrayRef> {
 /// Returns the converted 1-based start position for use with `get_true_start_end`.
 #[inline]
 fn spark_start_to_datafusion_start(start: i64, len: usize) -> i64 {
-    let start = if start >= 0 {
+    if start >= 0 {
         start.max(1)
     } else {
-        start + len as i64 + 1
-    };
-    start.max(1)
+        let start = start + len as i64 + 1;
+        start.max(1)
+    }
 }
 
 fn spark_substring_utf8<'a, O, V>(
@@ -282,244 +282,3 @@ fn spark_substring_view(
 
     Ok(Arc::new(builder.finish()) as ArrayRef)
 }
-
-#[cfg(test)]
-mod tests {
-    use arrow::array::{Array, LargeStringArray, StringArray, StringViewArray};
-    use arrow::datatypes::DataType::{self};
-
-    use datafusion_common::{Result, ScalarValue};
-    use datafusion_expr::{ColumnarValue, ScalarUDFImpl};
-
-    use crate::function::string::substring::SparkSubstring;
-    use crate::function::utils::test::test_scalar_function;
-
-    /// Test macro for substring(str, pos) - 2 argument version
-    macro_rules! test_substring_2 {
-        ($INPUT:expr, $POS:expr, $EXPECTED:expr) => {
-            test_scalar_function!(
-                SparkSubstring::new(),
-                vec![
-                    ColumnarValue::Scalar(ScalarValue::Utf8($INPUT)),
-                    ColumnarValue::Scalar(ScalarValue::Int64($POS))
-                ],
-                $EXPECTED,
-                &str,
-                DataType::Utf8,
-                StringArray
-            );
-
-            test_scalar_function!(
-                SparkSubstring::new(),
-                vec![
-                    ColumnarValue::Scalar(ScalarValue::LargeUtf8($INPUT)),
-                    ColumnarValue::Scalar(ScalarValue::Int64($POS))
-                ],
-                $EXPECTED,
-                &str,
-                DataType::LargeUtf8,
-                LargeStringArray
-            );
-
-            test_scalar_function!(
-                SparkSubstring::new(),
-                vec![
-                    ColumnarValue::Scalar(ScalarValue::Utf8View($INPUT)),
-                    ColumnarValue::Scalar(ScalarValue::Int64($POS))
-                ],
-                $EXPECTED,
-                &str,
-                DataType::Utf8View,
-                StringViewArray
-            );
-        };
-    }
-
-    /// Test macro for substring(str, pos, len) - 3 argument version
-    macro_rules! test_substring_3 {
-        ($INPUT:expr, $POS:expr, $LEN:expr, $EXPECTED:expr) => {
-            test_scalar_function!(
-                SparkSubstring::new(),
-                vec![
-                    ColumnarValue::Scalar(ScalarValue::Utf8($INPUT)),
-                    ColumnarValue::Scalar(ScalarValue::Int64($POS)),
-                    ColumnarValue::Scalar(ScalarValue::Int64($LEN))
-                ],
-                $EXPECTED,
-                &str,
-                DataType::Utf8,
-                StringArray
-            );
-
-            test_scalar_function!(
-                SparkSubstring::new(),
-                vec![
-                    ColumnarValue::Scalar(ScalarValue::LargeUtf8($INPUT)),
-                    ColumnarValue::Scalar(ScalarValue::Int64($POS)),
-                    ColumnarValue::Scalar(ScalarValue::Int64($LEN))
-                ],
-                $EXPECTED,
-                &str,
-                DataType::LargeUtf8,
-                LargeStringArray
-            );
-
-            test_scalar_function!(
-                SparkSubstring::new(),
-                vec![
-                    ColumnarValue::Scalar(ScalarValue::Utf8View($INPUT)),
-                    ColumnarValue::Scalar(ScalarValue::Int64($POS)),
-                    ColumnarValue::Scalar(ScalarValue::Int64($LEN))
-                ],
-                $EXPECTED,
-                &str,
-                DataType::Utf8View,
-                StringViewArray
-            );
-        };
-    }
-
-    #[test]
-    fn test_length_is_respected() -> Result<()> {
-        // substring("hello, world!", 2, 7) -> "ello, w"
-        test_substring_3!(
-            Some(String::from("hello, world!")),
-            Some(2),
-            Some(7),
-            Ok(Some("ello, w"))
-        );
-        // substring("short", 2, 7) -> "hort" (length exceeds remaining)
-        test_substring_3!(
-            Some(String::from("short")),
-            Some(2),
-            Some(7),
-            Ok(Some("hort"))
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn test_negative_start_with_length() -> Result<()> {
-        // substring("hello, world!", -5, 3) -> "orl"
-        // -5 + 13 = 8, so start at index 8 (0-indexed), take 3 chars
-        test_substring_3!(
-            Some(String::from("hello, world!")),
-            Some(-5),
-            Some(3),
-            Ok(Some("orl"))
-        );
-        // substring("short", -5, 3) -> "sho"
-        // -5 + 5 = 0, so start at index 0, take 3 chars
-        test_substring_3!(
-            Some(String::from("short")),
-            Some(-5),
-            Some(3),
-            Ok(Some("sho"))
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn test_negative_start_without_length() -> Result<()> {
-        // substring("hello, world!", -2) -> "d!"
-        // -2 + 13 = 11, so start at index 11 (0-indexed)
-        test_substring_2!(
-            Some(String::from("hello, world!")),
-            Some(-2),
-            Ok(Some("d!"))
-        );
-        // substring("short", -2) -> "rt"
-        // -2 + 5 = 3, so start at index 3
-        test_substring_2!(Some(String::from("short")), Some(-2), Ok(Some("rt")));
-        Ok(())
-    }
-
-    #[test]
-    fn test_null_start_returns_null() -> Result<()> {
-        test_substring_2!(Some(String::from("hello, world!")), None, Ok(None::<&str>));
-        Ok(())
-    }
-
-    #[test]
-    fn test_null_length_returns_null() -> Result<()> {
-        test_substring_3!(
-            Some(String::from("hello, world!")),
-            Some(1),
-            None,
-            Ok(None::<&str>)
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn test_null_expression_returns_null() -> Result<()> {
-        test_substring_3!(None::<String>, Some(2), Some(7), Ok(None::<&str>));
-        Ok(())
-    }
-
-    #[test]
-    fn test_negative_length_returns_empty_string() -> Result<()> {
-        // Spark returns empty string for negative length
-        test_substring_3!(
-            Some(String::from("hello, world!")),
-            Some(2),
-            Some(-2),
-            Ok(Some(""))
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn test_positive_positions() -> Result<()> {
-        // 1-indexed positions
-        test_substring_2!(
-            Some(String::from("alphabet")),
-            Some(1),
-            Ok(Some("alphabet"))
-        );
-        test_substring_2!(Some(String::from("alphabet")), Some(2), Ok(Some("lphabet")));
-        test_substring_2!(Some(String::from("alphabet")), Some(3), Ok(Some("phabet")));
-        test_substring_3!(
-            Some(String::from("alphabet")),
-            Some(3),
-            Some(2),
-            Ok(Some("ph"))
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn test_position_zero() -> Result<()> {
-        // Position 0 is treated as position 1 in Spark
-        test_substring_2!(
-            Some(String::from("alphabet")),
-            Some(0),
-            Ok(Some("alphabet"))
-        );
-        test_substring_3!(
-            Some(String::from("alphabet")),
-            Some(0),
-            Some(5),
-            Ok(Some("alpha"))
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn test_position_beyond_length() -> Result<()> {
-        test_substring_2!(Some(String::from("alphabet")), Some(30), Ok(Some("")));
-        Ok(())
-    }
-
-    #[test]
-    fn test_unicode_strings() -> Result<()> {
-        test_substring_2!(Some(String::from("joséésoj")), Some(5), Ok(Some("ésoj")));
-        test_substring_3!(
-            Some(String::from("joséésoj")),
-            Some(5),
-            Some(2),
-            Ok(Some("és"))
-        );
-        Ok(())
-    }
-}