86 lines
2.5 KiB
Scheme
86 lines
2.5 KiB
Scheme
; Tests of sharp expressions in ScriptFu
|
|
|
|
; This only tests:
|
|
; miscellaneous sharp expressions
|
|
; See also:
|
|
; sharp-expr-char.scm
|
|
; sharp-expr-number.scm
|
|
|
|
; Some "sharp expressions" e.g. #t and #f might not be explicitly tested,
|
|
; but tested "driveby" by other tests.
|
|
|
|
; Terminology:
|
|
; The code says "sharp constant expression".
|
|
; A "sharp expression" is text in the language that denotes a "sharp constant."
|
|
; A constant is an atom of various types: char, byte, number.
|
|
; The expression is distinct from the thing it denotes.
|
|
|
|
; A "sharp expression" is *recognized* by the interpreter.
|
|
; But also *printed* by the interpreter REPL.
|
|
; Mostly these are tests of recognition.
|
|
; The testing framework cannot test the REPL.
|
|
|
|
; See scheme.c, the token() function, about line 2000
|
|
; and the mk_sharp_constant() function, for sharp character constant
|
|
|
|
; #( token denotes start of a vector
|
|
|
|
; #! token denotes start of a comment terminated by newline
|
|
; aka shebang or hashbang, a notation that OS shells read
|
|
|
|
; #t denotes true
|
|
; #f denotes false
|
|
|
|
; #odxb<x> denotes a numeric constant in octal, decimal, hex, binary base
|
|
; where <x> are digits of that base
|
|
|
|
; #\<char> denotes a character constant where <char> is one character
|
|
; The one character may be multiple bytes in UTF-8,
|
|
; but should appear in the display as a single glyph,
|
|
; but may appear as a box glyph for unichar chars outside ASCII.
|
|
|
|
; #\x<x> denotes a character constant where <x> is a sequence of hex digits
|
|
; See mk_sharp_const()
|
|
|
|
; #\space #\newline #\return and #\tab also denote character constants.
|
|
|
|
; Note: sharp backslash followed by space/blank parses as a token,
|
|
|
|
; #U+<x> notation for unichar character constants is not in ScriptFu
|
|
|
|
; Any sharp character followed by characters not described above
|
|
; MAY optionally be a sharp expression when a program
|
|
; uses the "sharp hook" by defining symbol *sharp-hook* .
|
|
|
|
|
|
; block quote parses
|
|
; Seems only testable in REPL?
|
|
; Note there is a newline after foo
|
|
;(assert '#! foo
|
|
; )
|
|
; but is not testable by the framework
|
|
|
|
; #t denotes truth
|
|
(assert #t)
|
|
|
|
; #t denotes an atom
|
|
(assert (atom? #t))
|
|
|
|
; #t is type boolean
|
|
(assert (boolean? #t))
|
|
; #t is neither type number or symbol
|
|
(assert (not (number? #t)))
|
|
(assert (not (symbol? #t)))
|
|
|
|
; #t denotes constant, and constant means immutable
|
|
; You cannot redefine #t
|
|
(assert-error `(define #t 1)
|
|
"variable is not a symbol")
|
|
; You cannot set #t
|
|
(assert-error `(set! #t 1)
|
|
"set!: unbound variable:")
|
|
; error-hook omits suffix: #t
|
|
|
|
; There is no predicate immutable? in Scheme language?
|
|
|
