t/eval-tests.lisp

   1 ;; Copying and distribution of this file, with or without
   2 ;; modification, are permitted in any medium without royalty. This
   3 ;; file is offered as-is, without any warranty.
   4
   5 (in-package #:ps-eval-tests)
   6 (named-readtables:in-readtable :parenscript)
   7
   8 (in-suite ps-test::eval-tests)
   9
  10 (test-js-eval number
  11   3
  12   3)
  13
  14 (test-js-eval float
  15   (< 123.12 123.123 123.124)
  16   t)
  17
  18 (test-js-eval string
  19   "foobar"
  20   "foobar")
  21
  22 (test-js-eval statements-and-expressions-2
  23   ((lambda () (if 1 2 3)))
  24   2)
  25
  26 (test-js-eval statements-and-expressions-1
  27   ((lambda () (+ 2 (if 1 2 3))))
  28   4)
  29
  30 (test-js-eval empty-array
  31   (array)
  32   '())
  33
  34 (test-js-eval funargs-let1
  35   ((lambda (x)
  36      (let ((x 10))
  37        (incf x))
  38      (incf x))
  39    0)
  40   1)
  41
  42 (test-js-eval times-rem
  43   (* 12 (rem 10 3))
  44   12)
  45
  46 (test-js-eval divide-rem
  47   (rem 10 (/ 12 4))
  48   1)
  49
  50 (test-js-eval rem-divide
  51   (/ 9 (rem 11 4))
  52   3)
  53
  54 (test-js-eval rem-multiply
  55   (* 5 (rem 4 3))
  56   5)
  57
  58 (test-js-eval case-return-break-null
  59   ((lambda (x) (case x
  60                  (1)
  61                  (2 3)))
  62    1)
  63   :null)
  64
  65 (test-js-eval defun-return1
  66   (progn (defun bar (x) (1+ x))
  67          (bar 1))
  68   2)
  69
  70 (test-js-eval defun-return2
  71   (progn (defun bar (fn)
  72            (funcall fn))
  73
  74          (defun foo ()
  75            (bar (lambda () (return-from foo 123))))
  76
  77          (foo))
  78   123)
  79
  80 (test-js-eval defvar
  81   (progn (defvar foo 1)
  82          foo)
  83   1)
  84
  85 (test-js-eval block-dynamic-lambda
  86   ((lambda () (block nil (return 4) (+ 1 2))))
  87   4)
  88
  89 (test-js-eval block-dynamic-lambda1
  90   ((lambda () (block nil (return 4) (+ 1 2)) 5))
  91   5)
  92
  93 (test-js-eval loop-sum
  94   (+ 1 (loop for i from 0 to 10 sum i))
  95   56)
  96
  97 (test-js-eval loop-funcall-sum
  98   ((lambda (x) (1+ x)) (loop for i from 0 to 10 sum i))
  99   56)
 100
 101 (test-js-eval loop-funcall-if-sum
 102   (progn (defun one-plus (x)
 103            (1+ x))
 104
 105          (one-plus (if false 1 (loop for i from 0 to 10 sum i))))
 106   56)
 107
 108 (test-js-eval case-return-break1-broken-return
 109   (progn (defun foo (x y)
 110            (case x
 111              ("bar" (if y (return-from foo 1)))
 112              ("baz" 2)))
 113          (list (foo "bar" t) (foo "bar" nil) (foo "baz" nil)))
 114   '(1 :null 2))
 115
 116 (test-js-eval funcall-loop-doing
 117   ((lambda (x) x)
 118    (loop for i from 0 to 10 do (1+ i)))
 119   :undefined)
 120
 121 (test-js-eval block-dynamic-lambda2
 122   ((lambda () (1+ (block nil (return 4) (+ 1 2)))))
 123   5)
 124
 125 (test-js-eval block-dynamic-setf
 126   (progn (defvar foo (block nil (return 4) (+ 1 2)))
 127          foo)
 128   4)
 129
 130 (test-js-eval block-dynamic-return1
 131   (progn (defvar foo ((lambda ()
 132                         (block nil
 133                           ((lambda () (return 6)))
 134                           (+ 1 2)))))
 135          foo)
 136   6)
 137
 138 (test-js-eval block-lambda-dynamic-setf
 139   (progn (defvar foo (block nil ((lambda () (return 4))) (+ 1 2)))
 140          foo)
 141   4)
 142
 143 (test-js-eval block-lambda-dynamic-lambda
 144   ((lambda () (block nil ((lambda () (return 4))) (+ 1 2))))
 145   4)
 146
 147 (test-js-eval return-from-flet
 148   (progn (defun foo ()
 149            (flet ((bar () (return-from foo 42)))
 150              (bar)))
 151          (foo))
 152   42)
 153
 154 (test-js-eval plus-block
 155   (1+ (block nil (return 4) (+ 1 2)))
 156   5)
 157
 158 (test-js-eval let-closures-rename
 159   (progn (defun make-closures ()
 160            (list
 161             (let ((x 1)) (lambda () (1+ x)))
 162             (let ((x 2)) (lambda () (1+ x)))))
 163
 164          (defvar foo (make-closures))
 165
 166          (list (funcall (aref foo 0))
 167                (funcall (aref foo 1))))
 168   '(2 3))
 169
 170 (test-js-eval labels-return
 171   ((lambda ()
 172      (labels ((bar (x)
 173                 (when (evenp x)
 174                   (return-from bar "even"))
 175                 1))
 176        (bar 9))))
 177   1)
 178
 179 (test-js-eval labels-return1
 180   (progn (defun foo ()
 181            (labels ((bar (x)
 182                       (when (evenp x)
 183                         (return-from foo "even"))
 184                       1))
 185              (bar 8)
 186              2))
 187          (foo))
 188   "even")
 189
 190 (test-js-eval labels-return2
 191   (progn (defun foo ()
 192            (labels ((bar (x)
 193                       (flet ((foo (y)
 194                                (when (evenp (+ x y))
 195                                  (return-from bar "even"))))
 196                         (foo 4)
 197                         5)
 198                       1))
 199              (bar 8)))
 200          (foo))
 201   "even")
 202
 203 (test-js-eval labels-return3
 204   (progn (defun foo ()
 205            (labels ((bar (x)
 206                       (flet ((baz (y)
 207                                (when (evenp (+ x y))
 208                                  (return-from foo "even"))))
 209                         (baz 4)
 210                         5)
 211                       1))
 212              (bar 8)
 213              2))
 214          (foo))
 215   "even")
 216
 217 (test-js-eval toplevel-local-scope
 218   (progn (defvar foo (create "fn" (let ((x 5)) (lambda () x))))
 219          (funcall (getprop foo "fn")))
 220   5)
 221
 222 (test-js-eval special-var2
 223   (progn (defvar *foo*)
 224          (let* ((*baz* 3)
 225                 (*foo* 2))
 226            (* *foo* 2 *baz*)))
 227   12)
 228
 229 (test-js-eval special-var3
 230   (progn (defvar *foo* 1)
 231          (+ *foo* (let* ((*baz* 3)
 232                          (*foo* 2))
 233                     (* *foo* 2 *baz*))))
 234   13)
 235
 236 (test-js-eval let3
 237   (let ((x 3)
 238         (y 2))
 239     (+ x x))
 240   6)
 241
 242 (test-js-eval operator-expressions-array-nested-let
 243   (list (let ((y 1)) y) 2)
 244   '(1 2))
 245
 246 (test-js-eval block-return-plus
 247   (+ 1 (block foobar (return-from foobar 2) 1))
 248   3)
 249
 250 (test-js-eval block-return-plus1
 251   (+ 1 (block foobar (+ 4 ((lambda (x) (return-from foobar x)) 2)) 1))
 252   3)
 253
 254 (test-js-eval block-let
 255   (block foobar
 256     (let ((x 1))
 257       (return-from foobar x)
 258       2))
 259   1)
 260
 261 (test-js-eval block-dynamic-return
 262   (block nil (return 4) (+ 1 2))
 263   4)
 264
 265 (test-js-eval block-lambda-dynamic-return
 266   (block nil ((lambda () (return 4))) (+ 1 2))
 267   4)
 268
 269 (test-js-eval nil-block-return-1
 270   (block nil (return 1) 2)
 271   1)
 272
 273 (test-js-eval dolist-return
 274   (dolist (x '(5 2 3))
 275     (return (1+ x)))
 276   6)
 277
 278 (test-js-eval let-defun-toplevel
 279   (progn (let ((foo 0))
 280            (defun bar () foo))
 281          (bar))
 282   0)
 283
 284 (test-js-eval let-defvar-toplevel
 285   (progn (let ((foo 0))
 286            (defvar bar (1+ foo)))
 287          bar)
 288   1)
 289
 290 (test-js-eval values-not-returned
 291   (let ((x 1))
 292     (setf x (+ x (values 2 (incf x))))
 293     x)
 294   3)
 295
 296 (test-js-eval equality-nary1
 297   (let ((x 10) (y 10) (z 10))
 298     (= x y z))
 299   t)
 300
 301 (test-js-eval values-not-returned1
 302   (let ((x 1))
 303     (incf x (+ x (values 1 (incf x))))
 304     x)
 305   4)
 306
 307 (test-js-eval incf-incf
 308   (let ((x 1))
 309     (incf x (incf x))
 310     x)
 311   4)
 312
 313 (test-js-eval incf-setf
 314   (let ((x 1))
 315     (incf x (setf x 4))
 316     x)
 317   8)
 318
 319 (test-js-eval values0
 320   ((lambda () (values)))
 321   :null)
 322
 323 (test-js-eval mv-return1
 324   (progn (defun foo ()
 325            (values 1 2 3))
 326          (multiple-value-bind (a b c) (foo)
 327            (list a b c)))
 328   '(1 2 3)) ;; cl-js doesn't define callee.caller - fixme
 329
 330 (test-js-eval dynamic-extent-function-return-values
 331   (progn (defun foo ()
 332            ((lambda ()
 333               (return-from foo (values 1 2 3)))))
 334          (multiple-value-bind (a b c) (foo)
 335            (list a b c)))
 336   '(1 2 3)) ;; cl-js doesn't define callee.caller - fixme
 337
 338 (test-js-eval plus-not-associative
 339   (let ((str "a")
 340         (n 1))
 341     (+ str (+ n 1)))
 342   "a2")
 343
 344 (test-js-eval loop-return
 345   (progn (defun foo ()
 346            (* 10 (loop for i from 0 below 10 do
 347                       (when (> i 3)
 348                         (return i)))))
 349          (foo))
 350   40)
 351
 352 (test-js-eval loop-with-clause
 353   (loop for i :from 0 :to 5
 354         with x
 355         unless (< i 3)
 356      do (return (setf x i)))
 357   3)
 358
 359 (test-js-eval loop-extended-conditional-clauses
 360   (loop for i :from 0 :to 5
 361      for x := (1+ i)
 362      when x
 363        collect x
 364        and if (oddp x)
 365          collect (1+ x)
 366        else
 367          collect (/ x 2)
 368        end)
 369   '(1 2 2 1 3 4 4 2 5 6 6 3))
 370
 371 (test-js-eval loop-extended-conditional-clauses1
 372   (let* ((foo 0)
 373          (bar (loop for i :from 0 :to 5
 374                  for x := (1+ i)
 375                  when x
 376                    collect x
 377                    and if (oddp x)
 378                      collect (1+ x)
 379                    else
 380                      collect (/ x 2)
 381                    end
 382                    and do (incf foo x))))
 383     (funcall (@ bar push) foo)
 384     bar)
 385   '(1 2 2 1 3 4 4 2 5 6 6 3 21))