smparkes-envjs 0.0.3

data/test/qunit.smp/test/test.js

@@ -0,0 +1,136 @@
+test("module without setup/teardown (default)", function() {
+	expect(1);
+	ok(true);
+});
+
+test("expect in test", 3, function() {
+	ok(true);
+	ok(true);
+	ok(true);
+});
+
+test("expect in test", 1, function() {
+	ok(true);
+});
+
+module("setup test", {
+	setup: function() {
+		ok(true);
+	}
+});
+
+test("module with setup", function() {
+	expect(2);
+	ok(true);
+});
+
+var state;
+
+module("setup/teardown test", {
+	setup: function() {
+		state = true;
+		ok(true);
+	},
+	teardown: function() {
+		ok(true);
+	}
+});
+
+test("module with setup/teardown", function() {
+	expect(3);
+	ok(true);
+});
+
+module("setup/teardown test 2");
+
+test("module without setup/teardown", function() {
+	expect(1);
+	ok(true);
+});
+
+if (typeof setTimeout !== 'undefined') {
+state = 'fail';
+
+module("teardown and stop", {
+	teardown: function() {
+		equals(state, "done", "Test teardown.");
+	}
+});
+
+test("teardown must be called after test ended", function() {
+	expect(1);
+	stop();
+	setTimeout(function() {
+		state = "done";
+		start();
+	}, 13);
+});
+} // end setTimeout tests
+
+if (typeof asyncTest !== 'undefined') {
+module("asyncTest");
+
+asyncTest("asyncTest", function() {
+	expect(2);
+	ok(true);
+	setTimeout(function() {
+		state = "done";
+		ok(true);
+		start();
+	}, 13);
+});
+
+asyncTest("asyncTest", 2, function() {
+	ok(true);
+	setTimeout(function() {
+		state = "done";
+		ok(true);
+		start();
+	}, 13);
+});
+} // end asyncTest tests
+
+module("save scope", {
+	setup: function() {
+		this.foo = "bar";
+	},
+	teardown: function() {
+		same(this.foo, "bar");
+	}
+});
+test("scope check", function() {
+	expect(2);
+	same(this.foo, "bar");
+});
+
+module("simple testEnvironment setup", {
+	foo: "bar",
+	bugid: "#5311" // example of meta-data
+});
+test("scope check", function() {
+	same(this.foo, "bar");
+});
+test("modify testEnvironment",function() {
+	this.foo="hamster";
+});
+test("testEnvironment reset for next test",function() {
+	same(this.foo, "bar");
+});
+
+module("testEnvironment with object", {
+	options:{
+		recipe:"soup",
+		ingredients:["hamster","onions"]
+	}
+});
+test("scope check", function() {
+	same(this.options, {recipe:"soup",ingredients:["hamster","onions"]}) ;
+});
+test("modify testEnvironment",function() {
+	// since we do a shallow copy, the testEnvironment can be modified
+	this.options.ingredients.push("carrots");
+});
+test("testEnvironment reset for next test",function() {
+	same(this.options, {recipe:"soup",ingredients:["hamster","onions","carrots"]}, "Is this a bug or a feature? Could do a deep copy") ;
+});
+

data/test/rhino-call-load-test.js

@@ -0,0 +1,5 @@
+whichJarFile = "rhino"
+multiwindow = false;
+whichInterpreter = whichJarFile + " interpreter jar";
+load("dist/env.rhino.js");
+load("test/call-load-test.js");

data/test/test-with-envs-jar.js

@@ -0,0 +1,8 @@
+// Run 'test.js', letting it know that we're running with our customized
+// version of the JS interpreter: env-js.jar
+
+whichJarFile = "envjs";
+whichInterpreter = whichJarFile + " interpreter jar";
+multiwindow = true;
+load("dist/env.rhino.js");
+load("test/primaryTests.js");

data/test/test-with-rhino-jar.js

