053string.test

(test "len works on strings"
  :valueof (len "abcdefgh")
  :should be 8)

(test "strings work in function position"
  :valueof ("abcd" 2)
  :should be "c")

(test "strings can index final char"
  :valueof ("abcd" 3)
  :should be "d")

(test "strings can index past final char"
  :valueof ("abcd" 4)
  :should be_false)

(test "strings can take negative indices"
  :valueof ("abcd" -3)
  :should be "b")

(test "strings can take slices"
  :valueof ("abcd" 1 3)
  :should be "bc")

(test "strings can take slices - 2"
  :valueof ("abcd" 1 -1)
  :should be "bc")

(test "strings can take slices - explicit nil"
  :valueof ("abcd" 1 nil)
  :should be "bcd")

(test "strings can take slices - overflow"
  :valueof ("abcd" 1 10)
  :should be "bcd")

(test "string indices can be assigned to"
  :valueof (ret s "abc"
             (s.1 <- "z"))
  :should be "azc")

(test "string indices can be assigned to - 2"
  :valueof (ret s "abc"
             (s.-1 <- "z"))
  :should be "abz")

(test "string slices can be assigned to"
  :valueof (ret s "abcdefgh"
             ((s 1 5) <- "xy"))
  :should be "axyfgh")

(test "string slices can be assigned to - 2"
  :valueof (ret s "abcdefgh"
             ((s -4 -1) <- "xy"))
  :should be "abcdxyh")

(test "string slices can be assigned to - explicit nil"
  :valueof (ret s "abcdefgh"
             ((s -4 nil) <- "xy"))
  :should be "abcdxy")

(test "string slices can be assigned to - explicit nil var"
  :valueof (ret s "abcdefgh"
             (let x nil
               ((s -4 x) <- "xy")))
  :should be "abcdxy")

(test "string index can be reset"
  :valueof (ret l "abc"
             (l.1 <- nil))
  :should be "ac")

(test "each works on literal strings"
  :valueof (ret ans nil
             (each c "abc"
               (push! c ans)))
  :should be '("c" "b" "a"))

(test "each works on strings"
  :valueof (ret ans nil
             (let s "abc"
               (each c s
                 (push! c ans))))
  :should be '("c" "b" "a"))

(test "string works with multiple args"
  :valueof (string 'a 43)
  :should be "a43")

(test "string works with nil"
  :valueof string.nil
  :should be "")

(test "string coerces to list"
  :valueof (as list "abc")
  :should be '("a" "b" "c"))



(test "list coerces to string"
  :valueof (as string '("a" "b" "c"))
  :should be "abc")

(test "join works on strings"
  :valueof (join "a" 'b nil)
  :should be "ab")

(test "pos works on strings"
  :valueof (pos "ab" "abc")
  :should be 0)

(test "pos works on strings - 2"
  :valueof (pos "b" "abc")
  :should be 1)

(test "pos works on strings - 3"
  :valueof (pos "ba" "abc")
  :should be_false)



(test "< works on strings"
  :valueof ("a" < "b")
  :should be_true)

(test "< works on strings - 2"
  :valueof ("b" < "a")
  :should be_false)

(test "< works on strings - 3"
  :valueof ("a" < "a")
  :should be_false)

(test "< works on strings - 4"
  :valueof (< "a" "b" "c")
  :should be_true)

(test "< works on strings - 5"
  :valueof (< "a" "b" "a")
  :should be_false)

(test "< works on strings - 6"
  :valueof ("a" < "b" < "c")
  :should be_true)

(test "< works on strings - 7"
  :valueof ("a" < "b" < "a")
  :should be_false)

(test "> works on strings"
  :valueof ("a" > "b")
  :should be_false)

(test "> works on strings - 2"
  :valueof ("b" > "a")
  :should be_true)

(test "> works on strings - 3"
  :valueof (> "c" "b" "d")
  :should be_false)

(test "> works on strings - 4"
  :valueof (> "c" "b" "a")
  :should be_true)

(test "> works on strings - 5"
  :valueof (> "a" "b" "a")
  :should be_false)

(test "> works on strings - 6"
  :valueof ("a" > "a")
  :should be_false)

(test "> works on strings - 7"
  :valueof (> "c" "b" "a")
  :should be_true)

(test "> works on strings - 8"
  :valueof (> "c" "b" "c")
  :should be_false)

(test "> works on strings - 9"
  :valueof ("c" > "b" > "a")
  :should be_true)

(test "> works on strings - 7"
  :valueof ("c" > "b" > "c")
  :should be_false)

(test "<= works on strings"
  :valueof ("a" <= "b")
  :should be_true)

(test "<= works on strings - 2"
  :valueof ("b" <= "a")
  :should be_false)

(test "<= works on strings - 3"
  :valueof ("a" <= "a")
  :should be_true)

(test "<= works on strings - 4"
  :valueof (nil <= "a")
  :should be_false)

(test "<= works on strings - 5"
  :valueof ("z" <= nil)
  :should be_false)

(test ">= works on strings"
  :valueof ("a" >= "b")
  :should be_false)

(test ">= works on strings - 2"
  :valueof ("b" >= "a")
  :should be_true)

(test ">= works on strings - 4"
  :valueof ("a" >= "a")
  :should be_true)

(test "range checks work on strings"
  :valueof ("a" <= "a" <= "b")
  :should be_true)

(test "range checks work on strings - 2"
  :valueof ("c" >= "b" > "b")
  :should be_false)