ede/tools/capone/test/string.ss
2008-07-08 12:24:24 +00:00

126 lines
2.9 KiB
Scheme

;;
;; string functions
;;
(ut-add-test
"Check 'string?' function"
(begin
(and
(string? "sample string")
(not (string? 123))
(not (string? #\w))
)))
(ut-add-test
"Check 'string=?' function"
(begin
(and
(string=? "sample string" "sample string")
(not (string=? "sample string" "sample String"))
(not (string=? "ssss" ""))
)))
(ut-add-test
"Check 'string<? and string>?' functions"
(begin
(and
(string<? "aaaa" "z")
(string<? "foo" "fooo")
(not (string<? "foo" "asdadad"))
(not (string<? "fooooooooo" "ab"))
(string>? "z" "aaaa")
(string>? "fooo" "foo")
(string>? "foo" "asdadad")
(string>? "fooooooooo" "ab")
)))
(ut-add-test
"Check 'string<=? and string>=?' functions"
(begin
(and
(string<=? "aaaa" "z")
(string<=? "aaaa" "aaaa")
(string<=? "" "")
(not (string<=? "foo" "asdadad"))
(not (string<=? "fooooooooo" "ab"))
(string>=? "z" "aaaa")
(string>=? "aaaa" "aaaa")
(string>=? "" "")
(string>=? "foo" "asdadad")
(string>=? "fooooooooo" "ab")
)))
(ut-add-test
"Check 'string->list' function"
(begin
(let ((l (string->list "sample string")))
(and
(= 13 (length l))
(char=? #\s (car l))
(char=? #\a (cadr l))
(char=? #\m (caddr l))
(char=? #\p (cadddr l))
))))
(ut-add-test
"Check 'list->string' function"
(begin
(let ((s (list->string '(#\s #\a #\m #\p #\l #\e #\space #\s #\t #\r #\i #\n #\g))))
(string=? s "sample string")
)))
(ut-add-test
"Check 'string-length' function"
(begin
(and
(= 18 (string-length "some stupid sample"))
(= 0 (string-length ""))
(= 1 (string-length "a"))
)))
;; As I could find from chicken and guile, string-fill! should modify
;; any string, not only one given with (make-string) only, which creates immutable strings
;;
;; This behaviour should be somehow documented and here it is:
;; If we make a string like '(define s "foo")' it will be immutable by default and that
;; can't be changed. On other hand, if we do something like:
;; (define s (make-string 10))
;; (set! s (string-copy "foo"))
;; 's' will have "foo" value, have length of 3 characters and _will_ be mutable, e.g.
;; '(string-set! s 0 #\m)' will not fail and result will be "moo".
;;
;; Should it be seen as bug?
(ut-add-test
"Check 'string-fill! and make-string' functions [!]"
(begin
(define s (make-string 11))
(string-fill! s #\o)
(string=? s "ooooooooooo")
))
(ut-add-test
"Check 'string-set!' function"
(begin
(define s (make-string 10))
(set! s (string-copy "abrakadabra abrakadabra"))
(string-set! s 0 #\A)
(string-set! s 1 #\B)
(string-set! s 2 #\A)
(string-set! s 11 #\|)
(string-set! s 22 #\A)
(string=? s "ABAakadabra|abrakadabrA")
)
)
(ut-add-test
"Check 'number->string' function"
(begin
(and
(string=? "33" (number->string 33))
(string=? "1234" (number->string 1234))
(string=? "0" (number->string 0))
(string=? "-1234" (number->string -1234))
)))