Author: koutou
Date: Sat Mar 21 20:44:45 2009
New Revision: 5907
Modified:
trunk/test/test-uim-util.scm
trunk/test/util/test-string.scm
Log:
* test/test-uim-util.scm: move string related tests to ...
* test/util/test-string.scm: ... here.
Modified: trunk/test/test-uim-util.scm
==============================================================================
--- trunk/test/test-uim-util.scm (original)
+++ trunk/test/test-uim-util.scm Sat Mar 21 20:44:45 2009
@@ -41,177 +41,6 @@
(uim '(require "util.scm"))
(uim '(define lst '(1 2 3 4)))))
- ;; See "Specification changes of utility procedures" of doc/COMPATIBILITY
-;; ("test string-split (uim 1.4)"
-;; ;; ordinary split
-;; (assert-equal '("h" "geh" "ge")
-;; (uim '(string-split "hogehoge" "o")))
-;; ;; case sensitive
-;; (assert-equal '("hogehoge")
-;; (uim '(string-split "hogehoge" "O")))
-;; ;; split by sequence
-;; (assert-equal '("h" "eh" "e")
-;; (uim '(string-split "hogehoge" "og")))
-;; ;; split by first character
-;; (assert-equal '("oge" "oge")
-;; (uim '(string-split "hogehoge" "h")))
-;; ;; split by first sequence
-;; (assert-equal '("ge" "ge")
-;; (uim '(string-split "hogehoge" "ho")))
-;; ;; split by last character
-;; (assert-equal '("hog" "hog")
-;; (uim '(string-split "hogehoge" "e")))
-;; ;; split by last sequence
-;; (assert-equal '("ho" "ho")
-;; (uim '(string-split "hogehoge" "ge")))
-;; ;; split by whole string
-;; (assert-equal ()
-;; (uim '(string-split "hogehoge" "hogehoge")))
-;; ;; repeated splitter
-;; (assert-equal ()
-;; (uim '(string-split "hhh" "h")))
-;; ;; split by space
-;; (assert-equal '("h" "o" "g" "e" "hoge")
-;; (uim '(string-split " h o g e hoge" " ")))
-;; ;; split by symbolic character
-;; (assert-equal '("h" "o" "g" "e" "hoge")
-;; (uim '(string-split "|h|o|g|e|hoge" "|")))
-;; ;; split by non existent character
-;; (assert-equal '("hogehoge")
-;; (uim '(string-split "hogehoge" "|"))))
-
- ;; See "Specification changes of utility procedures" of doc/COMPATIBILITY
- ("test string-split (uim 1.5)"
- ;; ordinary split
- (assert-equal '("h" "geh" "ge")
- (uim '(string-split "hogehoge" "o")))
- ;; case sensitive
- (assert-equal '("hogehoge")
- (uim '(string-split "hogehoge" "O")))
- ;; split by sequence
- (assert-equal '("h" "eh" "e")
- (uim '(string-split "hogehoge" "og")))
- ;; split by first character
- (assert-equal '("" "oge" "oge")
- (uim '(string-split "hogehoge" "h")))
- ;; split by first sequence
- (assert-equal '("" "ge" "ge")
- (uim '(string-split "hogehoge" "ho")))
- ;; split by last character
- (assert-equal '("hog" "hog" "")
- (uim '(string-split "hogehoge" "e")))
- ;; split by last sequence
- (assert-equal '("ho" "ho" "")
- (uim '(string-split "hogehoge" "ge")))
- ;; split by whole string
- (assert-equal '("" "")
- (uim '(string-split "hogehoge" "hogehoge")))
- ;; repeated splitter
- (assert-equal '("" "" "" "")
- (uim '(string-split "hhh" "h")))
- ;; split by space
- (assert-equal '("" "h" "o" "g" "e" "hoge")
- (uim '(string-split " h o g e hoge" " ")))
- ;; split by symbolic character
- (assert-equal '("" "h" "o" "g" "e" "hoge")
- (uim '(string-split "|h|o|g|e|hoge" "|")))
- ;; split by non existent character
- (assert-equal '("hogehoge")
- (uim '(string-split "hogehoge" "|"))))
-
- ;; split EUC-JP string into reversed character list
- ("test string-to-list"
- (assert-equal '()
- (uim '(string-to-list "")))
- (assert-equal '("s")
- (uim '(string-to-list "s")))
- (assert-equal '("t" "s")
- (uim '(string-to-list "st")))
- (assert-equal '("g" "n" "i" "r" "t" "s")
- (uim '(string-to-list "string")))
- ;; TODO: activate following EUC-JP string test
-; (assert-equal '("あ")
-; (uim '(string-to-list "あ")))
-; (assert-equal '("あ" "a")
-; (uim '(string-to-list "aあ")))
-; (assert-equal '("a" "あ")
-; (uim '(string-to-list "あa")))
-; (assert-equal '("語" "本" "日")
-; (uim '(string-to-list "日本語")))
-; (assert-equal '("c" "語" "本" "b" "日" "a")
-; (uim '(string-to-list "a日b本語c")))
- )
-
- ("test string-contains"
- (assert-equal 0 (uim '(string-contains "" "" 0)))
- (assert-false (uim '(string-contains "" "f" 0)))
- (assert-equal 0 (uim '(string-contains "foo" "" 0)))
- (assert-equal 0 (uim '(string-contains "foo" "f" 0)))
- (assert-equal 1 (uim '(string-contains "foo" "o" 0)))
- (assert-equal 1 (uim '(string-contains "foo" "oo" 0)))
- (assert-false (uim '(string-contains "foo" "oof" 0)))
- (assert-equal 1 (uim '(string-contains "foo" "o" 1)))
- (assert-equal 2 (uim '(string-contains "foo" "o" 2))))
-
- ("test string-prefix?"
- (assert-true (uim-bool '(string-prefix? "" "foo_bar")))
- (assert-true (uim-bool '(string-prefix? "f" "foo_bar")))
- (assert-true (uim-bool '(string-prefix? "fo" "foo_bar")))
- (assert-true (uim-bool '(string-prefix? "foo" "foo_bar")))
- (assert-true (uim-bool '(string-prefix? "foo_" "foo_bar")))
- (assert-true (uim-bool '(string-prefix? "foo_b" "foo_bar")))
- (assert-true (uim-bool '(string-prefix? "foo_ba" "foo_bar")))
- (assert-true (uim-bool '(string-prefix? "foo_bar" "foo_bar")))
- (assert-false (uim-bool '(string-prefix? "foo_bar_" "foo_bar")))
- (assert-error (lambda () (uim-bool '(string-prefix?
#f "foo_bar"))))
- (assert-error (lambda () (uim-bool '(string-prefix? "foo_bar" #f))))
- (assert-false (uim-bool '(string-prefix? "Foo" "foo_bar")))
- (assert-false (uim-bool '(string-prefix? "oo_" "foo_bar")))
- (assert-false (uim-bool '(string-prefix? "bar" "foo_bar")))
-
- (assert-true (uim-bool '(string-prefix? "" "")))
- (assert-false (uim-bool '(string-prefix? "foo" "")))
- (assert-error (lambda () (uim-bool '(string-prefix? #f ""))))
- (assert-error (lambda () (uim-bool '(string-prefix? "" #f)))))
-
- ("test string-prefix-ci?"
- (assert-true (uim-bool '(string-prefix-ci? "" "foo_bar")))
- (assert-true (uim-bool '(string-prefix-ci? "f" "foo_bar")))
- (assert-true (uim-bool '(string-prefix-ci? "fo" "foo_bar")))
- (assert-true (uim-bool '(string-prefix-ci? "foo" "foo_bar")))
- (assert-true (uim-bool '(string-prefix-ci? "foo_" "foo_bar")))
- (assert-true (uim-bool '(string-prefix-ci? "foo_b" "foo_bar")))
- (assert-true (uim-bool '(string-prefix-ci? "foo_ba" "foo_bar")))
- (assert-true (uim-bool '(string-prefix-ci? "foo_bar" "foo_bar")))
- (assert-false (uim-bool '(string-prefix-ci? "foo_bar_" "foo_bar")))
- (assert-error (lambda () (uim-bool '(string-prefix-ci?
#f "foo_bar"))))
- (assert-error (lambda () (uim-bool '(string-prefix-ci? "foo_bar" #f))))
- (assert-true (uim-bool '(string-prefix-ci? "Foo" "foo_bar")))
- (assert-true (uim-bool '(string-prefix-ci? "fOo" "foo_bar")))
- (assert-true (uim-bool '(string-prefix-ci? "fOO" "foo_bar")))
- (assert-true (uim-bool '(string-prefix-ci? "FOO" "foo_bar")))
- (assert-true (uim-bool '(string-prefix-ci? "FOO_bar" "foo_bar")))
- (assert-false (uim-bool '(string-prefix-ci? "oo_" "foo_bar")))
- (assert-false (uim-bool '(string-prefix-ci? "bar" "foo_bar")))
-
- (assert-true (uim-bool '(string-prefix-ci? "" "")))
- (assert-false (uim-bool '(string-prefix-ci? "foo" "")))
- (assert-error (lambda () (uim-bool '(string-prefix-ci? #f ""))))
- (assert-error (lambda () (uim-bool '(string-prefix-ci? "" #f)))))
-
- ("test string=?"
- (assert-true (uim-bool '(string=? "foo1" "foo1")))
- (assert-true (uim-bool '(string=? "Foo1" "Foo1")))
- (assert-true (uim-bool '(string=? "FOO1" "FOO1")))
- (assert-true (uim-bool '(string=? "1foo" "1foo")))
- (assert-true (uim-bool '(string=? "1Foo" "1Foo")))
- (assert-true (uim-bool '(string=? "1FOO" "1FOO")))
- (assert-true (uim-bool '(string=? "" "")))
- (assert-false (uim-bool '(string=? "foo1" "")))
- (assert-false (uim-bool '(string=? "" "foo1")))
- (assert-false (uim-bool '(string=? "foo1" "Foo1")))
- (assert-false (uim-bool '(string=? "Foo1" "foo1"))))
-
("test nthcdr"
(assert-equal '(1 2 3 4)
(uim '(nthcdr 0 lst)))
@@ -224,131 +53,7 @@
(assert-equal ()
(uim '(nthcdr 4 lst)))
(assert-equal #f
- (uim '(nthcdr 5 lst))))
-
- ("test charcode->string"
- (assert-equal "" (uim '(charcode->string 'return)))
- (assert-equal "" (uim '(charcode->string 0)))
- (assert-equal "\n" (uim '(charcode->string 10)))
- (assert-equal "\r" (uim '(charcode->string 13)))
- (assert-equal " " (uim '(charcode->string 32)))
- (assert-equal "!" (uim '(charcode->string 33)))
- (assert-equal "/" (uim '(charcode->string 47)))
- (assert-equal "0" (uim '(charcode->string 48)))
- (assert-equal "9" (uim '(charcode->string 57)))
- (assert-equal ":" (uim '(charcode->string 58)))
- (assert-equal "@" (uim '(charcode->string 64)))
- (assert-equal "A" (uim '(charcode->string 65)))
- (assert-equal "Z" (uim '(charcode->string 90)))
- (assert-equal "[" (uim '(charcode->string 91)))
- (assert-equal "\\" (uim '(charcode->string 92)))
- (assert-equal "`" (uim '(charcode->string 96)))
- (assert-equal "a" (uim '(charcode->string 97)))
- (assert-equal "z" (uim '(charcode->string 122)))
- (assert-equal "{" (uim '(charcode->string 123)))
- (assert-equal "~" (uim '(charcode->string 126))))
-
- ("test string->charcode"
- (assert-equal 0 (uim '(string->charcode "")))
- (assert-equal 10 (uim '(string->charcode "\n")))
- (assert-equal 13 (uim '(string->charcode "\r")))
- (assert-equal 32 (uim '(string->charcode " ")))
- (assert-equal 33 (uim '(string->charcode "!")))
- (assert-equal 47 (uim '(string->charcode "/")))
- (assert-equal 48 (uim '(string->charcode "0")))
- (assert-equal 57 (uim '(string->charcode "9")))
- (assert-equal 58 (uim '(string->charcode ":")))
- (assert-equal 64 (uim '(string->charcode "@")))
- (assert-equal 65 (uim '(string->charcode "A")))
- (assert-equal 90 (uim '(string->charcode "Z")))
- (assert-equal 91 (uim '(string->charcode "[")))
- (assert-equal 92 (uim '(string->charcode "\\")))
- (assert-equal 96 (uim '(string->charcode "`")))
- (assert-equal 97 (uim '(string->charcode "a")))
- (assert-equal 122 (uim '(string->charcode "z")))
- (assert-equal 123 (uim '(string->charcode "{")))
- (assert-equal 126 (uim '(string->charcode "~"))))
-
- ("test digit->string"
- ;; for storage-fa...@32-bit
- ;;(assert-equal "-2147483648" (uim '(digit->string -2147483648)))
- ;; for storage-comp...@32-bit
- (assert-equal "-134217728" (uim '(digit->string -134217728)))
- (assert-equal "-10" (uim '(digit->string -10)))
- (assert-equal "-2" (uim '(digit->string -2)))
- (assert-equal "-1" (uim '(digit->string -1)))
- (assert-equal "0" (uim '(digit->string 0)))
- (assert-equal "1" (uim '(digit->string 1)))
- (assert-equal "2" (uim '(digit->string 2)))
- (assert-equal "3" (uim '(digit->string 3)))
- (assert-equal "4" (uim '(digit->string 4)))
- (assert-equal "5" (uim '(digit->string 5)))
- (assert-equal "6" (uim '(digit->string 6)))
- (assert-equal "7" (uim '(digit->string 7)))
- (assert-equal "8" (uim '(digit->string 8)))
- (assert-equal "9" (uim '(digit->string 9)))
- (assert-equal "10" (uim '(digit->string 10)))
- (assert-equal "11" (uim '(digit->string 11)))
- (assert-equal "12" (uim '(digit->string 12)))
- (assert-equal "13" (uim '(digit->string 13)))
- (assert-equal "14" (uim '(digit->string 14)))
- (assert-equal "15" (uim '(digit->string 15)))
- (assert-equal "16" (uim '(digit->string 16)))
- (assert-equal "17" (uim '(digit->string 17)))
- (assert-equal "18" (uim '(digit->string 18)))
- (assert-equal "19" (uim '(digit->string 19)))
- (assert-equal "100" (uim '(digit->string 100)))
- (assert-equal "1000" (uim '(digit->string 1000)))
- ;; for storage-fa...@32-bit
- ;;(assert-equal "2147483647" (uim '(digit->string 2147483647)))
- ;; for storage-comp...@32-bit
- (assert-equal "134217727" (uim '(digit->string 134217727)))
- )
-
- ;; compare string sequence
- ("test str-seq-equal?"
- (assert-true (uim-bool '(str-seq-equal? () ())))
- (assert-true (uim-bool '(str-seq-equal? '("") '(""))))
- (assert-false (uim-bool '(str-seq-equal? () '(""))))
- (assert-false (uim-bool '(str-seq-equal? '("") ())))
- (assert-true (uim-bool '(str-seq-equal? '("a") '("a"))))
- (assert-false (uim-bool '(str-seq-equal? '("a") '("A"))))
- (assert-false (uim-bool '(str-seq-equal? '("a") '("b"))))
- (assert-true (uim-bool '(str-seq-equal? '("a" "b" "c")
- '("a" "b" "c"))))
- (assert-false (uim-bool '(str-seq-equal? '("a" "b" "c")
- '("a" "b" "c" "d"))))
- (assert-false (uim-bool '(str-seq-equal? '("a" "b" "c")
- '("z" "a" "b" "c"))))
- (assert-false (uim-bool '(str-seq-equal? '("a" "b" "c" "d")
- '("a" "b" "c")))))
-
- ;; Partial -> first string of remaining sequence
- ;; eg. ("a" "b") ("a" "b" "c") -> "c"
- ;; Not partial -> #f
- ("test str-seq-partial?"
- (assert-false (uim-bool '(str-seq-partial? () ())))
- (assert-false (uim-bool '(str-seq-partial? '("") '(""))))
- (assert-equal ""
- (uim '(str-seq-partial? () '(""))))
- (assert-false (uim-bool '(str-seq-partial? '("") ())))
- (assert-false (uim-bool '(str-seq-partial? '("a") '("a"))))
- (assert-false (uim-bool '(str-seq-partial? '("a") '("A"))))
- (assert-false (uim-bool '(str-seq-partial? '("a") '("b"))))
- (assert-equal "b"
- (uim '(str-seq-partial? '("a")
- '("a" "b"))))
- (assert-false (uim-bool '(str-seq-partial? '("a" "b" "c")
- '("a" "b" "c"))))
- (assert-equal "d"
- (uim '(str-seq-partial? '("a" "b" "c")
- '("a" "b" "c" "d"))))
- (assert-equal "d"
- (uim '(str-seq-partial? '("a" "b" "c")
- '("a" "b" "c" "d" "e"))))
- (assert-false (uim-bool '(str-seq-partial? '("a" "b" "c" "d")
- '("a" "b" "c"))))))
-
+ (uim '(nthcdr 5 lst)))))
;; this test assumes that string encoding of Gauche is configured as
;; UTF-8
Modified: trunk/test/util/test-string.scm
==============================================================================
--- trunk/test/util/test-string.scm (original)
+++ trunk/test/util/test-string.scm Sat Mar 21 20:44:45 2009
@@ -74,4 +74,310 @@
(assert-uim-false '(string-find '("foo" "bar" "baz") "quux"))
#f)
+;; See "Specification changes of utility procedures" of doc/COMPATIBILITY
+(define (no-test-string-split-uim-1.4)
+ ;; ordinary split
+ (assert-uim-equal '("h" "geh" "ge")
+ '(string-split "hogehoge" "o"))
+ ;; case sensitive
+ (assert-uim-equal '("hogehoge")
+ '(string-split "hogehoge" "O"))
+ ;; split by sequence
+ (assert-uim-equal '("h" "eh" "e")
+ '(string-split "hogehoge" "og"))
+ ;; split by first character
+ (assert-uim-equal '("oge" "oge")
+ '(string-split "hogehoge" "h"))
+ ;; split by first sequence
+ (assert-uim-equal '("ge" "ge")
+ '(string-split "hogehoge" "ho"))
+ ;; split by last character
+ (assert-uim-equal '("hog" "hog")
+ '(string-split "hogehoge" "e"))
+ ;; split by last sequence
+ (assert-uim-equal '("ho" "ho")
+ '(string-split "hogehoge" "ge"))
+ ;; split by whole string
+ (assert-uim-equal ()
+ '(string-split "hogehoge" "hogehoge"))
+ ;; repeated splitter
+ (assert-uim-equal ()
+ '(string-split "hhh" "h"))
+ ;; split by space
+ (assert-uim-equal '("h" "o" "g" "e" "hoge")
+ '(string-split " h o g e hoge" " "))
+ ;; split by symbolic character
+ (assert-uim-equal '("h" "o" "g" "e" "hoge")
+ '(string-split "|h|o|g|e|hoge" "|"))
+ ;; split by non existent character
+ (assert-uim-equal '("hogehoge")
+ '(string-split "hogehoge" "|"))
+ #f)
+
+;; See "Specification changes of utility procedures" of doc/COMPATIBILITY
+(define (test-string-split-uim-1.5)
+ ;; ordinary split
+ (assert-uim-equal '("h" "geh" "ge")
+ '(string-split "hogehoge" "o"))
+ ;; case sensitive
+ (assert-uim-equal '("hogehoge")
+ '(string-split "hogehoge" "O"))
+ ;; split by sequence
+ (assert-uim-equal '("h" "eh" "e")
+ '(string-split "hogehoge" "og"))
+ ;; split by first character
+ (assert-uim-equal '("" "oge" "oge")
+ '(string-split "hogehoge" "h"))
+ ;; split by first sequence
+ (assert-uim-equal '("" "ge" "ge")
+ '(string-split "hogehoge" "ho"))
+ ;; split by last character
+ (assert-uim-equal '("hog" "hog" "")
+ '(string-split "hogehoge" "e"))
+ ;; split by last sequence
+ (assert-uim-equal '("ho" "ho" "")
+ '(string-split "hogehoge" "ge"))
+ ;; split by whole string
+ (assert-uim-equal '("" "")
+ '(string-split "hogehoge" "hogehoge"))
+ ;; repeated splitter
+ (assert-uim-equal '("" "" "" "")
+ '(string-split "hhh" "h"))
+ ;; split by space
+ (assert-uim-equal '("" "h" "o" "g" "e" "hoge")
+ '(string-split " h o g e hoge" " "))
+ ;; split by symbolic character
+ (assert-uim-equal '("" "h" "o" "g" "e" "hoge")
+ '(string-split "|h|o|g|e|hoge" "|"))
+ ;; split by non existent character
+ (assert-uim-equal '("hogehoge")
+ '(string-split "hogehoge" "|"))
+ #f)
+
+;; split EUC-JP string into reversed character list
+(define (test-string-to-list)
+ (assert-uim-equal '()
+ '(string-to-list ""))
+ (assert-uim-equal '("s")
+ '(string-to-list "s"))
+ (assert-uim-equal '("t" "s")
+ '(string-to-list "st"))
+ (assert-uim-equal '("g" "n" "i" "r" "t" "s")
+ '(string-to-list "string"))
+ ;; TODO: activate following EUC-JP string test
+;; (assert-uim-equal '("あ")
+;; '(string-to-list "あ"))
+;; (assert-uim-equal '("あ" "a")
+;; '(string-to-list "aあ"))
+;; (assert-uim-equal '("a" "あ")
+;; '(string-to-list "あa"))
+;; (assert-uim-equal '("語" "本" "日")
+;; '(string-to-list "日本語"))
+;; (assert-uim-equal '("c" "語" "本" "b" "日" "a")
+;; '(string-to-list "a日b本語c"))
+ #f)
+
+(define (test-string-contains)
+ (assert-uim-equal 0 '(string-contains "" "" 0))
+ (assert-uim-false '(string-contains "" "f" 0))
+ (assert-uim-equal 0 '(string-contains "foo" "" 0))
+ (assert-uim-equal 0 '(string-contains "foo" "f" 0))
+ (assert-uim-equal 1 '(string-contains "foo" "o" 0))
+ (assert-uim-equal 1 '(string-contains "foo" "oo" 0))
+ (assert-uim-false '(string-contains "foo" "oof" 0))
+ (assert-uim-equal 1 '(string-contains "foo" "o" 1))
+ (assert-uim-equal 2 '(string-contains "foo" "o" 2))
+ #f)
+
+(define (test-string-prefix?)
+ (assert-uim-true '(string-prefix? "" "foo_bar"))
+ (assert-uim-true '(string-prefix? "f" "foo_bar"))
+ (assert-uim-true '(string-prefix? "fo" "foo_bar"))
+ (assert-uim-true '(string-prefix? "foo" "foo_bar"))
+ (assert-uim-true '(string-prefix? "foo_" "foo_bar"))
+ (assert-uim-true '(string-prefix? "foo_b" "foo_bar"))
+ (assert-uim-true '(string-prefix? "foo_ba" "foo_bar"))
+ (assert-uim-true '(string-prefix? "foo_bar" "foo_bar"))
+ (assert-uim-false '(string-prefix? "foo_bar_" "foo_bar"))
+ (assert-uim-error '(string-prefix? #f "foo_bar"))
+ (assert-uim-error '(string-prefix? "foo_bar" #f))
+ (assert-uim-false '(string-prefix? "Foo" "foo_bar"))
+ (assert-uim-false '(string-prefix? "oo_" "foo_bar"))
+ (assert-uim-false '(string-prefix? "bar" "foo_bar"))
+
+ (assert-uim-true '(string-prefix? "" ""))
+ (assert-uim-false '(string-prefix? "foo" ""))
+ (assert-uim-error '(string-prefix? #f ""))
+ (assert-uim-error '(string-prefix? "" #f))
+ #f)
+
+(define (test-string-prefix-ci?)
+ (assert-uim-true '(string-prefix-ci? "" "foo_bar"))
+ (assert-uim-true '(string-prefix-ci? "f" "foo_bar"))
+ (assert-uim-true '(string-prefix-ci? "fo" "foo_bar"))
+ (assert-uim-true '(string-prefix-ci? "foo" "foo_bar"))
+ (assert-uim-true '(string-prefix-ci? "foo_" "foo_bar"))
+ (assert-uim-true '(string-prefix-ci? "foo_b" "foo_bar"))
+ (assert-uim-true '(string-prefix-ci? "foo_ba" "foo_bar"))
+ (assert-uim-true '(string-prefix-ci? "foo_bar" "foo_bar"))
+ (assert-uim-false '(string-prefix-ci? "foo_bar_" "foo_bar"))
+ (assert-uim-error '(string-prefix-ci? #f "foo_bar"))
+ (assert-uim-error '(string-prefix-ci? "foo_bar" #f))
+ (assert-uim-true '(string-prefix-ci? "Foo" "foo_bar"))
+ (assert-uim-true '(string-prefix-ci? "fOo" "foo_bar"))
+ (assert-uim-true '(string-prefix-ci? "fOO" "foo_bar"))
+ (assert-uim-true '(string-prefix-ci? "FOO" "foo_bar"))
+ (assert-uim-true '(string-prefix-ci? "FOO_bar" "foo_bar"))
+ (assert-uim-false '(string-prefix-ci? "oo_" "foo_bar"))
+ (assert-uim-false '(string-prefix-ci? "bar" "foo_bar"))
+
+ (assert-uim-true '(string-prefix-ci? "" ""))
+ (assert-uim-false '(string-prefix-ci? "foo" ""))
+ (assert-uim-error '(string-prefix-ci? #f ""))
+ (assert-uim-error '(string-prefix-ci? "" #f))
+ #f)
+
+(define (test-string=?)
+ (assert-uim-true '(string=? "foo1" "foo1"))
+ (assert-uim-true '(string=? "Foo1" "Foo1"))
+ (assert-uim-true '(string=? "FOO1" "FOO1"))
+ (assert-uim-true '(string=? "1foo" "1foo"))
+ (assert-uim-true '(string=? "1Foo" "1Foo"))
+ (assert-uim-true '(string=? "1FOO" "1FOO"))
+ (assert-uim-true '(string=? "" ""))
+ (assert-uim-false '(string=? "foo1" ""))
+ (assert-uim-false '(string=? "" "foo1"))
+ (assert-uim-false '(string=? "foo1" "Foo1"))
+ (assert-uim-false '(string=? "Foo1" "foo1"))
+ #f)
+
+(define (test-charcode->string)
+ (assert-uim-equal "" '(charcode->string 'return))
+ (assert-uim-equal "" '(charcode->string 0))
+ (assert-uim-equal "\n" '(charcode->string 10))
+ (assert-uim-equal "\r" '(charcode->string 13))
+ (assert-uim-equal " " '(charcode->string 32))
+ (assert-uim-equal "!" '(charcode->string 33))
+ (assert-uim-equal "/" '(charcode->string 47))
+ (assert-uim-equal "0" '(charcode->string 48))
+ (assert-uim-equal "9" '(charcode->string 57))
+ (assert-uim-equal ":" '(charcode->string 58))
+ (assert-uim-equal "@" '(charcode->string 64))
+ (assert-uim-equal "A" '(charcode->string 65))
+ (assert-uim-equal "Z" '(charcode->string 90))
+ (assert-uim-equal "[" '(charcode->string 91))
+ (assert-uim-equal "\\" '(charcode->string 92))
+ (assert-uim-equal "`" '(charcode->string 96))
+ (assert-uim-equal "a" '(charcode->string 97))
+ (assert-uim-equal "z" '(charcode->string 122))
+ (assert-uim-equal "{" '(charcode->string 123))
+ (assert-uim-equal "~" '(charcode->string 126))
+ #f)
+
+(define (test-string->charcode)
+ (assert-uim-equal 0 '(string->charcode ""))
+ (assert-uim-equal 10 '(string->charcode "\n"))
+ (assert-uim-equal 13 '(string->charcode "\r"))
+ (assert-uim-equal 32 '(string->charcode " "))
+ (assert-uim-equal 33 '(string->charcode "!"))
+ (assert-uim-equal 47 '(string->charcode "/"))
+ (assert-uim-equal 48 '(string->charcode "0"))
+ (assert-uim-equal 57 '(string->charcode "9"))
+ (assert-uim-equal 58 '(string->charcode ":"))
+ (assert-uim-equal 64 '(string->charcode "@"))
+ (assert-uim-equal 65 '(string->charcode "A"))
+ (assert-uim-equal 90 '(string->charcode "Z"))
+ (assert-uim-equal 91 '(string->charcode "["))
+ (assert-uim-equal 92 '(string->charcode "\\"))
+ (assert-uim-equal 96 '(string->charcode "`"))
+ (assert-uim-equal 97 '(string->charcode "a"))
+ (assert-uim-equal 122 '(string->charcode "z"))
+ (assert-uim-equal 123 '(string->charcode "{"))
+ (assert-uim-equal 126 '(string->charcode "~"))
+ #f)
+
+(define (test-digit->string)
+ ;; for storage-fa...@32-bit
+ ;;(assert-uim-equal "-2147483648" '(digit->string -2147483648))
+ ;; for storage-comp...@32-bit
+ (assert-uim-equal "-134217728" '(digit->string -134217728))
+ (assert-uim-equal "-10" '(digit->string -10))
+ (assert-uim-equal "-2" '(digit->string -2))
+ (assert-uim-equal "-1" '(digit->string -1))
+ (assert-uim-equal "0" '(digit->string 0))
+ (assert-uim-equal "1" '(digit->string 1))
+ (assert-uim-equal "2" '(digit->string 2))
+ (assert-uim-equal "3" '(digit->string 3))
+ (assert-uim-equal "4" '(digit->string 4))
+ (assert-uim-equal "5" '(digit->string 5))
+ (assert-uim-equal "6" '(digit->string 6))
+ (assert-uim-equal "7" '(digit->string 7))
+ (assert-uim-equal "8" '(digit->string 8))
+ (assert-uim-equal "9" '(digit->string 9))
+ (assert-uim-equal "10" '(digit->string 10))
+ (assert-uim-equal "11" '(digit->string 11))
+ (assert-uim-equal "12" '(digit->string 12))
+ (assert-uim-equal "13" '(digit->string 13))
+ (assert-uim-equal "14" '(digit->string 14))
+ (assert-uim-equal "15" '(digit->string 15))
+ (assert-uim-equal "16" '(digit->string 16))
+ (assert-uim-equal "17" '(digit->string 17))
+ (assert-uim-equal "18" '(digit->string 18))
+ (assert-uim-equal "19" '(digit->string 19))
+ (assert-uim-equal "100" '(digit->string 100))
+ (assert-uim-equal "1000" '(digit->string 1000))
+ ;; for storage-fa...@32-bit
+ ;;(assert-uim-equal "2147483647" '(digit->string 2147483647))
+ ;; for storage-comp...@32-bit
+ (assert-uim-equal "134217727" '(digit->string 134217727))
+ #f)
+
+;; compare string sequence
+(define (test-str-seq-equal?)
+ (assert-uim-true '(str-seq-equal? () ()))
+ (assert-uim-true '(str-seq-equal? '("") '("")))
+ (assert-uim-false '(str-seq-equal? () '("")))
+ (assert-uim-false '(str-seq-equal? '("") ()))
+ (assert-uim-true '(str-seq-equal? '("a") '("a")))
+ (assert-uim-false '(str-seq-equal? '("a") '("A")))
+ (assert-uim-false '(str-seq-equal? '("a") '("b")))
+ (assert-uim-true '(str-seq-equal? '("a" "b" "c")
+ '("a" "b" "c")))
+ (assert-uim-false '(str-seq-equal? '("a" "b" "c")
+ '("a" "b" "c" "d")))
+ (assert-uim-false '(str-seq-equal? '("a" "b" "c")
+ '("z" "a" "b" "c")))
+ (assert-uim-false '(str-seq-equal? '("a" "b" "c" "d")
+ '("a" "b" "c")))
+ #f)
+
+;; Partial -> first string of remaining sequence
+;; eg. ("a" "b") ("a" "b" "c") -> "c"
+;; Not partial -> #f
+(define (test-str-seq-partial?)
+ (assert-uim-false '(str-seq-partial? () ()))
+ (assert-uim-false '(str-seq-partial? '("") '("")))
+ (assert-uim-equal ""
+ '(str-seq-partial? () '("")))
+ (assert-uim-false '(str-seq-partial? '("") ()))
+ (assert-uim-false '(str-seq-partial? '("a") '("a")))
+ (assert-uim-false '(str-seq-partial? '("a") '("A")))
+ (assert-uim-false '(str-seq-partial? '("a") '("b")))
+ (assert-uim-equal "b"
+ '(str-seq-partial? '("a")
+ '("a" "b")))
+ (assert-uim-false '(str-seq-partial? '("a" "b" "c")
+ '("a" "b" "c")))
+ (assert-uim-equal "d"
+ '(str-seq-partial? '("a" "b" "c")
+ '("a" "b" "c" "d")))
+ (assert-uim-equal "d"
+ '(str-seq-partial? '("a" "b" "c")
+ '("a" "b" "c" "d" "e")))
+ (assert-uim-false '(str-seq-partial? '("a" "b" "c" "d")
+ '("a" "b" "c")))
+ #f)
+
+
+
(provide "test/util/test-string")
