envjs19 0.3.8.20101029121421

data/test/unit/fixtures/external_script.js

@@ -0,0 +1 @@
+var $$$$$ = "12345";

data/test/unit/form.js

@@ -0,0 +1,40 @@
+module("form");
+
+test("__param__ without a boundary should do query string style uri encoding", function() {
+  serialized_params = $master.static.__param__([{ name: 'username', value: 'jresig' }, { name: 'password', value: 'letmein' }]);
+  ok((serialized_params == 'username=jresig&password=letmein'), 'params should be key=value and joined by &');
+});
+
+test("__param__ without a boundary should escape spaces in values as + not %20", function() {
+  serialized_params = $master.static.__param__([{ name: 'username', value: 'jresig' }, { name: 'password', value: 'let me in' }]);
+  ok((serialized_params == 'username=jresig&password=let+me+in'), 'params should have spaces escaped as + not %20');
+});
+
+test("__param__ with a boundary should start with a -- then the boundary and a \\r\\n newline", function() {
+  serialized_params = $master.static.__param__([{ name: 'username', value: 'jresig' }, { name: 'password', value: 'letmein' }], '--aboundary');
+  ok(serialized_params.match(/^----aboundary\r\n/), 'params should start with a -- then the boundary and \\r\\n');
+});
+
+test("__param__ with a boundary should end with the boundary then -- and a \\r\\n newline", function() {
+  serialized_params = $master.static.__param__([{ name: 'username', value: 'jresig' }, { name: 'password', value: 'letmein' }], '--aboundary');
+  ok(serialized_params.match(/--aboundary--\r\n$/), 'params should end with the boundary then -- and \\r\\n');
+});
+
+test("__param__ with a boundary should render each key and value with a header, two \\r\\n newlines and the value", function() {
+  serialized_params = $master.static.__param__([{ name: 'username', value: 'jresig' }, { name: 'password', value: 'letmein' }], '--aboundary');
+  ok(serialized_params.match(/Content-Disposition: form-data; name="username"\r\n\r\njresig\r\n/), 'username not properly encoded');
+  ok(serialized_params.match(/Content-Disposition: form-data; name="password"\r\n\r\nletmein\r\n/), 'password not properly encoded');
+});
+
+test("__param__ with a boundary should separate each key-value with --, the boundary and a \\r\\n newline", function() {
+  serialized_params = $master.static.__param__([{ name: 'username', value: 'jresig' }, { name: 'password', value: 'letmein' }], '--aboundary');
+  ok(serialized_params.match(/jresig\r\n----aboundary\r\nContent-Disposition: form-data; name="password"/), 'username and password not properly separated');
+});
+
+test("__param__ with a boundary should not render spaces in data as + or %20", function() {
+  serialized_params = $master.static.__param__([{ name: 'username', value: 'jresig' }, { name: 'password', value: 'let me in' }], '--aboundary');
+  ok(!serialized_params.match(/let+me+in/), 'spaces incorrectly encoded as +');
+  ok(!serialized_params.match(/let%20me%20in/), 'spaces incorrectly encoded as %20');
+  ok(serialized_params.match(/let me in/), 'spaces not left as spaces');
+});
+

data/test/unit/iframe.js

