tests/eval-tests.lisp

   1 ;;; Copyright 2011-2012 Vladimir Sedach
   2
   3 ;;; SPDX-License-Identifier: BSD-3-Clause
   4
   5 ;;; Redistribution and use in source and binary forms, with or
   6 ;;; without modification, are permitted provided that the following
   7 ;;; conditions are met:
   8
   9 ;;; 1. Redistributions of source code must retain the above copyright
  10 ;;; notice, this list of conditions and the following disclaimer.
  11
  12 ;;; 2. Redistributions in binary form must reproduce the above
  13 ;;; copyright notice, this list of conditions and the following
  14 ;;; disclaimer in the documentation and/or other materials provided
  15 ;;; with the distribution.
  16
  17 ;;; 3. Neither the name of the copyright holder nor the names of its
  18 ;;; contributors may be used to endorse or promote products derived
  19 ;;; from this software without specific prior written permission.
  20
  21 ;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  22 ;;; CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  23 ;;; INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  24 ;;; MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  25 ;;; DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
  26 ;;; BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  27 ;;; EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  28 ;;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29 ;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  30 ;;; ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  31 ;;; OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32 ;;; OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33 ;;; POSSIBILITY OF SUCH DAMAGE.
  34
  35 (in-package #:parenscript.eval-tests)
  36 (named-readtables:in-readtable :parenscript)
  37
  38 #+sbcl (declaim (sb-ext:muffle-conditions sb-ext:compiler-note))
  39
  40 (fiveam:in-suite parenscript.tests::eval-tests)
  41
  42 (test-js-eval number
  43   3
  44   3)
  45
  46 (test-js-eval float
  47   (< 123.12 123.123 123.124)
  48   t)
  49
  50 (test-js-eval string
  51   "foobar"
  52   "foobar")
  53
  54 (test-js-eval statements-and-expressions-2
  55   ((lambda () (if 1 2 3)))
  56   2)
  57
  58 (test-js-eval statements-and-expressions-1
  59   ((lambda () (+ 2 (if 1 2 3))))
  60   4)
  61
  62 (test-js-eval empty-array
  63   (array)
  64   '())
  65
  66 (test-js-eval funargs-let1
  67   ((lambda (x)
  68      (let ((x 10))
  69        (incf x))
  70      (incf x))
  71    0)
  72   1)
  73
  74 (test-js-eval times-rem
  75   (* 12 (rem 10 3))
  76   12)
  77
  78 (test-js-eval divide-rem
  79   (rem 10 (/ 12 4))
  80   1)
  81
  82 (test-js-eval rem-divide
  83   (/ 9 (rem 11 4))
  84   3)
  85
  86 (test-js-eval rem-multiply
  87   (* 5 (rem 4 3))
  88   5)
  89
  90 (test-js-eval case-return-break-null
  91   ((lambda (x) (case x
  92                  (1)
  93                  (2 3)))
  94    1)
  95   :null)
  96
  97 (test-js-eval defun-return1
  98   (progn (defun bar (x) (1+ x))
  99          (bar 1))
 100   2)
 101
 102 (test-js-eval defun-return2
 103   (progn (defun bar (fn)
 104            (funcall fn))
 105
 106          (defun foo ()
 107            (bar (lambda () (return-from foo 123))))
 108
 109          (foo))
 110   123)
 111
 112 (test-js-eval defvar
 113   (progn (defvar foo 1)
 114          foo)
 115   1)
 116
 117 (test-js-eval block-dynamic-lambda
 118   ((lambda () (block nil (return 4) (+ 1 2))))
 119   4)
 120
 121 (test-js-eval block-dynamic-lambda1
 122   ((lambda () (block nil (return 4) (+ 1 2)) 5))
 123   5)
 124
 125 (test-js-eval loop-sum
 126   (+ 1 (loop for i from 0 to 10 sum i))
 127   56)
 128
 129 (test-js-eval loop-funcall-sum
 130   ((lambda (x) (1+ x)) (loop for i from 0 to 10 sum i))
 131   56)
 132
 133 (test-js-eval loop-funcall-if-sum
 134   (progn (defun one-plus (x)
 135            (1+ x))
 136
 137          (one-plus (if false 1 (loop for i from 0 to 10 sum i))))
 138   56)
 139
 140 (test-js-eval case-return-break1-broken-return
 141   (progn (defun foo (x y)
 142            (case x
 143              ("bar" (if y (return-from foo 1)))
 144              ("baz" 2)))
 145          (list (foo "bar" t) (foo "bar" nil) (foo "baz" nil)))
 146   '(1 :null 2))
 147
 148 (test-js-eval funcall-loop-doing
 149   ((lambda (x) x)
 150    (loop for i from 0 to 10 do (1+ i)))
 151   :undefined)
 152
 153 (test-js-eval block-dynamic-lambda2
 154   ((lambda () (1+ (block nil (return 4) (+ 1 2)))))
 155   5)
 156
 157 (test-js-eval block-dynamic-setf
 158   (progn (defvar foo (block nil (return 4) (+ 1 2)))
 159          foo)
 160   4)
 161
 162 (test-js-eval block-dynamic-return1
 163   (progn (defvar foo ((lambda ()
 164                         (block nil
 165                           ((lambda () (return 6)))
 166                           (+ 1 2)))))
 167          foo)
 168   6)
 169
 170 (test-js-eval block-lambda-dynamic-setf
 171   (progn (defvar foo (block nil ((lambda () (return 4))) (+ 1 2)))
 172          foo)
 173   4)
 174
 175 (test-js-eval block-lambda-dynamic-lambda
 176   ((lambda () (block nil ((lambda () (return 4))) (+ 1 2))))
 177   4)
 178
 179 (test-js-eval return-from-flet
 180   (progn (defun foo ()
 181            (flet ((bar () (return-from foo 42)))
 182              (bar)))
 183          (foo))
 184   42)
 185
 186 (test-js-eval plus-block
 187   (1+ (block nil (return 4) (+ 1 2)))
 188   5)
 189
 190 (test-js-eval let-closures-rename
 191   (progn (defun make-closures ()
 192            (list
 193             (let ((x 1)) (lambda () (1+ x)))
 194             (let ((x 2)) (lambda () (1+ x)))))
 195
 196          (defvar foo (make-closures))
 197
 198          (list (funcall (aref foo 0))
 199                (funcall (aref foo 1))))
 200   '(2 3))
 201
 202 (test-js-eval labels-return
 203   ((lambda ()
 204      (labels ((bar (x)
 205                 (when (evenp x)
 206                   (return-from bar "even"))
 207                 1))
 208        (bar 9))))
 209   1)
 210
 211 (test-js-eval labels-return1
 212   (progn (defun foo ()
 213            (labels ((bar (x)
 214                       (when (evenp x)
 215                         (return-from foo "even"))
 216                       1))
 217              (bar 8)
 218              2))
 219          (foo))
 220   "even")
 221
 222 (test-js-eval labels-return2
 223   (progn (defun foo ()
 224            (labels ((bar (x)
 225                       (flet ((foo (y)
 226                                (when (evenp (+ x y))
 227                                  (return-from bar "even"))))
 228                         (foo 4)
 229                         5)
 230                       1))
 231              (bar 8)))
 232          (foo))
 233   "even")
 234
 235 (test-js-eval labels-return3
 236   (progn (defun foo ()
 237            (labels ((bar (x)
 238                       (flet ((baz (y)
 239                                (when (evenp (+ x y))
 240                                  (return-from foo "even"))))
 241                         (baz 4)
 242                         5)
 243                       1))
 244              (bar 8)
 245              2))
 246          (foo))
 247   "even")
 248
 249 (test-js-eval toplevel-local-scope
 250   (progn (defvar foo (create "fn" (let ((x 5)) (lambda () x))))
 251          (funcall (getprop foo "fn")))
 252   5)
 253
 254 (test-js-eval special-var2
 255   (progn (defvar *foo*)
 256          (let* ((*baz* 3)
 257                 (*foo* 2))
 258            (* *foo* 2 *baz*)))
 259   12)
 260
 261 (test-js-eval special-var3
 262   (progn (defvar *foo* 1)
 263          (+ *foo* (let* ((*baz* 3)
 264                          (*foo* 2))
 265                     (* *foo* 2 *baz*))))
 266   13)
 267
 268 (test-js-eval let3
 269   (let ((x 3)
 270         (y 2))
 271     (+ x x))
 272   6)
 273
 274 (test-js-eval operator-expressions-array-nested-let
 275   (list (let ((y 1)) y) 2)
 276   '(1 2))
 277
 278 (test-js-eval block-return-plus
 279   (+ 1 (block foobar (return-from foobar 2) 1))
 280   3)
 281
 282 (test-js-eval block-return-plus1
 283   (+ 1 (block foobar (+ 4 ((lambda (x) (return-from foobar x)) 2)) 1))
 284   3)
 285
 286 (test-js-eval block-let
 287   (block foobar
 288     (let ((x 1))
 289       (return-from foobar x)
 290       2))
 291   1)
 292
 293 (test-js-eval block-dynamic-return
 294   (block nil (return 4) (+ 1 2))
 295   4)
 296
 297 (test-js-eval block-lambda-dynamic-return
 298   (block nil ((lambda () (return 4))) (+ 1 2))
 299   4)
 300
 301 (test-js-eval nil-block-return-1
 302   (block nil (return 1) 2)
 303   1)
 304
 305 (test-js-eval dolist-return
 306   (dolist (x '(5 2 3))
 307     (return (1+ x)))
 308   6)
 309
 310 (test-js-eval let-defun-toplevel
 311   (progn (let ((foo 0))
 312            (defun bar () foo))
 313          (bar))
 314   0)
 315
 316 (test-js-eval let-defvar-toplevel
 317   (progn (let ((foo 0))
 318            (defvar bar (1+ foo)))
 319          bar)
 320   1)
 321
 322 (test-js-eval values-not-returned
 323   (let ((x 1))
 324     (setf x (+ x (values 2 (incf x))))
 325     x)
 326   3)
 327
 328 (test-js-eval equality-nary1
 329   (let ((x 10) (y 10) (z 10))
 330     (= x y z))
 331   t)
 332
 333 (test-js-eval values-not-returned1
 334   (let ((x 1))
 335     (incf x (+ x (values 1 (incf x))))
 336     x)
 337   4)
 338
 339 (test-js-eval incf-incf
 340   (let ((x 1))
 341     (incf x (incf x))
 342     x)
 343   4)
 344
 345 (test-js-eval incf-setf
 346   (let ((x 1))
 347     (incf x (setf x 4))
 348     x)
 349   8)
 350
 351 (test-js-eval values0
 352   ((lambda () (values)))
 353   :null)
 354
 355 (test-js-eval mv-return1
 356   (progn (defun foo ()
 357            (values 1 2 3))
 358          (multiple-value-bind (a b c) (foo)
 359            (list a b c)))
 360   '(1 2 3))
 361
 362 (test-js-eval dynamic-extent-function-return-values
 363   (progn (defun foo ()
 364            ((lambda ()
 365               (return-from foo (values 1 2 3)))))
 366          (multiple-value-bind (a b c) (foo)
 367            (list a b c)))
 368   '(1 2 3))
 369
 370 (test-js-eval plus-not-associative
 371   (let ((str "a")
 372         (n 1))
 373     (+ str (+ n 1)))
 374   "a2")
 375
 376 (test-js-eval loop-return
 377   (progn (defun foo ()
 378            (* 10 (loop for i from 0 below 10 do
 379                       (when (> i 3)
 380                         (return i)))))
 381          (foo))
 382   40)
 383
 384 (test-js-eval for-arr-place-in
 385   (loop :for (a b) :in '((2 3) (4 5)) :sum (+ a b))
 386   14)
 387
 388 (test-js-eval for-obj-place-in
 389   (loop :for (:a :b) :in (list (create :a 2 :b 3)
 390                                (create :a 4 :b 5))
 391     :summing (+ a b))
 392   14)
 393
 394 (test-js-eval for-arr-place-=
 395   (flet ((foo () '(2 3)))
 396     (loop :repeat 3 :for (a b) = (foo) :sum (+ a b)))
 397   15)
 398
 399 (test-js-eval for-obj-place-=
 400   (flet ((foo () (create :a 2 :b 3)))
 401     (loop :repeat 3 :for (:a :b) = (foo) :sum (+ a b)))
 402   15)
 403
 404 (test-js-eval loop-until1
 405    (let ((x 0))
 406      (loop :doing (incf x) :until t)
 407      x)
 408    1)
 409
 410 (test-js-eval loop-until2
 411   (let ((b nil) (c nil))
 412     (loop :for a :in '(4 9 10) :do (setf b a) :until (> a 5))
 413     (loop :for a :in '(4 9 10) :until (> a 5) :do (setf c a))
 414     (list b c))
 415   '(9 4))
 416
 417 (test-js-eval loop-until3
 418    (let ((x 0) (y 0))
 419      (loop :do (incf x) :until (= x 5)
 420        :do (incf y) :until (= y 3))
 421      (list x y))
 422    '(3 3))
 423
 424 (test-js-eval loop-with-clause
 425   (loop for i :from 0 :to 5
 426         with x
 427         unless (< i 3)
 428      do (return (setf x i)))
 429   3)
 430
 431 (test-js-eval loop-append
 432    (loop :for i :from 0 :below 10 :by 3 :append (list i (* i 100)))
 433    '(0 0 3 300 6 600 9 900))
 434
 435 (test-js-eval loop-appending
 436    (loop :for i :from 0 :below 10 :by 3 :appending (list i (* i 100)))
 437    '(0 0 3 300 6 600 9 900))
 438
 439 (test-js-eval loop-maximize
 440    (loop :for i :in (list 1 5 3 2) :maximize i)
 441    5)
 442
 443 (test-js-eval loop-maximizing
 444    (loop :for i :in (list 1 5 3 7) :maximizing i)
 445    7)
 446
 447 (test-js-eval loop-minimize
 448    (loop :for i :in (list 1 5 3 2) :minimize i)
 449    1)
 450
 451 (test-js-eval loop-minimizing
 452    (loop :for i :in (list 3 5 3 2) :minimizing i)
 453    2)
 454
 455 (test-js-eval loop-for-on
 456    (loop :for (a b) :on '(10 20 30 40 50 60) :by 2 :collect (list b a))
 457    '((20 10) (40 30) (60 50)))
 458
 459 (test-js-eval loop-parallel-clauses-with-return
 460    (loop :for i :from 0 :below 10 :for x = (* i 10)
 461      :when (> i 5) :do (return x)
 462      :collecting i)
 463    60)
 464
 465 (test-js-eval loop-extended-conditional-clauses
 466   (loop for i :from 0 :to 5
 467      for x := (1+ i)
 468      when x
 469        collect x
 470        and if (oddp x)
 471          collect (1+ x)
 472        else
 473          collect (/ x 2)
 474        end)
 475   '(1 2 2 1 3 4 4 2 5 6 6 3))
 476
 477 (test-js-eval loop-extended-conditional-clauses1
 478   (let* ((foo 0)
 479          (bar (loop for i :from 0 :to 5
 480                  for x := (1+ i)
 481                  when x
 482                    collect x
 483                    and if (oddp x)
 484                      collect (1+ x)
 485                    else
 486                      collect (/ x 2)
 487                    end
 488                    and do (incf foo x))))
 489     (funcall (@ bar push) foo)
 490     bar)
 491   '(1 2 2 1 3 4 4 2 5 6 6 3 21))
 492
 493 (test-js-eval for-loop-downfrom-to
 494   (loop for i :downfrom 5 :to 0
 495     collect i)
 496   '(5 4 3 2 1 0))
 497
 498 (test-js-eval for-loop-downfrom-above
 499   (loop for i :downfrom 5 :above 0
 500     collect i)
 501   '(5 4 3 2 1))
 502
 503 (test-js-eval loop-conditional-return-works
 504   (block nil
 505     (dotimes (i 10)
 506       (if (< 10 i) (return i)))
 507     (return -1))
 508   -1)
 509
 510 (test-js-eval return-from-loop
 511   (let ((a 0))
 512     (dolist (x '(2 1 3))
 513       (when (= x 1)
 514         (return))
 515       (incf a))
 516     a)
 517   1)
 518
 519 (test-js-eval for-loop-var-init-exp
 520   ((lambda (x)
 521      (do* ((y (if x 0 1) (1+ y))
 522            (z 0 (1+ z)))
 523           ((= y 3) z)))
 524    true)
 525   3)
 526
 527 (test-js-eval dolist-return1
 528   (dolist (x '(5 2 3))
 529     (return (1+ x)))
 530   6)
 531
 532 (test-js-eval lambda-nil-return-implicit-nested
 533   (progn (defun foo (x)
 534            (block nil
 535              (if x
 536                  (return 1)
 537                  (dotimes (i 4)
 538                    (return 1)))
 539              2))
 540
 541          (list (foo t) (foo nil)))
 542   '(1 2))
 543
 544 (test-js-eval case-clauses0
 545   (let* ((foo :bar)
 546          (bar :baz)
 547          (x bar))
 548     (case x
 549       ((:foo) 1)
 550       ((:bar :baz) 2)))
 551   2)
 552
 553 (test-js-eval case-clauses-false
 554   (* 2 (case (= 1 2)
 555          (1 1)
 556          (false 3)
 557          (2 5)
 558          (otherwise 7)))
 559   6)
 560
 561 (test-js-eval case-clauses-true
 562   (* 2 (case (= 2 2)
 563          (1 1)
 564          ((t) 3)
 565          (otherwise 7)))
 566   6)
 567
 568 ;;; needs MV pass-through to work
 569 ;; (test-js-eval multiple-value-call-twice
 570 ;;   (progn
 571 ;;     (defun foo (x &optional y z)
 572 ;;       (if z
 573 ;;           (values x y z)
 574 ;;           (values x y)))
 575
 576 ;;     (defun bar ()
 577 ;;       (foo 1 2 3)
 578 ;;       (foo 4 5))
 579
 580 ;;     (multiple-value-bind (a b c) (bar)
 581 ;;       (list a b c)))
 582 ;;   '(4 5 :undefined))
 583
 584 (test-js-eval recursive-values
 585   (progn
 586     (defun foo (x)
 587       (if (= 0 x)
 588           (values 1 2 3 4)
 589           (progn
 590             (foo 0)
 591             23)))
 592
 593     (defun bar ()
 594       (foo 1))
 595
 596     (multiple-value-bind (a b c d) (bar)
 597       (list a b c d)))
 598   '(23 :undefined :undefined :undefined))
 599
 600 (test-js-eval recursive-values1
 601   (progn
 602     (defun foo (x)
 603       (if (= 0 x)
 604           (values 1 2 3)
 605           (baz)))
 606
 607     (defun baz (x)
 608       (foo 0)
 609       23)
 610
 611     (defun bar ()
 612       (foo 1))
 613
 614     (multiple-value-bind (a b c d) (bar)
 615       (list a b c d)))
 616   '(23 :undefined :undefined :undefined))
 617
 618 (test-js-eval values-nonlocal-return
 619   (progn
 620     (defun foo (x)
 621       (if (= 0 x)
 622           (values 1 2 3)
 623           (progn
 624             (foo 0)
 625             (throw 23))))
 626
 627     (defun bar ()
 628       (try (foo 1)
 629            (:catch (e)
 630              27)))
 631
 632     (multiple-value-bind (a b c) (bar)
 633       (list a b c)))
 634   '(27 :undefined :undefined))
 635
 636 (test-js-eval values-nonlocal-return1
 637   (progn
 638     (defun foo (x)
 639       (if (= 0 x)
 640           (values 1 2 3)
 641           (bar 0)))
 642
 643     (defun bar (x)
 644       (try
 645        (if (= x 0)
 646            (progn
 647              (foo 0)
 648              (throw 11))
 649            (foo x))
 650        (:catch (e)
 651          27)))
 652
 653     (multiple-value-bind (a b c) (bar 1)
 654       (list a b c)))
 655   '(27 :undefined :undefined))
 656
 657 (test-js-eval values-nonlocal-return2
 658   (progn
 659     (defun foo (x)
 660       (try
 661        (if (= 0 x)
 662            (values 1 2 3)
 663            (bar))
 664        (:catch (e) 27)))
 665
 666     (defun bar ()
 667       (foo 0)
 668       (throw 13))
 669
 670     (multiple-value-bind (a b c) (foo 1)
 671       (list a b c)))
 672   '(27 :undefined :undefined))
 673
 674 (test-js-eval case-symbol-macro-key
 675   (symbol-macrolet ((x 1))
 676     (let ((blah 1))
 677       (case blah
 678         (0 3)
 679         (x 7)
 680         (t 13))))
 681   7)
 682
 683 (test-js-eval symbol-macro-funcall
 684   (symbol-macrolet ((bar (getprop Math 'min)))
 685     (funcall bar -1 2))
 686   -1)
 687
 688 (test-js-eval negative-mod
 689   (mod -12 7)
 690   2)
 691
 692 (test-js-eval negative-mod1
 693   (mod -12 (funcall (@ Math floor) 7.5))
 694   2)
 695
 696 (test-js-eval negative-mod2
 697   (1+ (mod -12 7))
 698   3)
 699
 700 (test-js-eval negative-rem
 701   (rem -12 7)
 702   -5)
 703
 704 (test-js-eval negative-rem1
 705   (rem -12 (funcall (@ Math floor) 7.5))
 706   -5)
 707
 708 (test-js-eval-epsilon trig1
 709   (sinh 3.14)
 710   11.530293)
 711
 712 (test-js-eval-epsilon trig2
 713   (sinh (floor 3.14))
 714   10.017875)
 715
 716 (test-js-eval-epsilon trig3
 717   (cosh 3.14)
 718   11.573576)
 719
 720 (test-js-eval-epsilon trig4
 721   (cosh (floor 3.14))
 722   10.067662)
 723
 724 (test-js-eval-epsilon trig5
 725   (tanh 3.14)
 726   0.9962602)
 727
 728 (test-js-eval-epsilon trig6
 729   (tanh (floor 3.14))
 730   0.9950548)
 731
 732 (test-js-eval-epsilon trig7
 733   (asinh 3.14)
 734   1.8618126)
 735
 736 (test-js-eval-epsilon trig8
 737   (asinh (floor 3.14))
 738   1.8184465)
 739
 740 (test-js-eval-epsilon trig7
 741   (acosh 3.14)
 742   1.8109914)
 743
 744 (test-js-eval-epsilon trig8
 745   (acosh (floor 3.14))
 746   1.7627472)
 747
 748 (test-js-eval-epsilon trig7
 749   (atanh 0.71)
 750   0.88718385)
 751
 752 (test-js-eval-epsilon trig8
 753   (atanh (expt -0.71 3))
 754   -0.37448788)
 755
 756 (test-js-eval let-let
 757   (let ((x (let ((y 12))
 758              (+ 1 2)
 759              y)))
 760     (1+ x))
 761   13)
 762
 763 (test-js-eval let-let1
 764   (let ((x (let ((y 12))
 765              (dolist (x '(1 2 3))
 766                (* x x))
 767              y)))
 768     (1+ x))
 769   13)
 770
 771 (test-js-eval array-init-1
 772   (make-array 2 :initial-contents '(10 20))
 773   '(10 20))
 774
 775 (test-js-eval array-init-2
 776   (make-array 5 :initial-element 10)
 777   '(10 10 10 10 10))
 778
 779 (test-js-eval dotimes-block-return
 780   (1+ (dotimes (x 3) (if (= x 2) (return (+ x x)))))
 781   5)
 782
 783 (test-js-eval labels-factorial
 784   (progn
 785     (defun fac (n)
 786       (labels ((f (n a)
 787                  (if (< n 2)
 788                      a
 789                      (f (- n 1) (* n a)))))
 790         (f n 1)))
 791     (fac 5))
 792   120)
 793
 794 (test-js-eval destructuring-bind1
 795   ((lambda (a)
 796      (when a
 797        (destructuring-bind (b . c)
 798            a
 799          (list b c))))
 800    '(1 2 3))
 801   '(1 (2 3)))
 802
 803 (test-js-eval defun-not-a-docstring
 804   (progn
 805     (defun foo ()
 806       "bar")
 807     (foo))
 808   "bar")
 809
 810 (test-js-eval lambda-not-a-docstring
 811   ((lambda () "bar"))
 812   "bar")
 813
 814 (test-js-eval loop-variable-capture1
 815   (let ((x (make-array 10)))
 816     (dotimes (i 10) (setf (aref x i) (lambda () i)))
 817     (loop for x across x sum (funcall x)))
 818   100)
 819
 820 (test-js-eval loop-variable-capture2
 821   (let ((x (make-array 10)))
 822     (dotimes (i 10)
 823       (let ((y i))
 824         (setf (aref x i) (lambda () y))))
 825     (loop for x across x sum (funcall x)))
 826   45)
 827
 828 (test-js-eval loop-variable-capture3
 829   (let ((x (make-array 10)))
 830     (dotimes (i 10)
 831       (let ((i i))
 832         (setf (aref x i) (lambda () i))))
 833     (loop for x across x sum (funcall x)))
 834   45)
 835
 836 (test-js-eval nested-let
 837   (let ((x (let ((y 94))
 838              y)))
 839     x)
 840   94)
 841
 842 (test-js-eval lambda-apply
 843   ((lambda (x)
 844      (apply (lambda (y) (1+ y))
 845             x))
 846    (list 6))
 847   7)
 848
 849 (test-js-eval subtract-associative
 850   (list (- 1 2 3)
 851         (- 1 (- 2 3)))
 852   '(-4 2))
 853
 854 (test-js-eval logand1
 855   (let ((x 4583))
 856     (setf x (logand x 947))
 857     x)
 858   419)
 859
 860 (test-js-eval cons-cdr-clause-empty
 861   ((lambda () (cond (923))))
 862   923)
 863
 864 (test-js-eval labels-return-from
 865   (labels ((bar (x)
 866              (when (evenp x)
 867                (return-from bar "even"))
 868              "odd"))
 869     (bar 9))
 870   "odd")