shithub: sl

Info  •  Files  •  Log  •  Branches

more coverage

--- a/src/utf8.c

+++ b/src/utf8.c

@@ -128,6 +128,8 @@

 u8_escape_rune(char *buf, size_t sz, Rune ch)

 {

 	assert(sz > 12);

+	if(ch == '\\')

+		return buf_put2c(buf, "\\\\");

 	if(ch >= 0x20 && ch < 0x7f){

 		buf[0] = ch;

 		buf[1] = '\0';

@@ -140,7 +142,6 @@

 	switch(ch){

 	case '\n': return buf_put2c(buf, "\\n");

 	case '\t': return buf_put2c(buf, "\\t");

-	case '\\': return buf_put2c(buf, "\\\\");

 	case '\a': return buf_put2c(buf, "\\a");

 	case '\b': return buf_put2c(buf, "\\b");

 	case 0x1b: return buf_put2c(buf, "\\e");

--- a/test/unittest.lsp

+++ b/test/unittest.lsp

@@ -513,6 +513,7 @@

 (define s "привет\0пока")

 (assert (equal? s (string-encode (string-decode s))))

+(assert (equal? (string s "\0") (string-encode (string-decode s #t))))

 (assert (eq? 21 (sizeof s)))

 (assert (eq? 21 (length s)))

@@ -532,10 +533,25 @@

 (assert (equal? "акоп\0тевирп" (string-reverse s)))

 (assert (equal? "" (string-reverse "")))

 (assert (equal? "й" (string-reverse "й")))

+(assert (equal? "wб☺🡷⁹гq" (string-reverse "qг⁹🡷☺бw")))

-(assert (eq? 10 (string-width s)))

-(assert (eq? 0 (string-width "")))

+(assert (string-utf8? ""))

+(assert (string-utf8? "wб☺🡷⁹гq"))

+(assert (not (string-utf8? "\xfffe")))

+(let ((b (buffer)))

+  (write "a\x0a\x09\\\x07\x08\x1b\x0c\x0d\x0b" b)

+  (assert (equal? (iostream->string b) "\"a\\n\\t\\\\\\a\\b\\e\\f\\r\\v\"")))

+

+(assert (= 10 (string-width s)))

+(assert (= 0 (string-width "")))

+(assert (= 1 (string-width #\q)))

+(assert (= 1 (string-width #\й)))

+(assert (= 0 (string-width #\nul)))

+(assert-fail (string-width 123))

+(assert-fail (string-width 'blah))

+(assert-fail (string-width string-width))

+

 (assert (equal? '("привет" "пока") (string-split s "\0")))

 (assert (equal? '("пр" "вет" "пок" "") (string-split s "аи\0")))

 (assert (equal? '("" "") (string-split "1" "1")))

@@ -548,29 +564,55 @@

 (assert (equal? #\П (char-upcase #\п)))

 (assert (equal? #\nul (char-upcase #\nul)))

-(assert (equal? #t (char-upper-case? #\W)))

-(assert (equal? #t (char-upper-case? #\П)))

-(assert (equal? #f (char-upper-case? #\nul)))

-(assert (equal? #f (char-upper-case? #\w)))

-(assert (equal? #f (char-upper-case? #\п)))

-(assert (equal? #f (char-upper-case? #\nul)))

+(assert (char-upper-case? #\W))

+(assert (char-upper-case? #\П))

+(assert (not (char-upper-case? #\nul)))

+(assert (not (char-upper-case? #\w)))

+(assert (not (char-upper-case? #\п)))

+(assert (not (char-upper-case? #\nul)))

 (assert (equal? #\w (char-downcase #\W)))

 (assert (equal? #\п (char-downcase #\П)))

 (assert (equal? #\nul (char-downcase #\nul)))

-(assert (equal? #t (char-lower-case? #\w)))

-(assert (equal? #t (char-lower-case? #\п)))

-(assert (equal? #f (char-lower-case? #\nul)))

-(assert (equal? #f (char-lower-case? #\W)))

-(assert (equal? #f (char-lower-case? #\П)))

-(assert (equal? #f (char-lower-case? #\nul)))

+(assert (char-lower-case? #\w))

+(assert (char-lower-case? #\п))

+(assert (not (char-lower-case? #\nul)))

+(assert (not (char-lower-case? #\W)))

+(assert (not (char-lower-case? #\П)))

+(assert (not (char-lower-case? #\nul)))

+(assert (char-numeric? #\0))

+(assert (char-numeric? #\9))

+(assert (not (char-numeric? #\⁰)))

+(assert (not (char-numeric? #\q)))

+

+(assert (char-whitespace? #\space))

+(assert (char-whitespace? #\tab))

+(assert (char-whitespace? #\vtab))

+(assert (char-whitespace? #\newline))

+(assert (char-whitespace? #\x00a0))

+(assert (char-whitespace? #\x3000))

+(assert (not (char-whitespace? #\x200b)))

+

+(assert (char-alphabetic? #\q))

+(assert (char-alphabetic? #\й))

+(assert (not (char-alphabetic? #\⁰)))

+(assert (not (char-alphabetic? #\0)))

+

 (assert (equal? "1.5" (number->string 1.5)))

 (assert (equal? "-3039" (number->string (int16 -12345) 16)))

 (assert (equal? "111111111111111111111111111111111" (number->string   111111111111111111111111111111111)))

 (assert (equal? "fffffffffffffffffffffffffffffffff" (number->string 0xfffffffffffffffffffffffffffffffff 16)))

+(assert-fail (number->string 1.5 16))

+(assert-fail (number->string (bignum 0) 36))

+

+(assert (= 1.5 (string->number "1.5")))

+(assert (= -12345 (string->number "-3039" 16)))

+(assert (= 111111111111111111111111111111111 (string->number "111111111111111111111111111111111")))

+(assert (= 0xfffffffffffffffffffffffffffffffff (string->number "fffffffffffffffffffffffffffffffff" 16)))

+

 (assert (= (length (byte #\f)) 1))

 (assert (= (length #\я) 2))

 (assert (= (length #\⁹) 3))

@@ -654,6 +696,12 @@

 (assert-fail (sleep 1 2))

 (sleep)

 (sleep 0)

+(define t₀ (nanoseconds-monotonic))

+(sleep 1)

+(define t₁ (nanoseconds-monotonic))

+(define Δt (- t₁ t₀))

+(print Δt) (newline)

+(assert (and (< Δt 1010000000 ) (> Δt 999000000)))

 (gc)

 (let ((ruint32 (table))