X-Git-Url: http://git.hcoop.net/clinton/parenscript.git/blobdiff_plain/083b7f89d502756ecc7c6ab70c87b8f790bd6905..5ffb1ebaaff5e8f899fd4b1bd91b015f2c52d656:/t/ps-tests.lisp

diff --git a/t/ps-tests.lisp b/t/ps-tests.lisp
index 51c358a..69f1564 100644
--- a/t/ps-tests.lisp
+++ b/t/ps-tests.lisp
@@ -16,17 +16,17 @@
 
 (test-ps-js setf-side-effects
   (progn
-    (let* ((x 10))
+    (let ((x 10))
       (defun side-effect() 
         (setf x 4)
         (return 3))
       (setf x (+ 2 (side-effect) x 5))))
-  "var x = 10;
+  "var x1 = 10;
 function sideEffect() {
-  x = 4;
+  x1 = 4;
   return 3;
 };
-x = 2 + sideEffect() + x + 5;")
+x1 = 2 + sideEffect() + x1 + 5;")
 ;; Parenscript used to optimize incorrectly:
 ;;   var x = 10;
 ;;   function sideEffect() {
@@ -44,7 +44,7 @@ x = 2 + sideEffect() + x + 5;")
 
 (test-ps-js method-call-op-form-args
   ((@ (+ "" x) to-string) 1 2 :baz 3)
-  "('' + x).toString(1, 2, { baz : 3 })")
+  "('' + x).toString(1, 2, 'baz', 3)")
 
 (test-ps-js method-call-number
   ((@ 10 to-string))
@@ -90,18 +90,18 @@ x = 2 + sideEffect() + x + 5;")
     (is (char= char-before a-parenthesis))))
 
 (test-ps-js simple-slot-value
-  (let* ((foo (create :a 1)))
+  (let ((foo (create :a 1)))
     (alert (slot-value foo 'a)))
-  "var foo = { a : 1 };
-   alert(foo.a);")
+  "var foo1 = { a : 1 };
+   alert(foo1.a);")
 
 (test-ps-js buggy-slot-value
-   (let* ((foo (create :a 1))
-          (slot-name "a"))
+   (let ((foo (create :a 1))
+         (slot-name "a"))
     (alert (slot-value foo slot-name)))
-  " var foo = { a : 1 };
-    var slotName = 'a';
-    alert(foo[slotName]);
+  " var foo1 = { a : 1 };
+    var slotName2 = 'a';
+    alert(foo1[slotName2]);
    "); Last line was alert(foo.slotName) before bug-fix.
 
 (test-ps-js buggy-slot-value-two
@@ -181,18 +181,10 @@ x = 2 + sideEffect() + x + 5;")
                    ("u0080" . ,(code-char 128)) ;;Character over 127. Actually valid, parenscript escapes them to be sure.
                    ("uABCD" . ,(code-char #xabcd)))));; Really above ascii.
     (loop for (js-escape . lisp-char) in escapes
-          for generated = (ps1* `(let* ((x ,(format nil "hello~ahi" lisp-char)))))
-          for wanted = (format nil "var x = 'hello\\~ahi';" js-escape)
+          for generated = (ps-doc* `(let ((x ,(format nil "hello~ahi" lisp-char)))))
+          for wanted = (format nil "var x1 = 'hello\\~ahi';" js-escape)
           do (is (string= (normalize-js-code generated) wanted)))))
   
-(test-ps-js complicated-symbol-name1
-  grid-rows[foo].bar
-  "gridRows[foo].bar")
-
-(test-ps-js complicated-symbol-name2
-  *grid-rows*[foo].bar
-  "GRIDROWS[foo].bar")
-
 (test-ps-js slot-value-setf
   (setf (slot-value x 'y) (+ (+ a 3) 4))
   "x.y = (a + 3) + 4;")
@@ -211,42 +203,42 @@ x = 2 + sideEffect() + x + 5;")
 (test script-star-eval2
   (is (string= "x = 1;" (normalize-js-code (ps* '(setf x 1))))))
 
-(test-ps-js slot-value-null1
-  (slot-value foo nil)
-  "foo")
-
-(test-ps-js slot-value-null2
-  (slot-value foo 'nil)
-  "foo")
-
 (test-ps-js unquoted-nil
   nil
   "null")
 
 (test-ps-js list-with-single-nil
-  (array 'nil)
+  (array nil)
   "[null]")
 
-(test-ps-js quoted-nil
+(test-ps-js quoted-nil-is-array
   'nil
-  "null")
-
-(test defsetf1
-  (ps (defsetf baz (x y) (newval) `(set-baz ,x ,y ,newval)))
-  (is (string= "var _js2 = 1; var _js3 = 2; var _js1 = 3; setBaz(_js2, _js3, _js1);"
-               (normalize-js-code (let* ((ps:*ps-gensym-counter* 0))
-                                    (ps (setf (baz 1 2) 3)))))))
-
-(test defsetf-short
-  (ps (defsetf baz set-baz "blah"))
-  (is (string= "setBaz(1, 2, 3, 'foo');" (normalize-js-code (ps (setf (baz 1 2 3) "foo"))))))
+  "[]")
 
-(test defun-setf1
-  (is (and (string= (normalize-js-code (ps:ps (defun (setf some-thing) (new-val i1 i2)
-                                                (setf (aref *some-thing* i1 i2) new-val))))
-               "function __setf_someThing(newVal, i1, i2) { SOMETHING[i1][i2] = newVal; };")
-           (string= (normalize-js-code (ps:ps-doc (setf (some-thing 1 2) "foo")))
-                    "var _js2 = 1; var _js3 = 2; var _js1 = 'foo'; __setf_someThing(_js1, _js2, _js3);"))))
+(test-ps-js defsetf1
+  (progn (defsetf baz (x y) (newval) `(set-baz ,x ,y ,newval))
+         (setf (baz 1 2) 3))
+  "var _js2_4 = 1;
+var _js3_5 = 2;
+var _js1_6 = 3;
+setBaz(_js2_4, _js3_5, _js1_6);")
+
+(test-ps-js defsetf-short
+  (progn (defsetf baz set-baz "docstring")
+         (setf (baz 1 2 3) "foo"))
+  "setBaz(1, 2, 3, 'foo');")
+
+(test-ps-js defun-setf1
+  (progn (defun (setf some-thing) (new-val i1 i2)
+           (setf (aref *some-thing* i1 i2) new-val))
+         (setf (some-thing 1 2) "foo"))
+"function __setf_someThing(newVal, i1, i2) {
+    SOMETHING[i1][i2] = newVal;
+};
+var _js2_4 = 1;
+var _js3_5 = 2;
+var _js1_6 = 'foo';
+__setf_someThing(_js1_6, _js2_4, _js3_5);")
 
 (test-ps-js defun-optional1
   (defun test-opt (&optional x) (return (if x "yes" "no")))
@@ -364,11 +356,11 @@ x = 2 + sideEffect() + x + 5;")
   "[[1, 2], ['a', 'b']]")
 
 (test-ps-js defun-rest1
-  (defun foo (&rest bar) (alert bar[1]))
+  (defun foo (&rest bar) (alert (aref bar 1)))
   "function foo() {
     var bar = [];
-    for (var i2 = 0; i2 < arguments.length - 0; i2 += 1) {
-        bar[i2] = arguments[i2 + 0];
+    for (var i1 = 0; i1 < arguments.length - 0; i1 += 1) {
+        bar[i1] = arguments[i1 + 0];
     };
     alert(bar[1]);
 }")
@@ -377,53 +369,109 @@ x = 2 + sideEffect() + x + 5;")
   (defun foo (baz &rest bar) (return (+ baz (aref bar 1))))
   "function foo(baz) {
     var bar = [];
-    for (var i2 = 0; i2 < arguments.length - 1; i2 += 1) {
-        bar[i2] = arguments[i2 + 1];
+    for (var i1 = 0; i1 < arguments.length - 1; i1 += 1) {
+        bar[i1] = arguments[i1 + 1];
     };
     return baz + bar[1];
 }")
 
 (test-ps-js defun-keyword1
   (defun zoo (foo bar &key baz) (return (+ foo bar baz)))
-  "function zoo(foo, bar, _js1) {
-    if (_js1 === undefined) {
-        _js1 = {  };
+"function zoo(foo, bar) {
+    var baz;
+    var _js2 = arguments.length;
+    for (var n1 = 2; n1 < _js2; n1 += 2) {
+        switch (arguments[n1]) {
+        case 'baz':
+            {
+                baz = arguments[n1 + 1];
+            };
+        };
+    };
+    if (baz === undefined) {
+        baz = null;
     };
-    return foo + bar + _js1.baz;
+    return foo + bar + baz;
 }")
 
 (test-ps-js defun-keyword2
   (defun zoo (&key baz) (return (* baz baz)))
-  "function zoo(_js1) {
-    if (_js1 === undefined) {
-        _js1 = {  };
+  "function zoo() {
+    var baz;
+    var _js2 = arguments.length;
+    for (var n1 = 0; n1 < _js2; n1 += 2) {
+        switch (arguments[n1]) {
+        case 'baz':
+            {
+                baz = arguments[n1 + 1];
+            };
+        };
     };
-    return _js1.baz * _js1.baz;
+    if (baz === undefined) {
+        baz = null;
+    };
+    return baz * baz;
 }")
 
 (test-ps-js defun-keyword3
   (defun zoo (&key baz (bar 4)) (return (* baz bar)))
-  "function zoo(_js1) {
-    if (_js1 === undefined) {
-        _js1 = {  };
+  "function zoo() {
+    var baz;
+    var bar;
+    var _js2 = arguments.length;
+    for (var n1 = 0; n1 < _js2; n1 += 2) {
+        switch (arguments[n1]) {
+        case 'baz':
+            {
+                baz = arguments[n1 + 1];
+            };
+            break;
+        case 'bar':
+            {
+                bar = arguments[n1 + 1];
+            };
+        };
     };
-    if (_js1.bar === undefined) {
-        _js1.bar = 4;
+    if (baz === undefined) {
+        baz = null;
     };
-    return _js1.baz * _js1.bar;
+    if (bar === undefined) {
+        bar = 4;
+    };
+    return baz * bar;
+}")
+
+(test-ps-js defun-keyword4
+  (defun hello-world (&key ((:my-name-key my-name) 1))
+    my-name)
+  "function helloWorld() {
+    var myName;
+    var _js2 = arguments.length;
+    for (var n1 = 0; n1 < _js2; n1 += 2) {
+        switch (arguments[n1]) {
+        case 'my-name-key':
+            {
+                myName = arguments[n1 + 1];
+            };
+        };
+    };
+    if (myName === undefined) {
+        myName = 1;
+    };
+    myName;
 }")
 
 (test-ps-js keyword-funcall1
   (func :baz 1)
-  "func({ baz : 1 })")
+  "func('baz', 1)")
 
 (test-ps-js keyword-funcall2
   (func :baz 1 :bar foo)
-  "func({ baz : 1, bar : foo })")
+  "func('baz', 1, 'bar', foo)")
 
 (test-ps-js keyword-funcall3
   (fun a b :baz c)
-  "fun(a, b, { baz : c })")
+  "fun(a, b, 'baz', c)")
   
 (test-ps-js cond1
   (cond ((= x 1) 1))
@@ -432,7 +480,8 @@ x = 2 + sideEffect() + x + 5;")
 }")
 
 (test-ps-js cond2
-  (cond ((= x 1) 2) ((= y (* x 4)) (foo "blah") (* x y)))
+  (cond ((= x 1) 2)
+        ((= y (* x 4)) (foo "blah") (* x y)))
   "if (x == 1) {
     2;
 } else if (y == x * 4) {
@@ -473,13 +522,13 @@ x = 2 + sideEffect() + x + 5;")
 }")
 
 (test-ps-js funcall-if-expression
-  (document.write
+  ((@ document write)
    (if (= *linkornot* 1)
        (ps-html ((:a :href "#"
                      :onclick (ps-inline (transport)))
                  img))
        img))
-  "document.write(LINKORNOT == 1 ? '<A HREF=\"#\" ONCLICK=\"' + ('javascript:' + 'transport()') + '\">' + img + '</A>' : img)")
+  "document.write(LINKORNOT == 1 ? '<A HREF=\"#\" ONCLICK=\"' + ('javascript:' + 'transport' + '(' + ')') + '\">' + img + '</A>' : img)")
 
 (test-ps-js negate-number-literal ;; ok, this was broken and fixed before, but no one bothered to add the test!
   (- 1)
@@ -542,37 +591,34 @@ x = 2 + sideEffect() + x + 5;")
 (test-ps-js let-decl-in-expression
   (defun f (x) (return (if x 1 (let* ((foo x)) foo))))
   "function f(x) {
-    var foo;
-    return x ? 1 : (foo = x, foo);
+    var foo1;
+    return x ? 1 : (foo1 = x, foo1);
 }")
 
 (test-ps-js special-var1
   (progn (defvar *foo*) (let* ((*foo* 2)) (* *foo* 2)))
   "var FOO;
-var tempstackvar1;
+var FOO1;
 try {
-    tempstackvar1 = FOO;
+    FOO1 = FOO;
     FOO = 2;
     FOO * 2;
 } finally {
-    FOO = tempstackvar1;
-    delete tempstackvar1;
+    FOO = FOO1;
 };")
 
 (test-ps-js special-var2
   (progn (defvar *foo*) (let* ((*baz* 3) (*foo* 2)) (* *foo* 2 *baz*)))
   "var FOO;
-var BAZ = 3;
-var tempstackvar1;
+var BAZ1 = 3;
+var FOO2;
 try {
-    tempstackvar1 = FOO;
+    FOO2 = FOO;
     FOO = 2;
-    FOO * 2 * BAZ;
+    FOO * 2 * BAZ1;
 } finally {
-    FOO = tempstackvar1;
-    delete tempstackvar1;
-};
-")
+    FOO = FOO2;
+};")
 
 (test-ps-js literal1
   (setf x undefined)
@@ -596,7 +642,7 @@ try {
 
 (test-ps-js setf-operator-priority
   (return (or (slot-value cache id)
-              (setf (slot-value cache id) (document.get-element-by-id id))))
+              (setf (slot-value cache id) ((@ document get-element-by-id) id))))
   "return cache[id] || (cache[id] = document.getElementById(id))")
 
 (test-ps-js aref-operator-priority
@@ -640,10 +686,6 @@ try {
   (instanceof (or a b) (if x y z))
   "((a || b) instanceof (x ? y : z))")
 
-(test-ps-js op-p6
-  (doeach (x (or a b)))
-  "for (var x in (a || b)) { };")
-
 (test-ps-js op-p7
   (or x (if (= x 0) "zero" "empty"))
   "x || (x == 0 ? 'zero' : 'empty')")
@@ -698,7 +740,7 @@ try {
                       (:a :href "http://foo.com"
                           symbol)
                       (:span :class "ticker-symbol-popup")))
-  "'<SPAN CLASS=\"ticker-symbol\" TICKER-SYMBOL=\"' + symbol + '\"><A HREF=\"http://foo.com\">' + symbol + '</A><SPAN CLASS=\"ticker-symbol-popup\"/></SPAN>'")
+  "'<SPAN CLASS=\"ticker-symbol\" TICKER-SYMBOL=\"' + symbol + '\"><A HREF=\"http://foo.com\">' + symbol + '</A><SPAN CLASS=\"ticker-symbol-popup\"></SPAN></SPAN>'")
 
 (test-ps-js flet1
   ((lambda () (flet ((foo (x) (return (1+ x)))) (return (foo 1)))))
@@ -735,3 +777,136 @@ try {
         return z;
     })();
 })(true)")
+
+(test-ps-js math-pi
+  pi
+  "Math.PI")
+
+(test-ps-js literal-array
+  '(1 2 3)
+  "[1, 2, 3]")
+
+(test-ps-js literal-array-1
+  '(1 foo 3)
+  "[1, 'foo', 3]")
+
+(test ps-lisp-expands-in-lexical-environment
+  (is (string= "5;" (let ((x 5)) (ps (lisp x))))))
+
+(test ps*-lisp-expands-in-null-lexical-environment
+  (signals error (let ((x 5)) (declare (ignore x)) (ps* '(lisp x)))))
+
+(test ps*-lisp-expands-in-dynamic-environment
+  (is (string= "1 + 2;" (let ((*print-level* 2)) (ps* '(+ 1 (lisp *print-level*)))))))
+
+(test ps-lisp-dynamic-environment
+  (is (string= "1 + 2;" (let ((*print-level* 2)) (ps (+ 1 (lisp *print-level*)))))))
+
+(test-ps-js ps-js-target-version-keyword-test1
+  (defun foo (x y &key bar baz))
+  "function foo(x, y) {
+    var x1_3 = Array.prototype.indexOf.call(arguments, 'bar', 2);
+    var bar = -1 == x1_3 ? null : arguments[x1_3 + 1];
+    var x2_4 = Array.prototype.indexOf.call(arguments, 'baz', 2);
+    var baz = -1 == x2_4 ? null : arguments[x2_4 + 1];
+}"
+  :js-target-version 1.6)
+
+(test-ps-js nested-if-expressions1
+  (return (if (if x y z) a b))
+  "return (x ? y : z) ? a : b")
+
+(test-ps-js nested-if-expressions2
+  (return (if x y (if z a b)))
+  "return x ? y : (z ? a : b)")
+
+(test-ps-js let1
+  (let (x)
+    (+ x x))
+  "var x1 = null;
+x1 + x1;")
+
+(test-ps-js let2
+  (let ((x 1))
+    (+ x x))
+  "var x1 = 1;
+x1 + x1;")
+
+(test-ps-js let3
+  (let ((x 1)
+        (y 2))
+    (+ x x))
+  "var x1 = 1;
+var y2 = 2;
+x1 + x1;")
+
+(test-ps-js let4
+  (let ((x 1)
+        (y (1+ x)))
+    (+ x y))
+  "var x1 = 1;
+var y2 = x + 1;
+x1 + y2;")
+
+(test-ps-js let5
+  (let ((x 1))
+    (+ x 1)
+    (let ((x (+ x 5)))
+      (+ x 1))
+    (+ x 1))
+  "var x1 = 1;
+x1 + 1;
+var x2 = x1 + 5;
+x2 + 1;
+x1 + 1;")
+
+(test-ps-js let6
+  (let ((x 2))
+    (let ((x 1)
+          (y (1+ x)))
+      (+ x y)))
+  "var x1 = 2;
+var x2 = 1;
+var y3 = x1 + 1;
+x2 + y3;")
+
+(test-ps-js let-exp1
+  (lambda ()
+    (return (let (x) (+ x x))))
+  "function () {
+    var x1;
+    return (x1 = null, x1 + x1);
+}")
+
+(test-ps-js let*1
+  (let* ((x 1)) (+ x x))
+"var x1 = 1;
+x1 + x1;")
+
+(test-ps-js let*2
+  (let* ((x 1)
+         (y (+ x 2)))
+    (+ x y))
+  "var x1 = 1;
+var y2 = x1 + 2;
+x1 + y2;")
+
+(test-ps-js let*3
+  (let ((x 3))
+        (let* ((x 1) 
+               (y (+ x 2))) 
+          (+ x y)))
+  "var x1 = 3;
+var x2 = 1;
+var y3 = x2 + 2;
+x2 + y3;")
+
+(test-ps-js let*4
+  (let ((x 3))
+        (let* ((y (+ x 2))
+               (x 1))
+          (+ x y)))
+  "var x1 = 3;
+var y2 = x1 + 2;
+var x3 = 1;
+x3 + y2;")