@@ -0,0 +1,234 @@
+/*
+ * This file is a component of env.js,
+ *     http://github.com/gleneivey/env-js/commits/master/README
+ * a Pure JavaScript Browser Environment
+ * Copyright 2009 John Resig, licensed under the MIT License
+ *     http://www.opensource.org/licenses/mit-license.php
+ */
+
+
+module("iframe");
+
+
+// In general, the tests here use the files ../html/iframe*.html
+// I've tried to keep all of the id attributes and text fragments in these
+//   files unique from each other and from the content of index.html
+//   to ensure that we can correctly identify which file has loaded into
+//   which frame/window.  When making modifications/additions, paying
+//   attention to uniqueness is recommended.
+
+
+// all tests to next comment rely on content of ../html/iframe1.html and
+//                                              ../html/iframe1a.html
+
+    // iframe1 and iframe1a are identical in structure (so we can use the
+    //   same assertions against both), but different in content text (so
+    //   that we can tell which one is currently loaded).  So, create an
+    //   object (associative array) that is specific to the content of each.
+contentOfIframe1 = {
+    url : "html/iframe1.html",
+    titleRE : /IFRAME/,
+    elementId : 'anElementWithText',
+    elementRE : /content of a paragraph/
+};
+contentOfIframe1a = {
+    url : "html/iframe1a.html",
+    titleRE : /iframe1a.html/,
+    elementId : 'anotherElementWithText',
+    elementRE : /block-quote element/
+};
+
+var accessChecksForIframe1 = function(flag, iframe, contentOf) {
+    expect(6);
+
+    try{ok (iframe.src == contentOf.url,
+        flag + ": Initial iframe src matches test page source");
+    }catch(e){print(e);}
+
+    var idoc = iframe.contentDocument;
+    var mtch = idoc.title.match(contentOf.titleRE);
+    try{ok (mtch && mtch.length > 0,
+        flag + ": Can get 'document' object from test iframe");
+    }catch(e){print(e);}
+
+    var para = idoc.getElementById(contentOf.elementId);
+    mtch = para.innerHTML.match(contentOf.elementRE);
+    try{ok (mtch && mtch.length > 0,
+        flag + ": Can get text from element in an iframe");
+    }catch(e){print(e);}
+
+    try{ok (idoc.parentWindow == iframe.contentWindow,
+        flag + ": doc's .parentWindow points to iframe's .contentWindow");
+    }catch(e){print(e);}
+
+    try{ok (idoc.parentWindow.parent == window,
+        flag + ": Can follow chain from iframe's doc to containing window");
+    }catch(e){print(e);}
+
+    try{ok (iframe.contentWindow.top == window,
+        flag + ": '.top' from iframe does point to top window");
+    }catch(e){print(e);}
+};
+
+test("IFRAMEs load with accessible content", function() {
+    var iframe = document.getElementById('loadediframe');
+    // iframe1.html loaded via src= attribute when index.html was parsed
+    accessChecksForIframe1("1", iframe, contentOfIframe1);
+});
+
+
+test("IFRAMEs still load when .src is set after the page is parsed",function() {
+    var iframe = document.getElementById('emptyiframe');
+    iframe.src = "html/iframe1.html";
+    accessChecksForIframe1("2", iframe, contentOfIframe1);
+});
+
+test("IFRAMEs reload with accessible content", function() {
+    var iframe = document.getElementById('loadediframe');
+    iframe.src = "html/iframe1a.html";
+    accessChecksForIframe1("3", iframe, contentOfIframe1a);
+});
+
+
+// this test relies on iframe3.html, iframe2.html, and iframeN.html
+test("IFRAMEs can be nested, created dynamically", function() {
+    var startingDepth = 3;
+    var endingDepth   = 7;
+    expect(5 + (10*((endingDepth - startingDepth)+1)));
+
+    // manually load iframe3.html
+    var firstIframe = document.getElementById('emptyiframe');
+    firstIframe.src = "html/iframe3.html";
+
+    // iframe3.html contains a static <iframe> element that loads iframe2.html,
+    // so at this point, we should have both loaded, with the structure that
+    //     index.html --contains--> iframe3.html --contains--> iframe2.html
+    // w/ id's =      emptyiframe               nested1Level
+
+
+
+    ////////////////////////////////////////
+    // first, verify that we've got the structure we expect:
+    var mtch = firstIframe.contentDocument.title.match(/nested-IFRAME/);
+    try{ok (mtch && mtch.length > 0,
+        "top-level IFRAME reloaded from correct source");
+    }catch(e){print(e);}
+
+    var secondIframe = firstIframe.contentDocument.
+      getElementById('nested1Level');
+    mtch = secondIframe.contentDocument.title.match(/IFRAME loading/);
+    try{ok (mtch && mtch.length > 0,
+        "can access content of an IFRAME nested in another");
+    }catch(e){print(e);}
+
+    try{ok (secondIframe.contentDocument.parentWindow.parent.parent == window,
+        "can follow path from nested IFRAME to root window");
+    }catch(e){print(e);}
+
+    try{ok (secondIframe.contentWindow.parent.parent == window,
+        "also path through .contentWindow to root window");
+    }catch(e){print(e);}
+
+    try{ok (secondIframe.contentWindow.top == window,
+        "nested IFRAME has correct .top");
+    }catch(e){print(e);}
+
+
+    ////////////////////////////////////////
+    // OK, now we'll programatically extend the nesting depth from 2 to many
+    window.numberNestedIframeLoads = 0;
+    window.winLoadCount = 0;
+    window.bodyLoadCount = 0;
+    window.frameLoadCount = 0;
+    for (var c = startingDepth, bottomIframe = secondIframe; c <= endingDepth;
+         c++){
+
+        // add a new iframe within the current leaf iframe
+        var newIframe = bottomIframe.contentDocument.createElement("iframe");
+        newIframe.setAttribute("id", "iframe_of_depth_" + c);
+        newIframe.setAttribute("onload", "iframeOnloadHandler();");
+        var bottomBody = bottomIframe.contentDocument.
+          getElementsByTagName('body')[0];
+
+        bottomBody.appendChild(newIframe);
+        newIframe.src = "iframeN.html";
+        bottomIframe = newIframe;
+
+
+
+        ////////////////////////////////////////
+        // verify contents of just-loaded iframe
+        mtch = bottomIframe.contentDocument.getElementById('nestingLevel').
+          innerHTML.match(/[0-9]+/);
+        try{ok (mtch && mtch.length > 0 && parseInt(mtch[0]) == c,
+            "nested " + c + " levels: can access content");
+        }catch(e){print(e);}
+
+        for (var aWindow = bottomIframe.contentWindow, cn = c; cn > 0; cn--)
+            aWindow = aWindow.parent;
+        try{ok (aWindow == window,
+            "nested " + c + " levels: can follow path to root window");
+        }catch(e){print(e);}
+
+        try{ok (bottomIframe.contentWindow.top == window,
+            "nested " + c + " levels: IFRAME has correct .top");
+        }catch(e){print(e);}
+
+
+
+        ////////////////////////////////////////
+        // verify events related to iframe load:
+        //  iframe.onload (container); window.onload and body.onload (contained)
+        var num = (c - startingDepth) + 1;
+        try{ok (num == window.numberNestedIframeLoads,
+            "nested " + c + " levels: event <script> executed");
+        }catch(e){print(e);}
+
+        try{ok (num == window.winLoadCount,
+            "nested " + c + " levels: window-onload handler executed");
+        }catch(e){print(e);}
+        try{ok (num == window.bodyLoadCount,
+            "nested " + c + " levels: body-onload handler executed");
+        }catch(e){print(e);}
+        try{ok (num == window.frameLoadCount,
+            "nested " + c + " levels: iframe-onload handler executed");
+        }catch(e){print(e);}
+
+        mtch = bottomIframe.contentWindow.parent.document.
+          getElementById("pCreatedIframeOnload" + num).innerHTML.
+          match(/para iframe onload ([0-9]+)/);
+        try{ok (mtch && mtch.length > 0 && parseInt(mtch[1]) == num,
+            "nested " + c + " levels: confirmed iframe-onload");
+        }catch(e){print(e);}
+        mtch = bottomIframe.contentDocument.
+          getElementById("pCreatedWindowOnload" + num).innerHTML.
+          match(/para window onload ([0-9]+)/);
+        try{ok (mtch && mtch.length > 0 && parseInt(mtch[1]) == num,
+            "nested " + c + " levels: confirmed window-onload");
+        }catch(e){print(e);}
+        mtch = bottomIframe.contentDocument.
+          getElementById("pCreatedBodyOnload" + num).innerHTML.
+          match(/para body onload ([0-9]+)/);
+        try{ok (mtch && mtch.length > 0 && parseInt(mtch[1]) == num,
+            "nested " + c + " levels: confirmed body-onload");
+        }catch(e){print(e);}
+    }
+});
+
+
+// all tests to next comment rely on content of ../html/iframe2.html
+test("IFRAMEs reload on assignment to 'src'", function() {
+    expect(2);
+
+    var iframe = document.getElementById('loadediframe');
+    iframe.src = "html/iframe2.html";
+    try{ok (iframe.src == "html/iframe2.html",
+        "iframe.src matches value assigned");
+    }catch(e){print(e);}
+
+    var para = iframe.contentDocument.getElementById('aParaInAnIframe');
+    var mtch = para.innerHTML.match(/short paragraph/);
+    try{ok (mtch && mtch.length > 0,
+        "IFRAME reloaded from correct source");
+    }catch(e){print(e);}
+});