@@ -0,0 +1,9 @@
+// Run 'test.js', letting it know that we're running with the vanilla
+// unmodified version of the Rhino JS interpreter: rhino.jar
+
+whichJarFile = "rhino"
+whichInterpreter = whichJarFile + " interpreter jar";
+multiwindow = false;
+load("dist/env.rhino.js");
+load("test/primaryTests.js");
+

data/test/unit/dom.js

@@ -0,0 +1,43 @@
+// dependencies for the tests
+$w = { }
+$env = { debug: function() {} }
+$openingWindow = $parentWindow = $initTop = null;
+this.options = this.options || {}
+
+load("src/window/window.js", "src/dom/node.js");
+
+
+module("dom");
+
+test("Basic requirements", function() {
+	expect(5);
+	ok( Array.prototype.push, "Array.push()" );
+	ok( Function.prototype.apply, "Function.apply()" );
+	ok( document.getElementById, "getElementById" );
+	ok( document.getElementsByTagName, "getElementsByTagName" );
+	ok( RegExp, "RegExp" );
+});
+
+test("document.getElementById", function() {
+	expect(14);
+  try{ok (document.getElementById('body').id == "body", "Can get Element by id, expected id='body'");}catch(e){print(e);}
+  try{ok (document.getElementById('header').id == "header", "Can get Element by id, expected id='header'");}catch(e){print(e);}
+  try{ok (document.getElementById('banner').id == "banner", "Can get Element by id, expected id='banner'");}catch(e){print(e);}
+  try{ok (document.getElementById('userAgent').id == "userAgent", "Can get Element by id, expected id='userAgent'");}catch(e){print(e);}
+  try{ok (document.getElementById('nothiddendiv').id == "nothiddendiv", "Can get Element by id, expected id='nothiddendiv'");}catch(e){print(e);}
+  try{ok (document.getElementById('nothiddendivchild').id == "nothiddendivchild", "Can get Element by id, expected id='nothiddendivchild'");}catch(e){print(e);}
+  try{ok (document.getElementById('dl').id == "dl", "Can get Element by id, expected id='dl'");}catch(e){print(e);}
+  try{ok (document.getElementById('main').id == "main", "Can get Element by id, expected id='main'");}catch(e){print(e);}
+  try{ok (document.getElementById('firstp').id == "firstp", "Can get Element by id, expected id='firstp");}catch(e){print(e);}
+  try{ok (document.getElementById('simon1').id == "simon1", "Can get Element by id, expected id='simon1'");}catch(e){print(e);}
+  try{ok (document.getElementById('ap').id == "ap", "Can get Element by id, expected id='ap'");}catch(e){print(e);}
+  try{ok (document.getElementById('google').id == "google", "Can get Element by id, expected id='google'");}catch(e){print(e);}
+  try{ok (document.getElementById('groups').id == "groups", "Can get Element by id, expected id='groups'");}catch(e){print(e);}
+  try{ok (document.getElementById('台北Táiběi').id == "台北Táiběi", "Can get Element by UTF-8 id, expected id='台北Táiběi'");}catch(e){print(e);}
+});
+
+test("element.getElementsByTagName", function() {
+	expect(1);
+  var body = document.getElementById('body');
+  try{ok (body.getElementsByTagName('h1').length == 1, "Can get NodeList length : Expected 1 , Got " + body.getElementsByTagName('h1').length);}catch(e){print(e);}
+});

data/test/unit/elementmembers.js

