(use test utf8 utf8-srfi-13 utf8-srfi-14)
(import (prefix (only scheme string list->string) byte-))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; R5RS

(test-begin)

(test 2 (string-length "漢字"))

(test 28450 (char->integer (string-ref "漢字" 0)))

(define str (string-copy "漢字"))

(test "赤字" (begin (string-set! str 0 (string-ref "赤" 0)) str))

(test "赤外" (begin (string-set! str 1 (string-ref "外" 0)) str))

(test "赤x" (begin (string-set! str 1 #\x) str))

(test "赤々" (begin (string-set! str 1 (string-ref "々" 0)) str))

(test "文字列" (substring "文字列" 0))
(test "字列" (substring "文字列" 1))
(test "列" (substring "文字列" 2))
(test "文" (substring "文字列" 0 1))
(test "字" (substring "文字列" 1 2))
(test "文字" (substring "文字列" 0 2))

(define *string* "文字列")
(define *list* '("文" "字" "列"))
(define *chars* '(25991 23383 21015))

(test *chars* (map char->integer (string->list "文字列")))

(test *list* (map string (map integer->char *chars*)))

(test *string* (list->string (map integer->char '(25991 23383 21015))))

(test "列列列" (make-string 3 (string-ref "列" 0)))

(test "文文文" (let ((s (string-copy "abc"))) (string-fill! s (string-ref "文" 0)) s))

(test (string-ref "ﾊ" 0) (with-input-from-string "全角ﾊﾝｶｸ"
                           (lambda () (read-char) (read-char) (read-char))))

(test "個々" (with-output-to-string
              (lambda ()
                (write-char (string-ref "個" 0))
                (write-char (string-ref "々" 0)))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; library

(test "出力改行\n" (with-output-to-string
                   (lambda () (print "出" (string-ref "力" 0) "改行"))))

(test "出力" (with-output-to-string
              (lambda () (print* "出" (string-ref "力" 0) ""))))

(test "逆リスト→文字列" (reverse-list->string
                     (map (cut string-ref <> 0)
                          '("列" "字" "文" "→" "ト" "ス" "リ" "逆"))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; extras

(test "这是" (with-input-from-string "这是中文" (cut read-string 2)))

(test "这是" (with-output-to-string (cut write-string "这是中文" 2)))

(test "我爱她" (conc (with-input-from-string "我爱你"
                      (cut read-token (lambda (c)
                                        (memv c (map (cut string-ref <> 0)
                                                     '("爱" "您" "我")))))) "她"))

(test '("第一" "第二" "第三") (string-chop "第一第二第三" 2))

(test '("第一" "第二" "第三" "…") (string-chop "第一第二第三…" 2))

(test '("a" "bc" "第" "f几") (string-split "a,bc、第,f几" ",、"))

(test "THE QUICK BROWN FOX JUMPED OVER THE LAZY SLEEPING DOG"
    (string-translate "the quick brown fox jumped over the lazy sleeping dog"
                      "abcdefghijklmnopqrstuvwxyz"
                      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
(test ":foo:bar:baz" (string-translate "/foo/bar/baz" "/" ":"))
(test "你爱我" (string-translate "我爱你" "我你" "你我"))
(test "你爱我" (string-translate "我爱你" '(#\我 #\你) '(#\你 #\我)))
(test "我你" (string-translate "我爱你" "爱"))
(test "我你" (string-translate "我爱你" #\爱))

(test-assert (substring=? "日本語" "日本語"))
(test-assert (substring=? "日本語" "日本"))
(test-assert (substring=? "日本" "日本語"))
(test-assert (substring=? "日本語" "本語" 1))
(test-assert (substring=? "日本語" "本" 1 0 1))
(test-assert (substring=? "听说上海的东西很贵" "上海的东西很便宜" 2 0 5))

(test 2 (substring-index "上海" "听说上海的东西很贵"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; regex

(test '("abc") (string-match "a.c" "abc"))
(test '("aうc") (string-match "a.c" "aうc"))
(test-assert (not (string-match "a.c" "ac")))
(test '("aうc") (string-match "a.*c" "aうc"))
(test '("a0c") (string-match "a[あい0-9えお]c" "a0c"))
(test '("aいc") (string-match "a[あい0-9えお]c" "aいc"))
(test-assert (not (string-match "a[あい0-9えお]c" "aうc")))

(test #f (string-search-positions "a" "b" 0))
(test '((0 1)) (string-search-positions "a" "a" 0))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SRFI-13

(test-assert (string-null? ""))

(test-assert (string-every (lambda (c) (not (char-alphabetic? c)))
                           "日本語に戻りましょう"))

(test-assert (string-any (lambda (c) (eqv? c (string-ref "白" 0)))
                         "black: 黒 white: 白"))

(test "一二三" (string-tabulate
               (lambda (i)
                 (integer->char
                  (inexact->exact (+ (* -135.5 i i) (* 275.5 i) 19968))))
               3))

;; this is the same as substring, why extend it in SRFI-13?
(test "春夏秋冬" (string-copy "春夏秋冬"))
(test "秋冬" (string-copy "春夏秋冬" 2))
(test "夏秋" (string-copy "春夏秋冬" 1 3))

(let ((a (string-copy "春夏秋冬")) (b "ABCD"))
  (test "ABCD" (begin (string-copy! a 0 b) a)))
(let ((a (string-copy "春夏秋冬")) (b "ABCD"))
  (test "D夏秋冬" (begin (string-copy! a 0 b 3) a)))
(let ((a (string-copy "春夏秋冬")) (b "ABCD"))
  (test "AB秋冬" (begin (string-copy! a 0 b 0 2) a)))

(let ((a (string-copy "春夏秋冬")) (b (string-copy "ABCD")))
  (test "春夏秋冬" (begin (string-copy! b 0 a) b)))
(let ((a (string-copy "春夏秋冬")) (b (string-copy "ABCD")))
  (test "夏秋冬D" (begin (string-copy! b 0 a 1) b)))
(let ((a (string-copy "春夏秋冬")) (b (string-copy "ABCD")))
  (test "秋冬CD" (begin (string-copy! b 0 a 2 4) b)))

(let ((a (string-copy "春夏秋冬")))
  (string-xcopy! a 1 "BC" 0)
  (test "春BC冬" a))

;; again, these are just variations of substring
(test "春" (string-take "春夏秋冬" 1))
(test "春夏" (string-take "春夏秋冬" 2))
(test "夏秋冬" (string-drop "春夏秋冬" 1))
(test "秋冬" (string-drop "春夏秋冬" 2))
(test "冬" (string-take-right "春夏秋冬" 1))
(test "秋冬" (string-take-right "春夏秋冬" 2))
(test "春夏秋" (string-drop-right "春夏秋冬" 1))
(test "春夏" (string-drop-right "春夏秋冬" 2))

(let ((pad-char (string-ref "…" 0)))
  (test "強食" (string-pad "弱肉強食" 2 pad-char))
  (test "弱肉強食" (string-pad "弱肉強食" 4 pad-char))
  (test "…弱肉強食" (string-pad "弱肉強食" 5 pad-char))
  (test "………弱肉強食" (string-pad "弱肉強食" 7 pad-char))
  (test "…肉強食" (string-pad "弱肉強食" 4 pad-char 1))
  (test "……肉強" (string-pad "弱肉強食" 4 pad-char 1 3))
  (test "弱肉" (string-pad-right "弱肉強食" 2 pad-char))
  (test "弱肉強食" (string-pad-right "弱肉強食" 4 pad-char))
  (test "弱肉強食…" (string-pad-right "弱肉強食" 5 pad-char))
  (test "弱肉強食………" (string-pad-right "弱肉強食" 7 pad-char))
  (test "肉強食…" (string-pad-right "弱肉強食" 4 pad-char 1))
  (test "肉強……" (string-pad-right "弱肉強食" 4 pad-char 1 3))
  )

(test "弱肉強食 \t\n" (string-trim "\n\t 弱肉強食 \t\n"))
(test "\n\t 弱肉強食" (string-trim-right "\n\t 弱肉強食 \t\n"))
(test "弱肉強食" (string-trim-both "\n\t 弱肉強食 \t\n"))
(let ((trim-char (string-ref "…" 0)))
  (test "弱肉強食……" (string-trim "……弱肉強食……" trim-char))
  (test "……弱肉強食" (string-trim-right "……弱肉強食……" trim-char))
  (test "弱肉強食" (string-trim-both "……弱肉強食……" trim-char)))

(let ((proc< (cut list '< <>))
      (proc= (cut list '= <>))
      (proc> (cut list '> <>))
      (s1 "御世話になっております")
      (s2 "お世話になります"))
  (test '(> 0) (string-compare s1 s2 proc< proc= proc>))
  (test '(< 5) (string-compare s1 s2 proc< proc= proc> 1 7 1))
  (test '(= 3) (string-compare s1 s2 proc< proc= proc> 1 3 1 3))
  )

;;   string= string<> string< string> string<= string>=
;;   string-ci= string-ci<> string-ci< string-ci> string-ci<= string-ci>=

(test-assert (and (string= "麻布" "麻布") #t))
(test-assert (not (and (string= "麻布" "麻布十番") #t)))
(test-assert (and (string= "西麻布" "麻布" 1) #t))
(test-assert (and (string= "西麻布の辺" "麻布" 1 3) #t))
(test-assert (and (string= "西麻布の辺" "元麻布に" 1 3 1 3) #t))
(test-assert (and (string<> "西麻布の辺" "元麻布に" 1 3) #t))

(test-assert (not (and (string< "あいうえお" "あいうえお") #t)))
(test-assert (not (and (string< "あいうえお" "あいうえお" 1) #t)))
(test-assert (and (string< "あいうえお" "あいうえお" 0 3) #t))
(test-assert (and (string< "あいうえお" "あいうえお" 0 3 1) #t))
(test-assert (and (string< "あいうえお" "あいうえお" 0 3 1 4) #t))

(test-assert (and (string<= "あいうえお" "あいうえお") #t))
(test-assert (not (and (string<= "あいうえお" "あいうえお" 1) #t)))

(test-assert (not (and (string> "あいうえお" "あいうえお") #t)))
(test-assert (and (string> "あいうえお" "あいうえお" 1) #t))

(test-assert (and (string>= "あいうえお" "あいうえお") #t))
(test-assert (not (and (string>= "あいうえお" "あいうえお" 1 3 2) #t)))

(test-assert (integer? (string-hash "abc")))
(test-assert (integer? (string-ci-hash "abc")))

(test-assert (not (= (string-hash "abc") (string-hash "abd"))))
(test-assert (= (string-ci-hash "abc") (string-ci-hash "aBc") (string-ci-hash "ABC")))

(test-assert (= (string-hash "いうえ" #xFFFF)
                (string-hash "あいうえ" #xFFFF 1)
                (string-hash "あいうえお" #xFFFF 1 4)))

(test-assert (string-prefix? "麻布" "麻布十番"))
(test-assert (not (string-prefix? "元麻布" "麻布十番")))
(test-assert (not (string-prefix? "麻布十番" "麻布")))
(test-assert (string-prefix? "元麻布" "麻布十番" 1))
(test-assert (string-prefix? "元麻布" "麻" 1 2))

(test-assert (string-suffix? "十番" "麻布十番"))
(test-assert (not (string-suffix? "九番" "麻布十番")))
(test-assert (not (string-suffix? "麻布十番" "十番")))
(test-assert (string-suffix? "元麻布" "東麻布" 1))
(test-assert (string-suffix? "元麻布" "東麻布" 1 3))

(test 2 (string-prefix-length "麻布" "麻布十番"))
(test 0 (string-prefix-length "元麻布" "麻布十番"))
(test 2 (string-prefix-length "元麻布" "麻布十番" 1))
(test 1 (string-prefix-length "元麻布" "麻" 1 2))

(test 2 (string-suffix-length "十番" "麻布十番"))
(test 1 (string-suffix-length "九番" "麻布十番"))
(test 2 (string-suffix-length "元麻布" "東麻布" 1))
(test 2 (string-suffix-length "元麻布" "東麻布" 1 3))

(test 1 (string-index "文字列の文字検索" (string-ref "字" 0)))
(test 5 (string-index-right "文字列の文字検索" (string-ref "字" 0)))

(test 3 (string-skip "文字列no関数kensaku"
                     (lambda (c) (not (char-alphabetic? c)))))
(test 7 (string-skip "文字列no関数kensaku"
                     (lambda (c) (not (char-alphabetic? c))) 5))
(test 13 (string-skip-right "文字列no関数kensaku"
                            (lambda (c) (not (char-alphabetic? c)))))
(test 4 (string-skip-right "文字列no関数kensaku"
                           (lambda (c) (not (char-alphabetic? c)))
                           0
                           5))

(test 7 (string-count "aびcでぃeえふgえち"
                      (lambda (c) (not (char-alphabetic? c)))))

(test 15 (string-contains "eek -- what a geek." "ee" 12 18))

(test 15 (string-contains-ci "eek -- what a gEek." "ee" 12 18))

(test 2 (string-contains "この釘は引き抜き難い釘だ" "釘"))
(test 10 (string-contains "この釘は引き抜き難い釘だ" "釘" 4))

(test "英語でSundayの最初の文字をTitlecase（小文字）と書く"
      (string-titlecase "英語でsundayの最初の文字をtitlecase（小文字）と書く"))

#;(test "英語でSundayの最初の文字をTitlecase（小文字）と書く"
      (let ((s "英語でsundayの最初の文字をtitlecase（小文字）と書く"))
        (string-titlecase! s)
        s))

(test "英語でUFOはUPCASEと書く" (string-upcase "英語でufoはupcaseと書く"))
#;(test "英語でUFOはUPCASEと書く"
      (let ((s "英語でufoはupcaseと書く"))
        (string-upcase! s)
        s))

(test "英語でappleはdowncaseと書く" (string-downcase "英語でAPPLEはDOWNCASEと書く"))
#;(test "英語でappleはdowncaseと書く"
      (let ((s "英語でAPPLEはDOWNCASEと書く"))
        (string-downcase! s)
        s))

(test "ΕΛΛΗΝΙΚΆ" (string-upcase "ελληνικά"))
(test "ελληνικά" (string-downcase "ΕΛΛΗΝΙΚΆ"))

(test "РУССКИЙ ЯЗЫК" (string-upcase "русский язык"))
(test "русский язык" (string-downcase "РУССКИЙ ЯЗЫК"))

(test "TEŞEKKÜR EDERIM" (string-upcase "teşekkür ederim"))
(test "teşekkür ederim" (string-downcase "TEŞEKKÜR EDERIM"))

(test "TEŞEKKÜR EDERIM" (string-upcase "teşekkür ederım"))
(test "teşekkür ederi̇m" (string-downcase "TEŞEKKÜR EDERİM"))

(test "TEŞEKKÜR EDERİM" (string-upcase "teşekkür ederim" "tr"))
(test "teşekkür ederım" (string-downcase "TEŞEKKÜR EDERIM" "tr"))
(test "teşekkür ederim" (string-downcase "TEŞEKKÜR EDERİM" "tr"))

(test "文X字X列" (string-map char-upcase "文x字x列"))

(test "文X字X列" (string-map! char-upcase (string-copy "文x字x列")))

(test "a字a字a" (string-map (lambda (c)
                             (if (char-alphabetic? c)
                               (string-ref "字" 0)
                               #\a))
                           "字x字x字"))

(test '("下" "却" "可" "許" "遽" "急" "日" "今" "局" "可" "許" "許" "特" "京" "東")
      (map string (string-fold cons '() "東京特許許可局今日急遽許可却下")))

(test '("東" "京" "特" "許" "許" "可" "局" "今" "日" "急" "遽" "許" "可" "却" "下")
      (map string (string-fold-right cons '() "東京特許許可局今日急遽許可却下")))

(test "あぃいぅう" (string-unfold
                  (cut = <> 5)
                  (lambda (i) (integer->char (+ i 12354)))
                  (cut + <> 1)
                  0))

(test "うぅいぃあ" (string-unfold-right
                  (cut = <> 5)
                  (lambda (i) (integer->char (+ i 12354)))
                  (cut + <> 1)
                  0))

(test "c三b二a一" (string-reverse "一a二b三c"))

(test "c三b二a一" (let ((s (string-copy "一a二b三c"))) (string-reverse! s) s))

(test '("マ" "ャ" "ジ" "パ" "茶" "マ" "ャ" "ジ" "パ" "黄" "マ" "ャ" "ジ" "パ" "赤")
      (let ((s "赤パジャマ黄パジャマ茶パジャマ") (ls '()))
        (string-for-each (lambda (c) (set! ls (cons c ls))) s)
        (map string ls)))

(test 10 (let ((sum 0))
           (string-for-each-index
            (lambda (i) (set! sum (+ sum i)))
            "赤パジャマ")
           sum))

(test "ｃｄｅｆａｂ" (xsubstring "ａｂｃｄｅｆ" 2))
(test "ｅｆａｂｃｄ" (xsubstring "ａｂｃｄｅｆ" -2))
(test "ａｂｃａｂｃａ" (xsubstring "ａｂｃ" 0 7))

(test "Ａａｂｃａｂ" (let ((s1 (string-copy "ＡＢＣＤＥＦ"))
                        (s2 "ａｂｃ"))
                    (string-xcopy! s1 1 s2 0 5)
                    s1))

(test "日本語" (string-replace "英語" "日本" 0 1))
(test "日本語" (string-replace "英語" "日本語" 0 1 0 2))

(test '("文字列" "引" "裂") (string-tokenize "文字列を引き裂く" (string->char-set "字列引裂文")))

(test "文字列引裂" (string-filter (lambda (c)
                                  (not (char-set-contains?
                                        (string->char-set "きくを") c)))
                                "文字列を引き裂く"))

(test "文字列引裂" (string-delete (string->char-set "きくを") "文字列を引き裂く"))

(test "foo:bar:baz" (string-join '("foo" "bar" "baz") ":"))
(test "foo:bar:baz" (string-join '("foo" "bar" "baz") ":" 'infix))
(test "foo:bar:baz" (string-join '("foo" "bar" "baz") ":" 'strict-infix))
(test ":foo:bar:baz" (string-join '("foo" "bar" "baz") ":" 'prefix))
(test "foo:bar:baz:" (string-join '("foo" "bar" "baz") ":" 'suffix))

;; Infix grammar is ambiguous wrt empty list vs. empty string,
(test "" (string-join '()   ":"))
(test "" (string-join '("") ":"))

;; but suffix & prefix grammars are not.
(test "" (string-join '()   ":" 'prefix))
(test ":" (string-join '("") ":" 'prefix))
(test "" (string-join '()   ":" 'suffix))
(test ":" (string-join '("") ":" 'suffix))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SRFI-14 (sanity only, these are tested more heavily in iset)

(test-assert (char-set? (->char-set "あいうえお")))

(test-assert (char-set-empty? (char-set)))

(test 0 (char-set-size (char-set)))

(test 5 (char-set-size (->char-set "あいうえお")))

(test 4 (char-set-count (lambda (c) (not (eqv? c (string-ref "う" 0))))
                        (->char-set "あいうえお")))

(test-assert (let ((cs (->char-set "あいうえお"))) (char-set= cs (char-set-copy cs))))
(test-assert (char-set= (->char-set "あいうえお") (->char-set "おえういあ")))
(test-assert (char-set<= (->char-set "あいうえお") (->char-set "おえういあ")))
(test-assert (char-set<= (->char-set "あおい") (->char-set "おえういあ")))
(test-assert (not (char-set<= (->char-set "おえういあ") (->char-set "あおい"))))
(test-assert (char-set>= (->char-set "おえういあ") (->char-set "あいうえお")))
(test-assert (char-set>= (->char-set "おえういあ") (->char-set "あおい")))
(test-assert (not (char-set>= (->char-set "あおい") (->char-set "おえういあ"))))

(test-assert (let ((cs (->char-set "あいうえお")))
               (char-set-every (cut char-set-contains? cs <>) cs)))

(test-assert (not (let ((cs1 (->char-set "あおい"))
                        (cs2 (->char-set "あいうえお")))
                    (char-set-every (cut char-set-contains? cs1 <>) cs2))))

(test-assert (let ((cs1 (->char-set "あおい"))
                   (cs2 (->char-set "あいうえお")))
               (char-set-any (cut char-set-contains? cs1 <>) cs2)))

(test-assert (not (char-set-any char-alphabetic? (->char-set "あいうえお"))))

(test-assert (char-set-contains? (->char-set "あa字") (string-ref "あ" 0)))
(test-assert (char-set-contains? (->char-set "あa字") (string-ref "a" 0)))
(test-assert (char-set-contains? (->char-set "あa字") (string-ref "字" 0)))
(test-assert (not (char-set-contains? (->char-set "あa字") (string-ref "い" 0))))

(test-assert (char-set= (->char-set "a")
                        (char-set-filter char-alphabetic? (->char-set "あa字"))))

(test-assert (char-set= (->char-set "あa字")
                        (char-set-adjoin (->char-set "あ字") #\a)))

(test-assert (char-set= (->char-set "あ字")
                        (char-set-delete (->char-set "あa字") #\a)))

(test '("あ" "い" "う" "え" "お")
      (map string (sort (char-set-fold cons '() (->char-set "あいうえお")) char<?)))

(test-assert (char-set=
              (->char-set "一二三")
              (char-set-unfold
               (lambda (i)
                 (integer->char
                  (inexact->exact (+ (* -135.5 i i) (* 275.5 i) 19968))))
               (cut >= <> 3)
               add1
               0)))

(test-assert (char-set= (->char-set "ABCあ") (char-set-map char-upcase (->char-set "abcあ"))))

(test 4 (let ((sum 0))
          (char-set-for-each (lambda _ (set! sum (+ sum 1))) (->char-set "ABCあ")) sum))

(test-assert (char-set= (->char-set "あいうえお")
                        (char-set-union (->char-set "えい") (->char-set "うあお"))))

(test-assert (char-set= (->char-set "あおい")
                        (char-set-intersection (->char-set "あいうえお") (->char-set "いおあ"))))

(test-assert (char-set= (->char-set "あお")
                        (char-set-difference (->char-set "あいうえお") (->char-set "うえい"))))

(test-assert (char-set= (->char-set "あおえかき")
                        (char-set-xor (->char-set "あいうえお") (->char-set "きういか"))))

(test-assert (char-set= (->char-set "あぃいぅうぇ") (ucs-range->char-set #x3042 #x3048)))

(let ((cs (char-set-complement char-set:letter)))
  (test-assert (not (char-set-contains? cs #\a)))
  (test-assert (char-set-contains? cs (string-ref "あ" 0))) )

(let ((cs (char-set-complement (ucs-range->char-set #x3042 #x3090))))
  (test-assert (char-set-contains? cs #\a))
  (test-assert (not (char-set-contains? cs (string-ref "あ" 0)))) )

(test-assert (char-set-contains? char-set:lower-case #\a))
(test-assert (not (char-set-contains? char-set:lower-case #\A)))
(test-assert (not (char-set-contains? char-set:lower-case (string-ref "あ" 0))))

(test-assert (not (char-set-contains? char-set:upper-case #\a)))
(test-assert (char-set-contains? char-set:upper-case #\A))
(test-assert (not (char-set-contains? char-set:upper-case (string-ref "あ" 0))))

(test-assert (not (char-set-contains? char-set:title-case #\a)))
(test-assert (not (char-set-contains? char-set:title-case #\A)))

(test-assert (char-set-contains? char-set:letter #\a))
(test-assert (not (char-set-contains? char-set:letter #\0)))
(test-assert (not (char-set-contains? char-set:letter (string-ref "あ" 0))))

(test-assert (char-set-contains? char-set:digit #\0))
(test-assert (not (char-set-contains? char-set:digit #\a)))
(test-assert (not (char-set-contains? char-set:digit (string-ref "あ" 0))))

(test-assert (char-set-contains? char-set:hex-digit #\f))
(test-assert (not (char-set-contains? char-set:hex-digit #\g)))
(test-assert (not (char-set-contains? char-set:hex-digit (string-ref "あ" 0))))

(test-assert (char-set-contains? char-set:letter+digit #\z))
(test-assert (not (char-set-contains? char-set:letter+digit #\.)))
(test-assert (not (char-set-contains? char-set:letter+digit (string-ref "あ" 0))))

(test-assert (char-set-contains? char-set:punctuation #\.))
(test-assert (not (char-set-contains? char-set:punctuation #\a)))
(test-assert (not (char-set-contains? char-set:punctuation (string-ref "あ" 0))))

(test-assert (char-set-contains? char-set:symbol #\+))
(test-assert (not (char-set-contains? char-set:symbol #\.)))
(test-assert (not (char-set-contains? char-set:symbol (string-ref "あ" 0))))

(test-assert (char-set-contains? char-set:whitespace #\newline))
(test-assert (not (char-set-contains? char-set:whitespace #\_)))
(test-assert (not (char-set-contains? char-set:whitespace (string-ref "　" 0))))

(test-assert (char-set-contains? char-set:blank #\space))
(test-assert (not (char-set-contains? char-set:blank #\newline)))
(test-assert (not (char-set-contains? char-set:blank (string-ref "　" 0))))

(test-assert (char-set-contains? char-set:graphic #\a))
(test-assert (not (char-set-contains? char-set:graphic #\space)))
(test-assert (not (char-set-contains? char-set:graphic (string-ref "あ" 0))))

(test-assert (char-set-contains? char-set:printing #\space))
(test-assert (not (char-set-contains? char-set:printing (integer->char 0))))
(test-assert (not (char-set-contains? char-set:printing (string-ref "あ" 0))))

(test-assert (char-set-contains? char-set:iso-control (integer->char 0)))
(test-assert (not (char-set-contains? char-set:iso-control #\a)))
(test-assert (not (char-set-contains? char-set:iso-control (string-ref "あ" 0))))

(test-assert (char-set-contains? char-set:ascii #\a))
(test-assert (not (char-set-contains? char-set:ascii (string-ref "あ" 0))))

(test-assert (not (char-set-contains? char-set:empty #\a)))
(test-assert (not (char-set-contains? char-set:empty (string-ref "あ" 0))))

(test-assert (char-set-contains? char-set:full #\a))
(test-assert (char-set-contains? char-set:full (string-ref "あ" 0)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; utf8-validation

(test-assert "stray continuation byte"
  (not (valid-string? (byte-string #\x (integer->char #b10101010) #\x))))

(test-assert "overlong"
  (not (valid-string? (byte-list->string `(#\x ,@(map integer->char '(#b11000000 #b10100111)) #\x)))))

(test-assert "incomplete"
  (not (valid-string? (byte-string #\x (integer->char #b11000001)))))

(test-assert "surrogate"
  (not (valid-string? (byte-list->string `(#\x ,@(map integer->char '(#xED #xA0 #x90)) #\x)))))

(test-assert "out of range"
  (not (valid-string? (byte-list->string `(#\x ,@(map integer->char '(#xF5 #x90 #x90 #x90)) #\x)))))

(test-assert (valid-string? "Є"))
(test-assert (valid-string? "☭"))
(test-assert (valid-string? "😈"))
(test-assert (valid-string? "xЄ☭😈x"))

(test-end)