data/test/unit/insertion.js

@@ -0,0 +1,23 @@
+module("insertion");
+
+test("inserting SELECT elements with multiple='multiple' should not raise an error", function() {
+  expect(3);
+  var div = document.createElement('div');
+  var html = "<select multiple='multiple'><option value='wheels'>Wheels within Wheels</option></select>";
+  ok(div.innerHTML = html, html);  
+  var select = document.createElement('select');
+  var x;
+  try {
+    select.type = "foo";
+  }catch(e){
+    x = e;
+  }
+  ok(x !== void(0), "should not allow setting type");
+  x = void(0);
+  try {
+    select.setAttribute("type","foo");
+  }catch(e){
+    x = e;
+  }
+  ok(x !== void(0), "should not allow setting type via setAttribute");
+});

data/test/unit/multi-window.js

@@ -0,0 +1,212 @@
+/*
+ * This file is a component of env.js,
+ *     http://github.com/gleneivey/env-js/commits/master/README
+ * a Pure JavaScript Browser Environment
+ * Copyright 2009 John Resig, licensed under the MIT License
+ *     http://www.opensource.org/licenses/mit-license.php
+ */
+
+
+module("multi-window");
+
+test("2nd window.location= operation flagged as error", function() {
+    expect(1);
+
+    if ( window.Envjs.interpreter === "Johnson" ) {
+      ok(true,"we don't object to setting window.location in Johnson, which will blitz the tests");
+    } else {
+      var gotAnException = false;
+      window.onload = function(){;};
+      try {
+        window.location = "html/trivial.html";
+      } catch (e){   gotAnException = true;                         }
+      try{ ok(gotAnException, "prohibited window.location setter call fails");
+         }catch(e){print(e);}
+    }
+});
+
+test("window.open()-related behavior and members", function() {
+    expect(30);
+
+    var anotherWin;
+    try{ ok(anotherWin = window.open("html/trivial.html"),
+        "'window.open' returns new object");
+    }catch(e){print(e);}
+
+    try{ ok(anotherWin.closed == false,
+        "2nd window knows that it is not-closed");
+    }catch(e){print(e);}
+
+    var mtch = anotherWin.document.getElementById('oneP').innerHTML.
+        match(/Nearly-empty HTML/);
+    try{ ok(mtch && mtch.length > 0,
+        "2nd window has correct contents");
+    }catch(e){print(e);}
+
+    try{ ok(anotherWin.opener == window,
+        "2nd window's .opener is original window");
+    }catch(e){print(e);}
+
+    try{ ok(anotherWin.top == anotherWin,
+        "2nd window's .top is itself");
+    }catch(e){print(e);}
+
+    try{ ok(anotherWin.parent == anotherWin,
+        "2nd window's .parent is itself");
+    }catch(e){print(e);}
+
+    try{ ok(anotherWin.document.referrer == location.href,
+        "2nd window's document.referrer points to this one");
+    }catch(e){print(e);}
+
+
+    try{ ok((anotherWin.location = "html/with_js.html") || true,
+        "1st explicit '.location=' completes without exception");
+    }catch(e){print(e);}
+
+    mtch = anotherWin.document.getElementById('HeaderLevel1').
+        innerHTML.match(/Hello/);
+    try{ ok(mtch && mtch.length > 0,
+        "location setter-loaded content is correct");
+    }catch(e){print(e);}
+
+
+    try{ ok((anotherWin.location = "html/trivial.html") || true,
+        "2nd explicit '.location=' completes without exception");
+    }catch(e){print(e);}
+
+    mtch = anotherWin.document.getElementById('oneP').innerHTML.
+        match(/Nearly-empty HTML/);
+    try{ ok(mtch && mtch.length > 0,
+        "2nd location setter-loaded content is correct");
+    }catch(e){print(e);}
+
+
+    var thirdWin;
+    try{ ok(thirdWin = window.open("html/with_js.html"),
+        "2nd 'window.open' returns 3rd window");
+    }catch(e){print(e);}
+
+    mtch = thirdWin.document.getElementById('HeaderLevel1').
+        innerHTML.match(/Hello/);
+    try{ ok(mtch && mtch.length > 0,
+        "3rd window's content is correct");
+    }catch(e){print(e);}
+
+    mtch = anotherWin.document.getElementById('oneP').innerHTML.
+        match(/Nearly-empty HTML/);
+    try{ ok(mtch && mtch.length > 0,
+        "after 3rd window, 2nd's content still correct");
+    }catch(e){print(e);}
+
+    try{ ok(document.title == "jQuery Test Suite",
+        "after 3rd window, original's content still correct");
+    }catch(e){print(e);}
+
+
+    try{ ok(thirdWin.getTestVariables()[0] == "hello, scope",
+        "function from open()'ed window's scope callable");
+    }catch(e){print(e);}
+
+    try{ ok(thirdWin.getTestVariables()[1] == undefined ||
+            thirdWin.getTestVariables()[1] == null,
+        "dynamically-created test variable in 3rd win doesn't exist yet");
+    }catch(e){print(e);}
+
+    try{ ok(thirdWin.setTestVariable(42) || true,
+        "call to fn to create variable in other window's scope w/o exception");
+    }catch(e){print(e);}
+
+    try{ ok(thirdWin.getTestVariables()[1] == 42,
+        "variable in other window's scope created correctly");
+    }catch(e){print(e);}
+
+    try{ ok(thirdWin.notAlwaysPresentVariable == 42,
+        "variable in other window's scope accessible directly, too");
+    }catch(e){print(e);}
+
+    try{ ok((thirdWin.location = "html/with_js.html") || true,
+        "3rd window's '.location=' worked without exception");
+    }catch(e){print(e);}
+
+    try{ ok(thirdWin.getTestVariables()[1] == undefined ||
+            thirdWin.getTestVariables()[1] == null,
+        "reloaded window has clean variable scope");
+    }catch(e){print(e);}
+
+    try{ ok(thirdWin.notAlwaysPresentVariable = 55,
+        "setting variable in other window's scope executes without exception");
+    }catch(e){print(e);}
+
+    try{ ok(thirdWin.getTestVariables()[1] == 55,
+        "directly-set variable visible to code executing in other scope");
+    }catch(e){print(e);}
+
+    try{ ok(window.notAlwaysPresentVariable == undefined ||
+            window.notAlwaysPresentVariable == null,
+        "creating variable in 3rd window scope doesn't affect original window");
+    }catch(e){print(e);}
+
+    try{ ok(anotherWin.notAlwaysPresentVariable == undefined ||
+            anotherWin.notAlwaysPresentVariable == null,
+        "creating variable in 3rd window scope doesn't affect 2nd window");
+    }catch(e){print(e);}
+
+
+    try{ ok(anotherWin.close() || true,
+        "'.close()' executed without exception");
+    }catch(e){print(e);}
+
+    try{ ok(anotherWin.closed == true,
+        "after closing window, '.closed' is true");
+    }catch(e){print(e);}
+
+    try{ ok(window.closed == false,
+        "closing 2nd window doesn't affect original window");
+    }catch(e){print(e);}
+
+    try{ ok(thirdWin.closed == false,
+        "closing 2nd window doesn't affect 3rd window");
+    }catch(e){print(e);}
+});
+
+test("window.reload() behavior", function() {
+    expect(3);
+
+    var testWindow = window.open("html/trivial.html");
+    testWindow.checkingScope = 17;
+    try{ ok(testWindow.location.reload() || true,
+        "'window.location.reload()' completes without exception");
+    }catch(e){print(e);}
+
+    var variableNoLongerDefined = false;
+    try {
+        variableNoLongerDefined = (testWindow.checkingScope == undefined);
+    } catch (e){
+        variableNoLongerDefined = true;
+    }
+    try{ ok(variableNoLongerDefined, "reloaded window has clean scope");
+    }catch(e){print(e);}
+
+    var mtch = testWindow.document.getElementById('oneP').innerHTML.
+        match(/Nearly-empty HTML/);
+    try{ ok(mtch && mtch.length > 0,
+        "reloaded window has correct contents");
+    }catch(e){print(e);}
+});
+
+test("window.replace() behavior", function() {
+    expect(2);
+
+    var testWindow = window.open("html/trivial.html");
+    try{ ok(testWindow.location.replace("html/with_js.html") || true,
+        "'window.location.replace()' completes without exception");
+    }catch(e){print(e);}
+
+    var mtch = testWindow.document.getElementById('HeaderLevel1').
+        innerHTML.match(/Hello/);
+    try{ ok(mtch && mtch.length > 0, "replaced window has correct content");
+    }catch(e){print(e);}
+});
+
+