3 ;; Testcases for parenscript
5 (defun trim-whitespace(str)
6 (string-trim '(#\Space
#\Tab
#\Newline
) str
))
8 (defun same-space-between-statements(code)
9 (cl-ppcre:regex-replace-all
"\\s*;\\s*" code
(concatenate 'string
(list #\
; #\Newline))))
11 (defun no-indentation(code)
12 (cl-ppcre:regex-replace-all
(cl-ppcre:create-scanner
"^\\s*" :multi-line-mode t
) code
""))
14 (defun no-trailing-spaces(code)
15 (cl-ppcre:regex-replace-all
(cl-ppcre:create-scanner
"\\s*$" :multi-line-mode t
) code
""))
17 (defun normalize-js-code(str)
18 (trim-whitespace (no-indentation (no-trailing-spaces (same-space-between-statements str
)))))
20 (defmacro test-ps-js
(testname parenscript javascript
)
22 (setf js
::*var-counter
* 0)
23 ;; is-macro expands its argument again when reporting failures, so
24 ;; the reported temporary js-variables get wrong if we don't evalute first.
25 (let ((generated-code (js-to-string ',parenscript
))
26 (js-code ,javascript
))
27 (is (string= (normalize-js-code generated-code
)
28 (normalize-js-code js-code
))))))
31 (format t
"Running reference tests:~&")
33 (format t
"Running other tests:~&")
36 ;;---------------------------------------------------------------------------
37 (eval-when (:compile-toplevel
:load-toplevel
:execute
)
41 (test-ps-js plus-is-not-commutative
42 (setf x
(+ "before" x
"after"))
43 "x = 'before' + x + 'after'")
45 (test-ps-js plus-works-if-first
46 (setf x
(+ x
"middle" "after"))
47 "x += 'middle' + 'after'")
49 (test-ps-js setf-side-effects
55 (setf x
(+ 2 (side-effect) x
5))))
58 function sideEffect() {
62 x = 2 + sideEffect() + x + 5;")
63 ;; Parenscript used to optimize to much:
65 ;; function sideEffect() {
69 ;; x += 2 + sideEffect() + 5;
71 ;; Which is 20, not 14
74 (test-ps-js dot-notation-bug
75 (.match
(+ "" x
) "foo")
76 "('' + x).match('foo')")
78 (test-ps-js method-call-op-form
(.to-string
(+ "" x
)) "('' + x).toString()")
79 (test-ps-js method-call-number
(.to-string
10) "(10).toString()")
80 (test-ps-js method-call-string
(.to-string
"hi") "'hi'.toString()")
81 (test-ps-js method-call-lit-object
82 (.to-string
(create :to-string
(lambda ()
83 (return "it works"))))
84 "({ toString : function () {
88 (test-ps-js method-call-variable
92 (test-ps-js method-call-array
93 (.to-string
(list 10 20))
94 "[10, 20].toString()")
95 (test-ps-js method-call-fn-call
98 (test-ps-js method-call-lambda-fn
99 (.to-string
(lambda () (alert 10)))
100 "(function () {alert(10);}).toString()")
101 (test-ps-js method-call-lambda-call
102 (.to-string
((lambda (x) (return x
)) 10))
103 "(function (x) {return x;})(10).toString()")
105 (test no-whitespace-before-dot
106 (let* ((str (js:js
* '(.to-string
((lambda (x) (return x
)) 10))))
107 (dot-pos (position #\. str
:test
#'char
=))
108 (char-before (elt str
(1- dot-pos
)))
110 (is (char= char-before a-parenthesis
))))
112 ;; A problem with long nested operator, when the statement spanned several rows
113 ;; the rows would not be joined together correctly.
114 (test-ps-js bug-dwim-join
115 (alert (html ((:div
:id
777
116 :style
(css-inline :border
"1pxsssssssssss"
119 :width
(* 2 300))))))
121 ('<div id=\"777\" style=\"'
122 + ('border:1pxsssssssssss;font-size:x-small;height:' + 2 * 200 + ';width:'
124 + '\"></div>')") ;";This line should start with a plus character.
127 (test-ps-js simple-slot-value
128 (let ((foo (create :a
1)))
129 (alert (slot-value foo
'a
)))
135 (test-ps-js buggy-slot-value
136 (let ((foo (create :a
1))
138 (alert (slot-value foo slot-name
)))
142 alert(foo[slotName]);
143 }"); Last line was alert(foo.slotName) before bug-fix.
145 (test-ps-js buggy-slot-value-two
146 (slot-value foo
(get-slot-name))
147 "foo[getSlotName()]")
149 (test-ps-js old-case-is-now-switch
150 ;; Switch was "case" before, but that was very non-lispish.
151 ;; For example, this code makes three messages and not one
152 ;; which may have been expected. This is because a switch
153 ;; statment must have a break statement for it to return
154 ;; after the alert. Otherwise it continues on the next
156 (switch (aref blorg i
)
159 (default (alert "default clause")))
161 case 1: alert('one');
162 case 2: alert('two');
163 default: alert('default clause');
166 (test-ps-js lisp-like-case
170 (default (alert "default clause")))
178 default: alert('default clause');
182 (test-ps-js even-lispier-case
184 ((1 2) (alert "Below three"))
186 (t (alert "Something else")))
190 alert('Below three');
195 default: alert('Something else');
198 (test-ps-js otherwise-case
201 (otherwise (alert "default clause")))
206 default: alert('default clause');
209 (test escape-sequences-in-string
210 (let ((escapes `((#\\ .
#\\)
212 (#\f .
,(code-char 12))
213 ("u000B" .
,(code-char #x000b
));;Vertical tab, too uncommon to bother with
216 (#\' .
#\');;Double quote need not be quoted because parenscript strings are single quoted
218 ("u001F" .
,(code-char #x001f
));; character below 32
219 ("u0080" .
,(code-char 128)) ;;Character over 127. Actually valid, parenscript escapes them to be sure.
220 ("uABCD" .
,(code-char #xabcd
)))));; Really above ascii.
221 (loop for
(js-escape . lisp-char
) in escapes
222 for generated
= (js-to-string `(let ((x , (format nil
"hello~ahi" lisp-char
)))))
223 for wanted
= (format nil
"{
224 var x = 'hello\\~ahi';
226 do
(is (string= generated wanted
)))))