@@ -0,0 +1,29 @@
+module("elementmembers");
+
+// We ought to have test coverage for all members of all DOM objects, but
+// until then, add test cases here for members as they are created
+
+test("attributes common to all HTML elements", function() {
+    expect(4);
+
+    // tests for .innerText
+    var mtch = document.getElementById('dl').innerText.match(
+        /^See this blog entry for more information.\s+Here are/);
+    try{ ok(mtch && mtch.length > 0,
+        "dl.innerText returns the correct content");
+    }catch(e){print(e);}
+
+    mtch = document.getElementById('sndp').innerText.match(/^Everything insid/);
+    try{ ok(mtch && mtch.length > 0,
+        "p.innerText returns the correct content");
+    }catch(e){print(e);}
+
+    try{ ok(document.getElementById('sndp').innerText = "test text" || true,
+        "p.innerText= operates without exception");
+    }catch(e){print(e);}
+
+    try{ ok(document.getElementById('sndp').innerText == "test text",
+        "p.innerText= changes content of element");
+    }catch(e){print(e);}
+});
+

data/test/unit/events.js

@@ -0,0 +1,195 @@
+/*
+ * 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("events");
+
+// This file is for tests of general event dispatching, propagation, and
+//   handling functionality.  In keeping with the general non-exhaustive
+//   approach of env.js's unit tests, each behavior is checked for one
+//   relevant type of event in one relevant context (page structure, etc.).
+
+// These tests rely on the content of ../html/events.html and of the
+//   <iframe id='eventsFrame'> tag in ../index.html.
+
+// These tests are order-dependent.  If you alter the order or add new tests
+//   in the middle, the expected values of eventFrameLoaded and
+//   eventFrameClicked may well change (perhaps requiring extra parameters
+//   to the *Checks convenience functions).
+
+
+var __click__ = function(element){
+    var event = new Event({
+      target:element,
+      currentTarget:element
+    });
+    event.initEvent("click");
+    element.dispatchEvent(event);
+}
+
+function loadChecks(tag, loadCount, imgCount, unloadCount){
+    expect(5);
+
+    var eCounters = window.top.eCounters;
+    try{ ok( eCounters["window onload"] == loadCount &&
+             eCounters["body onload"] == loadCount,
+        tag + ": Onload Events recorded");
+    }catch(e){print(e);}
+
+    try{ ok( eCounters["img onload"]  == imgCount,
+        tag + ": Img-tag onload event(s) recorded separately");
+    }catch(e){print(e);}
+
+    try{ ok( eCounters["window onunload"] == unloadCount &&
+             eCounters["body onunload"] == unloadCount,
+        tag + ": Onunload events recorded");
+    }catch(e){print(e);}
+
+    try{ ok( eCounters["body onclick"] == 0 &&
+             eCounters["h1 onclick"] == 0 &&
+             eCounters["h2 onclick"] == 0 &&
+             eCounters["div onclick"] == 0 &&
+             eCounters["table onclick"] == 0 &&
+             eCounters["tbody onclick"] == 0 &&
+             eCounters["tr onclick"] == 0 &&
+             eCounters["td onclick"] == 0 &&
+             eCounters["ul onclick"] == 0 &&
+             eCounters["li onclick"] == 0 &&
+             eCounters["p onclick"] == 0 &&
+             eCounters["b onclick"] == 0 &&
+             eCounters["i onclick"] == 0 &&
+             eCounters["a onclick"] == 0 &&
+             eCounters["img onclick"] == 0,
+        tag + ": Onload events recorded once.");
+    }catch(e){print(e);}
+
+    try{ ok( eventFrameLoaded == loadCount && eventFrameClicked == 0,
+        tag + ": " + loadCount + " iframe events recorded on page load.");
+    }catch(e){print(e);}
+}
+
+
+test("Check that events do/don't occur on document load", function() {
+    // eCounters already initialized by code in ../html/events.html
+    loadChecks("Load", 1, 1, 0);
+});
+
+test("Check that events do/don't occur on manual iframe reload", function() {
+    document.getElementById('eventsFrame').src = "html/events.html";
+    loadChecks("Reload", 2, 2, 1);
+});
+
+test("Check that an event which should NOT bubble actually does not",
+     function() {
+    var img = document.getElementById('eventsFrame').contentDocument.
+      getElementById('theIMG').src = "missing.png";
+    loadChecks("Img Load", 2, 3, 1);
+
+    // note: if img-onload had bubbled up, previous tests probably would
+    //   have failed (too large body-onload counts), too.  So this test
+    //   just ensures that operation is correct even when only part of
+    //   page is reloading.
+});
+
+
+
+function clickChecks(tag, upperCount, lowerCount){
+    expect(5);
+
+    var eCounters = window.top.eCounters;
+    try{ ok( eCounters["window onload"] == 0 &&
+             eCounters["window onunload"] == 0 &&
+             eCounters["body onload"] == 0 &&
+             eCounters["body onunload"] == 0 &&
+             eCounters["img onload"] == 0,
+        tag + ": Onload events not triggered by click");
+    }catch(e){print(e);}
+
+    var special = (upperCount == lowerCount) ? "" : " not";
+    try{ ok( eCounters["ul onclick"] == lowerCount &&
+             eCounters["li onclick"] == lowerCount &&
+             eCounters["p onclick"] == lowerCount &&
+             eCounters["b onclick"] == lowerCount &&
+             eCounters["i onclick"] == lowerCount &&
+             eCounters["a onclick"] == lowerCount &&
+             eCounters["img onclick"] == lowerCount,
+        tag + ": Click event did" + special + " bubble through inner elements");
+    }catch(e){print(e);}
+
+    try{ ok( eCounters["body onclick"] == upperCount &&
+             eCounters["div onclick"] == upperCount &&
+             eCounters["table onclick"] == upperCount &&
+             eCounters["tbody onclick"] == upperCount &&
+             eCounters["tr onclick"] == upperCount &&
+             eCounters["td onclick"] == upperCount,
+        tag + ": Click event bubbled through outer elements");
+    }catch(e){print(e);}
+
+    try{ ok( eCounters["h1 onclick"] == 0 &&
+             eCounters["h2 onclick"] == 0,
+        tag + ": No click events for Hx elements");
+    }catch(e){print(e);}
+
+
+    try{ ok( eventFrameLoaded == 2 && eventFrameClicked == 0,
+        tag + ": Iframe event counts unchanged");
+    }catch(e){print(e);}
+}
+
+test("Check that an event which should bubble actually does", function() {
+    // clear in-iframe event counters to zero
+    window.top.eCounters = {};
+    fWin = document.getElementById('eventsFrame').contentWindow;
+    fWin.initECounters(window.top.eCounters);
+
+    // simulate a "click" user action
+    var img = document.getElementById('eventsFrame').contentDocument.
+      getElementById('theIMG');
+    __click__(img);
+
+    clickChecks("Click img", 1, 1);
+});
+
+test("Bubbling event ONLY bubbles 'up'", function() {
+    // simulate a "click" user action
+    var td = document.getElementById('eventsFrame').contentDocument.
+      getElementById('theTD');
+    __click__(td);
+
+    clickChecks("Click td", 2, 1);
+});
+
+
+test("Check that events can be set with addEventListener(), and bubble",
+  function() {
+    expect(4);
+
+    var img = document.getElementById('eventsFrame').contentDocument.
+                getElementById('theIMG');
+
+    // add handlers
+    addHdlr = function(id) {
+        var elem = document.getElementById('eventsFrame').contentDocument.
+          getElementById(id).addEventListener('click', function(event){
+            try{
+                ok( event.target === img && this === window,
+                    "Scope: 'this' refers to the window '" + window + "'");
+            }catch(e){print(e);}
+        });
+    };
+
+    // a few objects that the <img 'theImG'>.click event will bubble up through
+    addHdlr("theIMG");
+    addHdlr("theA");
+    addHdlr("theP");
+    addHdlr("theLI");
+
+    // simulate user action
+    __click__(img);
+});
+

data/test/unit/fixtures/external_script.js

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

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 = "html/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);}
+});