content: module Hydra.Sources.Test.Lib.Strings (stringPrimitiveTests) where
  
  import Hydra.Dsl.Tests
  
  
  stringPrimitiveTests :: TestGroup
  stringPrimitiveTests = TestGroup "hydra.lib.strings primitives" Nothing groups []
    where
      groups = [
        stringsCat,
        stringsCat2,
        stringsCharAt,
        stringsFromList,
        stringsIntercalate,
        stringsLength,
        stringsLines,
        stringsNull,
        stringsSplitOn,
        stringsToList,
        stringsToLower,
        stringsToUpper,
        stringsUnlines]
  
  stringsCat :: TestGroup
  stringsCat = TestGroup "cat" Nothing [] [
      test "basic concatenation" ["one", "two", "three"] "onetwothree",
      test "with empty strings" ["", "one", "", ""] "one",
      test "empty list" [] "",
      test "single string" ["hello"] "hello",
      test "many empty strings" ["", "", "", ""] "",
      test "unicode strings" ["ñ", "世", "🌍"] "ñ世🌍",
      test "special characters" ["\n", "\t", "\r"] "\n\t\r",
      test "numbers as strings" ["1", "2", "3"] "123",
      test "spaces" [" ", " ", " "] "   ",
      test "mixed content" ["Hello", " ", "World", "!"] "Hello World!"]
    where
      test name ls result = primCase name _strings_cat [list (string <$> ls)] (string result)
  
  stringsCat2 :: TestGroup
  stringsCat2 = TestGroup "cat2" Nothing [] [
      test "basic concatenation" "hello" "world" "helloworld",
      test "empty first string" "" "world" "world",
      test "empty second string" "hello" "" "hello",
      test "both empty strings" "" "" "",
      test "with spaces" "hello " "world" "hello world",
      test "unicode characters" "ñ" "世" "ñ世",
      test "numeric strings" "123" "456" "123456",
      test "special characters" "\n" "\t" "\n\t"]
    where
      test name s1 s2 result = primCase name _strings_cat2 [string s1, string s2] (string result)
  
  stringsCharAt :: TestGroup
  stringsCharAt = TestGroup "charAt" Nothing [] [
      test "first character" 0 "hello" 104,  -- 'h'
      test "middle character" 2 "hello" 108, -- 'l'
      test "last character" 4 "hello" 111,   -- 'o'
      test "single character string" 0 "a" 97,      -- 'a'
      test "unicode character" 0 "ñ" 241,    -- 'ñ'
      test "space character" 0 " " 32,       -- space
      test "newline character" 0 "\n" 10,    -- newline
      test "tab character" 0 "\t" 9]         -- tab
    where
      test name idx s result = primCase name _strings_charAt [int32 idx, string s] (int32 result)
  
  stringsFromList :: TestGroup
  stringsFromList = TestGroup "fromList" Nothing [] [
      test "basic ascii string" [104, 101, 108, 108, 111] "hello",
      test "empty code point list" [] "",
      test "single character" [97] "a",
      test "with spaces" [104, 32, 105] "h i",
      test "unicode characters" [241, 19990, 127757] "ñ世🌍",
      test "numeric characters" [49, 50, 51] "123",
      test "special characters" [10, 9, 13] "\n\t\r"]
    where
      test name codePoints result = primCase name _strings_fromList [list (int32 <$> codePoints)] (string result)
  
  stringsIntercalate :: TestGroup
  stringsIntercalate = TestGroup "intercalate" Nothing [] [
      test "comma separator" "," ["one", "two", "three"] "one,two,three",
      test "space separator" " " ["hello", "world"] "hello world",
      test "empty separator" "" ["a", "b", "c"] "abc",
      test "multi-character separator" " | " ["A", "B", "C"] "A | B | C",
      test "empty string list" "," [] "",
      test "single item list" "," ["only"] "only",
      test "empty strings in list" "," ["", "a", ""] ",a,",
      test "unicode separator" "🔗" ["link1", "link2"] "link1🔗link2"]
    where
      test name sep strs result = primCase name _strings_intercalate [string sep, list (string <$> strs)] (string result)
  
  stringsLength :: TestGroup
  stringsLength = TestGroup "length" Nothing [] [
      test "empty string" "" 0,
      test "single character" "a" 1,
      test "basic word" "one" 3,
      test "string with spaces" "hello world" 11,
      test "unicode characters" "ñ世🌍" 3,
      test "special characters" "\n\t\r" 3,
      test "numeric string" "12345" 5,
      test "long string" "this is a longer string for testing" 35]
    where
      test name s result = primCase name _strings_length [string s] (int32 result)
  
  stringsLines :: TestGroup
  stringsLines = TestGroup "lines" Nothing [] [
      test "single line" "hello world" ["hello world"],
      test "two lines" "hello\nworld" ["hello", "world"],
      test "three lines" "one\ntwo\nthree" ["one", "two", "three"],
      test "empty string" "" [],
      test "just newline" "\n" [""],
      test "trailing newline" "hello\n" ["hello"],
      test "leading newline" "\nhello" ["", "hello"],
      test "multiple consecutive newlines" "a\n\nb" ["a", "", "b"]]
    where
      test name s result = primCase name _strings_lines [string s] (list (string <$> result))
  
  stringsNull :: TestGroup
  stringsNull = TestGroup "null" Nothing [] [
      test "empty string" "" True,
      test "single character" "a" False,
      test "space only" " " False,
      test "basic word" "hello" False,
      test "newline only" "\n" False,
      test "tab only" "\t" False]
    where
      test name s result = primCase name _strings_null [string s] (boolean result)
  
  stringsSplitOn :: TestGroup
  stringsSplitOn = TestGroup "splitOn" Nothing [] [
      test "double s in Mississippi" "ss" "Mississippi" ["Mi", "i", "ippi"],
      test "whole string as separator" "Mississippi" "Mississippi" ["", ""],
      test "space separated words" " " "one two three" ["one", "two", "three"],
      test "leading and trailing spaces" " " " one two three " ["", "one", "two", "three", ""],
      test "multiple consecutive spaces" " " "  one two three" ["", "", "one", "two", "three"],
      test "double space separator" "  " "  one two three" ["", "one two three"],
      test "overlapping pattern aa in aaa" "aa" "aaa" ["", "a"],
      test "separator on empty string" "a" "" [""],
      test "empty separator on abc" "" "abc" ["", "a", "b", "c"],
      test "both separator and string empty" "" "" [""],
      test "separator not found" "x" "hello" ["hello"],
      test "separator at start" "h" "hello" ["", "ello"],
      test "separator at end" "o" "hello" ["hell", ""],
      test "multiple same separators" "l" "hello" ["he", "", "o"],
      test "single character string and separator" "a" "a" ["", ""],
      test "unicode separator" "世" "hello世world世!" ["hello", "world", "!"],
      test "multi-character separator" "ab" "cabbage" ["c", "bage"],
      test "newline separator" "\n" "line1\nline2\nline3" ["line1", "line2", "line3"]]
    where
      test name s0 s1 result = primCase name _strings_splitOn [string s0, string s1] (list (string <$> result))
  
  stringsToList :: TestGroup
  stringsToList = TestGroup "toList" Nothing [] [
      test "empty string" "" [],
      test "single character" "a" [97],
      test "basic word" "hello" [104, 101, 108, 108, 111],
      test "with space" "h i" [104, 32, 105],
      test "unicode characters" "ñ世🌍" [241, 19990, 127757],
      test "numeric string" "123" [49, 50, 51],
      test "special characters" "\n\t\r" [10, 9, 13]]
    where
      test name s result = primCase name _strings_toList [string s] (list (int32 <$> result))
  
  stringsToLower :: TestGroup
  stringsToLower = TestGroup "toLower" Nothing [] [
      test "mixed case sentence" "One TWO threE" "one two three",
      test "alphanumeric mixed case" "Abc123" "abc123",
      test "all uppercase" "HELLO" "hello",
      test "all lowercase" "hello" "hello",
      test "empty string" "" "",
      test "single uppercase char" "A" "a",
      test "single lowercase char" "a" "a",
      test "with spaces" "Hello World" "hello world",
      test "with punctuation" "Hello, World!" "hello, world!",
      test "unicode accented chars" "ÑÁÉÍÓÚ" "ñáéíóú",
      test "numbers only" "12345" "12345",
      test "special characters only" "\n\t\r" "\n\t\r"]
    where
      test name s result = primCase name _strings_toLower [string s] (string result)
  
  stringsToUpper :: TestGroup
  stringsToUpper = TestGroup "toUpper" Nothing [] [
      test "mixed case sentence" "One TWO threE" "ONE TWO THREE",
      test "alphanumeric mixed case" "Abc123" "ABC123",
      test "all lowercase" "hello" "HELLO",
      test "all uppercase" "HELLO" "HELLO",
      test "empty string" "" "",
      test "single lowercase char" "a" "A",
      test "single uppercase char" "A" "A",
      test "with spaces" "hello world" "HELLO WORLD",
      test "with punctuation" "hello, world!" "HELLO, WORLD!",
      test "unicode accented chars" "ñáéíóú" "ÑÁÉÍÓÚ",
      test "numbers only" "12345" "12345",
      test "special characters only" "\n\t\r" "\n\t\r"]
    where
      test name s result = primCase name _strings_toUpper [string s] (string result)
  
  stringsUnlines :: TestGroup
  stringsUnlines = TestGroup "unlines" Nothing [] [
      test "basic two lines" ["hello", "world"] "hello\nworld\n",
      test "single line" ["hello"] "hello\n",
      test "empty list" [] "",
      test "three lines" ["one", "two", "three"] "one\ntwo\nthree\n",
      test "with empty lines" ["hello", "", "world"] "hello\n\nworld\n",
      test "all empty lines" ["", "", ""] "\n\n\n",
      test "unicode content" ["ñoño", "世界"] "ñoño\n世界\n"]
    where
      test name strs result = primCase name _strings_unlines [list (string <$> strs)] (string result)
  