RubyGems - jruby-activemq - Versions diffs - 5.5.1-java - Mend

jruby-activemq 5.5.1-java

Files changed (302) hide show

data/apache-activemq-5.5.1/webapps/demo/test/amq_test.html ADDED Viewed

@@ -0,0 +1,311 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+  http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>AMQ test</title>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <script src="assets/jsunittest.js" type="text/javascript"></script>
+  <script>
+  var org = org || {};
+  org.activemq = org.activemq || {};
+  org.activemq.AmqAdapter = {
+    // implement org.activemq.AmqAdapter API
+    init: function(options) {},
+    ajax: function(uri, options) {
+      ajaxRequests[ajaxRequests.length] = { uri:uri, options:options };
+    },
+    // add additional functionality for testing.
+    ajaxRequests: [],
+    getRequests: function() {
+      return ajaxRequests;
+    },
+    reset: function() {
+      ajaxRequests=[];
+    }
+  };
+  </script>
+  <script src="../js/amq.js" type="text/javascript"></script>
+  <link rel="stylesheet" href="assets/unittest.css" type="text/css" />
+</head>
+<body>
+<div id="content">
+  <div id="header">
+    <h1>AMQ tests</h1>
+    <p>
+      This file tests amq.js.
+    </p>
+  </div>
+  <!-- Log output (one per Runner, via {testLog: "testlog"} option)-->
+  <div id="testlog"></div>
+  <!-- Put sample/test html here -->
+  <div id="sample">
+  </div>
+</div>
+<script type="text/javascript">
+  function createXmlFromString( xmlString ) {
+    // http://developer.taboca.com/cases/en/client-javascript-dom-parser/
+    // Mozilla and Netscape browsers
+    if (document.implementation.createDocument) {
+      var parser = new DOMParser()
+      response = parser.parseFromString( xmlString, "text/xml")
+    // MSIE
+    } else if (window.ActiveXObject) {
+      response = new ActiveXObject("Microsoft.XMLDOM")
+      response.async="false"
+      response.loadXML( xmlString )
+    }
+    return response;
+  }
+// <![CDATA[
+  new Test.Unit.Runner({
+    setup: function() {
+      org.activemq.AmqAdapter.reset();
+      org.activemq.Amq.init({ uri: '../amq', timeout: 30 });
+    },
+    teardown: function() {
+      org.activemq.Amq.endBatch();
+    },
+    testMessagesAreSentToUrlDefinedInInit: function() { with( this ) {
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      var requests = org.activemq.AmqAdapter.getRequests();
+      assertEqual( 2, requests.length );
+      assertEqual( '../amq', requests[ 0 ].uri );
+      assertEqual( '../amq', requests[ 1 ].uri );
+    }},
+    testFirstMessageIsAPoll: function() { with( this ) {
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      var requests = org.activemq.AmqAdapter.getRequests();
+      assertEqual( 'get', requests[ 0 ].options.method );
+      assert( requests[ 0 ].options.data.match( /timeout=1&d=\d+&r=[\d.]+/ ) );
+    }},
+    testPostIsSentIfNoBatchIsInProgress: function() { with( this ) {
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      var requests = org.activemq.AmqAdapter.getRequests();
+      assertEqual( 2, requests.length );
+      assertEqual( 'post', requests[ 1 ].options.method );
+      assertEqual( 'destination=queue://test&message=<message>test</message>&type=send', requests[ 1 ].options.data );
+    }},
+    testMessagesAreDeliveredInABatchIfAjaxRequestIsInProgressWhenSendMessageIsCalled: function() { with( this ) {
+      // use startBatch to indicate a previous message POST is currently in progress.
+      org.activemq.Amq.startBatch();
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      org.activemq.Amq.sendMessage( 'queue://test2', '<message>test2</message>' );
+      // endBatch is the callback once the previous POST finishes.  Triggers delivery of queued messages.
+      org.activemq.Amq.endBatch();
+      var requests = org.activemq.AmqAdapter.getRequests();
+      assertEqual( 2, requests.length );
+      assertEqual( 'post', requests[1].options.method );
+      assertEqual( "destination=queue://test&message=<message>test</message>&type=send&d1=queue://test2&m1=<message>test2</message>&t1=send", requests[1].options.data );
+    }},
+    testAddListenerSendsListenMessage: function() { with( this ) {
+      org.activemq.Amq.addListener( 'client_id', 'topic://test', function(){} );
+      var requests = org.activemq.AmqAdapter.getRequests();
+      assertEqual( 2, requests.length );
+      assertEqual( 'post', requests[1].options.method );
+      assertEqual( "destination=topic://test&message=client_id&type=listen", requests[1].options.data );
+    }},
+    testAddListenerMayIncludeASelector: function() { with( this ) {
+      org.activemq.Amq.addListener( 'client_id', 'topic://test', function(){}, {selector:"identifier='ALPHA'"} );
+      var requests = org.activemq.AmqAdapter.getRequests();
+      assertEqual( 2, requests.length );
+      assertEqual( 'post', requests[1].options.method );
+      assertEqual( "destination=topic://test&message=client_id&type=listen", requests[1].options.data );
+      assertHashEqual( { selector: "identifier='ALPHA'" }, requests[1].options.headers );
+    }},
+    testAllQueuedMessagesContainingHeadersAreDeliveredIndividuallyToPreventHeaderConflicts: function() { with( this ) {
+      org.activemq.Amq.startBatch();
+      org.activemq.Amq.addListener( 'client_id_1', 'topic://test1', function(){}, {selector:"identifier='ALPHA'"} );
+      org.activemq.Amq.addListener( 'client_id_2', 'topic://test2', function(){}, {selector:"identifier='BRAVO'"} );
+      // simulate 1st post returning, which triggers 2nd post.
+      org.activemq.Amq.endBatch();
+      // poll & first listen have been sent.
+      assertEqual( 2, org.activemq.AmqAdapter.getRequests().length );
+      // second listen is still in the queue.
+      var queued = org.activemq.Amq.getMessageQueue();
+      assertEqual( 1, queued.length );
+      assertHashEqual( { selector: "identifier='BRAVO'" }, queued[ 0 ].headers );
+      assertHashEqual( { destination: 'topic://test2', message: 'client_id_2', messageType: 'listen' }, queued[ 0 ].message );
+      // when first post returns, the second listen gets sent.
+      // this endBatch simulates that second post returning.
+      org.activemq.Amq.endBatch();
+      var requests = org.activemq.AmqAdapter.getRequests();
+      var queued = org.activemq.Amq.getMessageQueue();
+      assertEqual( 3, requests.length );
+      assertEqual( 'post', requests[1].options.method );
+      assertEqual( "destination=topic://test1&message=client_id_1&type=listen", requests[1].options.data );
+      assertHashEqual( { selector: "identifier='ALPHA'" }, requests[1].options.headers );
+      assertEqual( 'post', requests[2].options.method );
+      assertEqual( "destination=topic://test2&message=client_id_2&type=listen", requests[2].options.data );
+      assertHashEqual( { selector: "identifier='BRAVO'" }, requests[2].options.headers );
+      assertEqual( 0, queued.length );
+    }},
+    // Is this desired behavior?  Message order changes from that specified by the client.
+    testQueuedMessagesWithoutHeadersAreDeliveredInASinglePost: function() { with( this ) {
+      org.activemq.Amq.startBatch();
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      org.activemq.Amq.addListener( 'client_id_1', 'topic://test1', function(){}, {selector:"identifier='ALPHA'"} );
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      org.activemq.Amq.addListener( 'client_id_2', 'topic://test2', function(){}, {selector:"identifier='BRAVO'"} );
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      // poll & all sendMessage calls go out first.
+      org.activemq.Amq.endBatch();
+      assertEqual( 2, org.activemq.AmqAdapter.getRequests().length );
+      assertEqual( 2, org.activemq.Amq.getMessageQueue().length );
+      // first listen goes next.
+      org.activemq.Amq.endBatch();
+      assertEqual( 3, org.activemq.AmqAdapter.getRequests().length );
+      assertEqual( 1, org.activemq.Amq.getMessageQueue().length );
+      // final listen goes out.
+      org.activemq.Amq.endBatch();
+      var requests = org.activemq.AmqAdapter.getRequests();
+      assertEqual( 4, requests.length );
+      assertEqual( 0, org.activemq.Amq.getMessageQueue().length );
+      assertEqual( "destination=queue://test&message=<message>test</message>&type=send&d1=queue://test&m1=<message>test</message>&t1=send&d2=queue://test&m2=<message>test</message>&t2=send", requests[ 1 ].options.data );
+      assertHashEqual( {}, requests[ 1 ].options.headers );
+      assertEqual( "destination=topic://test1&message=client_id_1&type=listen", requests[ 2 ].options.data );
+      assertEqual( "destination=topic://test2&message=client_id_2&type=listen", requests[ 3 ].options.data );
+    }},
+    testSelectorFromQueuedListenerIsNotAddedToLaterMessages: function() { with( this ) {
+      org.activemq.Amq.startBatch();
+      org.activemq.Amq.addListener( 'client_id_1', 'topic://test1', function(){}, {selector:"identifier='ALPHA'"} );
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      // poll & listener go out first.
+      org.activemq.Amq.endBatch();
+      assertEqual( 2, org.activemq.AmqAdapter.getRequests().length );
+      assertEqual( 2, org.activemq.Amq.getMessageQueue().length );
+      // 2 sendMessages go next.
+      org.activemq.Amq.endBatch();
+      var requests = org.activemq.AmqAdapter.getRequests();
+      assertEqual( 3, requests.length );
+      assertEqual( 0, org.activemq.Amq.getMessageQueue().length );
+      assertEqual( "destination=topic://test1&message=client_id_1&type=listen", requests[ 1 ].options.data );
+      assertHashEqual( { selector: "identifier='ALPHA'" }, requests[ 1 ].options.headers );
+      assertEqual( "destination=queue://test&message=<message>test</message>&type=send&d1=queue://test&m1=<message>test</message>&t1=send", requests[ 2 ].options.data );
+      assertHashEqual( {}, requests[ 2 ].options.headers );
+    }},
+    testAddListenerWithoutSelectorWillBeBatchedWithOtherMessages: function() { with( this ) {
+      org.activemq.Amq.startBatch();
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      org.activemq.Amq.addListener( 'client_id_1', 'topic://test1', function(){} );
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      org.activemq.Amq.addListener( 'client_id_2', 'topic://test2', function(){} );
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      org.activemq.Amq.endBatch();
+      var requests = org.activemq.AmqAdapter.getRequests();
+      assertEqual( 2, requests.length );
+      assertEqual( 0, org.activemq.Amq.getMessageQueue().length );
+      assertEqual( "destination=queue://test&message=<message>test</message>&type=send&d1=topic://test1&m1=client_id_1&t1=listen&d2=queue://test&m2=<message>test</message>&t2=send&d3=topic://test2&m3=client_id_2&t3=listen&d4=queue://test&m4=<message>test</message>&t4=send", requests[ 1 ].options.data );
+    }},
+    testRemoveListenerSendsUnlistenMessage: function() { with( this ) {
+      org.activemq.Amq.removeListener( 'client_id', 'topic://test' );
+      var requests = org.activemq.AmqAdapter.getRequests();
+      assertEqual( 2, requests.length );
+      assertEqual( 'post', requests[1].options.method );
+      assertEqual( "destination=topic://test&message=client_id&type=unlisten", requests[1].options.data );
+    }},
+    testAddListenerCallbackIsCalledForReceivedMessages: function() { with( this ) {
+      // build an XML document like the one which the ajax implementers would pass to pollHandler
+      response = createXmlFromString( '<ajax-response><response id="client_id" destination="queue://test" >test message</response></ajax-response>' );
+      // we'll expect the callback to set this value
+      var callbackValue;
+      org.activemq.Amq.addListener( 'client_id', 'queue://test', function( msg ) { callbackValue = msg; } );
+      org.activemq.Amq.testPollHandler( response );
+      assertEqual( 'test message', callbackValue.textContent );
+    }},
+    testClientIdSpecifiedInInitIsAddedToAllAjaxRequests: function() { with( this ) {
+      // need to reset to remove the poll message sent when init() is called in setup().
+      org.activemq.AmqAdapter.reset();
+      org.activemq.Amq.init({ uri: '../amq', timeout: 30, clientId:'uniqueClientName' });
+      org.activemq.Amq.addListener( 'id', 'queue://test', function(){} );
+      org.activemq.Amq.sendMessage( 'queue://test', '<message>test</message>' );
+      org.activemq.Amq.removeListener( 'id', 'topic://test' );
+      org.activemq.Amq.endBatch();
+      var requests = org.activemq.AmqAdapter.getRequests();
+      var clientNameRegex = /clientId=uniqueClientName/;
+      assertEqual( 3, requests.length );
+      assertMatch( clientNameRegex, requests[0].options.data );
+      assertMatch( clientNameRegex, requests[1].options.data );
+      assertMatch( clientNameRegex, requests[2].options.data );
+    }}
+  });
+// ]]>
+</script>
+</body>
+</html>

data/apache-activemq-5.5.1/webapps/demo/test/assets/README ADDED Viewed

@@ -0,0 +1,4 @@
+jsunittest.js from http://jsunittest.com/
+This directory is for core jsunittest files only! Put your unit test .html files up one level.
+You should be referencing files in public/javascripts/ in your test files.

data/apache-activemq-5.5.1/webapps/demo/test/assets/jsunittest.js ADDED Viewed

@@ -0,0 +1,1017 @@
+/*  Jsunittest, version 0.7.3
+ *  (c) 2008 Dr Nic Williams
+ *
+ *  Jsunittest is freely distributable under
+ *  the terms of an MIT-style license.
+ *  For details, see the web site: http://jsunittest.rubyforge.org
+ *
+ *--------------------------------------------------------------------------*/
+var JsUnitTest = {
+  Unit: {},
+  inspect: function(object) {
+    try {
+      if (typeof object == "undefined") return 'undefined';
+      if (object === null) return 'null';
+      if (typeof object == "string") {
+        var useDoubleQuotes = arguments[1];
+        var escapedString = this.gsub(object, /[\x00-\x1f\\]/, function(match) {
+          var character = String.specialChar[match[0]];
+          return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
+        });
+        if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
+        return "'" + escapedString.replace(/'/g, '\\\'') + "'";
+      };
+      return String(object);
+    } catch (e) {
+      if (e instanceof RangeError) return '...';
+      throw e;
+    }
+  },
+  $: function(element) {
+    if (arguments.length > 1) {
+      for (var i = 0, elements = [], length = arguments.length; i < length; i++)
+        elements.push(this.$(arguments[i]));
+      return elements;
+    }
+    if (typeof element == "string")
+      element = document.getElementById(element);
+    return element;
+  },
+  gsub: function(source, pattern, replacement) {
+    var result = '', match;
+    replacement = arguments.callee.prepareReplacement(replacement);
+    while (source.length > 0) {
+      if (match = source.match(pattern)) {
+        result += source.slice(0, match.index);
+        result += JsUnitTest.String.interpret(replacement(match));
+        source  = source.slice(match.index + match[0].length);
+      } else {
+        result += source, source = '';
+      }
+    }
+    return result;
+  },
+  scan: function(source, pattern, iterator) {
+    this.gsub(source, pattern, iterator);
+    return String(source);
+  },
+  escapeHTML: function(data) {
+    return data.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+  },
+  arrayfromargs: function(args) {
+  	var myarray = new Array();
+  	var i;
+  	for (i=0;i<args.length;i++)
+  		myarray[i] = args[i];
+  	return myarray;
+  },
+  hashToSortedArray: function(hash) {
+    var results = [];
+    for (key in hash) {
+      results.push([key, hash[key]]);
+    }
+    return results.sort();
+  },
+  flattenArray: function(array) {
+    var results = arguments[1] || [];
+    for (var i=0; i < array.length; i++) {
+      var object = array[i];
+      if (object != null && typeof object == "object" &&
+        'splice' in object && 'join' in object) {
+          this.flattenArray(object, results);
+      } else {
+        results.push(object);
+      }
+    };
+    return results;
+  },
+  selectorMatch: function(expression, element) {
+    var tokens = [];
+    var patterns = {
+      // combinators must be listed first
+      // (and descendant needs to be last combinator)
+      laterSibling: /^\s*~\s*/,
+      child:        /^\s*>\s*/,
+      adjacent:     /^\s*\+\s*/,
+      descendant:   /^\s/,
+      // selectors follow
+      tagName:      /^\s*(\*|[\w\-]+)(\b|$)?/,
+      id:           /^#([\w\-\*]+)(\b|$)/,
+      className:    /^\.([\w\-\*]+)(\b|$)/,
+      pseudo:
+  /^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|(?=\s|[:+~>]))/,
+      attrPresence: /^\[((?:[\w]+:)?[\w]+)\]/,
+      attr:         /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/
+    };
+    var assertions = {
+      tagName: function(element, matches) {
+        return matches[1].toUpperCase() == element.tagName.toUpperCase();
+      },
+      className: function(element, matches) {
+        return Element.hasClassName(element, matches[1]);
+      },
+      id: function(element, matches) {
+        return element.id === matches[1];
+      },
+      attrPresence: function(element, matches) {
+        return Element.hasAttribute(element, matches[1]);
+      },
+      attr: function(element, matches) {
+        var nodeValue = Element.readAttribute(element, matches[1]);
+        return nodeValue && operators[matches[2]](nodeValue, matches[5] || matches[6]);
+      }
+    };
+    var e = this.expression, ps = patterns, as = assertions;
+    var le, p, m;
+    while (e && le !== e && (/\S/).test(e)) {
+      le = e;
+      for (var i in ps) {
+        p = ps[i];
+        if (m = e.match(p)) {
+          // use the Selector.assertions methods unless the selector
+          // is too complex.
+          if (as[i]) {
+            tokens.push([i, Object.clone(m)]);
+            e = e.replace(m[0], '');
+          }
+        }
+      }
+    }
+    var match = true, name, matches;
+    for (var i = 0, token; token = tokens[i]; i++) {
+      name = token[0], matches = token[1];
+      if (!assertions[name](element, matches)) {
+        match = false; break;
+      }
+    }
+    return match;
+  },
+  toQueryParams: function(query, separator) {
+    var query = query || window.location.search;
+    var match = query.replace(/^\s+/, '').replace(/\s+$/, '').match(/([^?#]*)(#.*)?$/);
+    if (!match) return { };
+    var hash = {};
+    var parts = match[1].split(separator || '&');
+    for (var i=0; i < parts.length; i++) {
+      var pair = parts[i].split('=');
+      if (pair[0]) {
+        var key = decodeURIComponent(pair.shift());
+        var value = pair.length > 1 ? pair.join('=') : pair[0];
+        if (value != undefined) value = decodeURIComponent(value);
+        if (key in hash) {
+          var object = hash[key];
+          var isArray = object != null && typeof object == "object" &&
+            'splice' in object && 'join' in object
+          if (!isArray) hash[key] = [hash[key]];
+          hash[key].push(value);
+        }
+        else hash[key] = value;
+      }
+    };
+    return hash;
+  },
+  String: {
+    interpret: function(value) {
+      return value == null ? '' : String(value);
+    }
+  }
+};
+JsUnitTest.gsub.prepareReplacement = function(replacement) {
+  if (typeof replacement == "function") return replacement;
+  var template = new Template(replacement);
+  return function(match) { return template.evaluate(match) };
+};
+JsUnitTest.Version = '0.7.3';
+JsUnitTest.Template = function(template, pattern) {
+  this.template = template; //template.toString();
+  this.pattern = pattern || JsUnitTest.Template.Pattern;
+};
+JsUnitTest.Template.prototype.evaluate = function(object) {
+  if (typeof object.toTemplateReplacements == "function")
+    object = object.toTemplateReplacements();
+  return JsUnitTest.gsub(this.template, this.pattern, function(match) {
+    if (object == null) return '';
+    var before = match[1] || '';
+    if (before == '\\') return match[2];
+    var ctx = object, expr = match[3];
+    var pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
+    match = pattern.exec(expr);
+    if (match == null) return before;
+    while (match != null) {
+      var comp = (match[1].indexOf('[]') === 0) ? match[2].gsub('\\\\]', ']') : match[1];
+      ctx = ctx[comp];
+      if (null == ctx || '' == match[3]) break;
+      expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
+      match = pattern.exec(expr);
+    }
+    return before + JsUnitTest.String.interpret(ctx);
+  });
+}
+JsUnitTest.Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
+JsUnitTest.Event = {};
+// written by Dean Edwards, 2005
+// with input from Tino Zijdel, Matthias Miller, Diego Perini
+// namespaced by Dr Nic Williams 2008
+// http://dean.edwards.name/weblog/2005/10/add-event/
+// http://dean.edwards.name/weblog/2005/10/add-event2/
+JsUnitTest.Event.addEvent = function(element, type, handler) {
+	if (element.addEventListener) {
+		element.addEventListener(type, handler, false);
+	} else {
+		// assign each event handler a unique ID
+		if (!handler.$$guid) handler.$$guid = JsUnitTest.Event.addEvent.guid++;
+		// create a hash table of event types for the element
+		if (!element.events) element.events = {};
+		// create a hash table of event handlers for each element/event pair
+		var handlers = element.events[type];
+		if (!handlers) {
+			handlers = element.events[type] = {};
+			// store the existing event handler (if there is one)
+			if (element["on" + type]) {
+				handlers[0] = element["on" + type];
+			}
+		}
+		// store the event handler in the hash table
+		handlers[handler.$$guid] = handler;
+		// assign a global event handler to do all the work
+		element["on" + type] = this.handleEvent;
+	}
+};
+// a counter used to create unique IDs
+JsUnitTest.Event.addEvent.guid = 1;
+JsUnitTest.Event.removeEvent = function(element, type, handler) {
+	if (element.removeEventListener) {
+		element.removeEventListener(type, handler, false);
+	} else {
+		// delete the event handler from the hash table
+		if (element.events && element.events[type]) {
+			delete element.events[type][handler.$$guid];
+		}
+	}
+};
+JsUnitTest.Event.handleEvent = function(event) {
+	var returnValue = true;
+	// grab the event object (IE uses a global event object)
+	event = event || JsUnitTest.Event.fixEvent(((this.ownerDocument || this.document || this).parentWindow || window).event);
+	// get a reference to the hash table of event handlers
+	var handlers = this.events[event.type];
+	// execute each event handler
+	for (var i in handlers) {
+		this.$$handleEvent = handlers[i];
+		if (this.$$handleEvent(event) === false) {
+			returnValue = false;
+		}
+	}
+	return returnValue;
+};
+JsUnitTest.Event.fixEvent = function(event) {
+	// add W3C standard event methods
+	event.preventDefault = this.fixEvent.preventDefault;
+	event.stopPropagation = this.fixEvent.stopPropagation;
+	return event;
+};
+JsUnitTest.Event.fixEvent.preventDefault = function() {
+	this.returnValue = false;
+};
+JsUnitTest.Event.fixEvent.stopPropagation = function() {
+	this.cancelBubble = true;
+};
+JsUnitTest.Unit.Logger = function(element) {
+  this.element = JsUnitTest.$(element);
+  if (this.element) this._createLogTable();
+};
+JsUnitTest.Unit.Logger.prototype.start = function(testName) {
+  if (!this.element) return;
+  var tbody = this.element.getElementsByTagName('tbody')[0];
+  var tr = document.createElement('tr');
+  var td;
+  //testname
+  td = document.createElement('td');
+  td.appendChild(document.createTextNode(testName));
+  tr.appendChild(td)
+  tr.appendChild(document.createElement('td'));//status
+  tr.appendChild(document.createElement('td'));//message
+  tbody.appendChild(tr);
+};
+JsUnitTest.Unit.Logger.prototype.setStatus = function(status) {
+  var logline = this.getLastLogLine();
+  logline.className = status;
+  var statusCell = logline.getElementsByTagName('td')[1];
+  statusCell.appendChild(document.createTextNode(status));
+};
+JsUnitTest.Unit.Logger.prototype.finish = function(status, summary) {
+  if (!this.element) return;
+  this.setStatus(status);
+  this.message(summary);
+};
+JsUnitTest.Unit.Logger.prototype.message = function(message) {
+  if (!this.element) return;
+  var cell = this.getMessageCell();
+  // cell.appendChild(document.createTextNode(this._toHTML(message)));
+  cell.innerHTML = this._toHTML(message);
+};
+JsUnitTest.Unit.Logger.prototype.summary = function(summary) {
+  if (!this.element) return;
+  var div = this.element.getElementsByTagName('div')[0];
+  div.innerHTML = this._toHTML(summary);
+};
+JsUnitTest.Unit.Logger.prototype.getLastLogLine = function() {
+  var tbody = this.element.getElementsByTagName('tbody')[0];
+  var loglines = tbody.getElementsByTagName('tr');
+  return loglines[loglines.length - 1];
+};
+JsUnitTest.Unit.Logger.prototype.getMessageCell = function() {
+  var logline = this.getLastLogLine();
+  return logline.getElementsByTagName('td')[2];
+};
+JsUnitTest.Unit.Logger.prototype._createLogTable = function() {
+  var html = '<div class="logsummary">running...</div>' +
+  '<table class="logtable">' +
+  '<thead><tr><th>Status</th><th>Test</th><th>Message</th></tr></thead>' +
+  '<tbody class="loglines"></tbody>' +
+  '</table>';
+  this.element.innerHTML = html;
+};
+JsUnitTest.Unit.Logger.prototype.appendActionButtons = function(actions) {
+  // actions = $H(actions);
+  // if (!actions.any()) return;
+  // var div = new Element("div", {className: 'action_buttons'});
+  // actions.inject(div, function(container, action) {
+  //   var button = new Element("input").setValue(action.key).observe("click", action.value);
+  //   button.type = "button";
+  //   return container.insert(button);
+  // });
+  // this.getMessageCell().insert(div);
+};
+JsUnitTest.Unit.Logger.prototype._toHTML = function(txt) {
+  return JsUnitTest.escapeHTML(txt).replace(/\n/g,"<br/>");
+};
+JsUnitTest.Unit.MessageTemplate = function(string) {
+  var parts = [];
+  var str = JsUnitTest.scan((string || ''), /(?=[^\\])\?|(?:\\\?|[^\?])+/, function(part) {
+    parts.push(part[0]);
+  });
+  this.parts = parts;
+};
+JsUnitTest.Unit.MessageTemplate.prototype.evaluate = function(params) {
+  var results = [];
+  for (var i=0; i < this.parts.length; i++) {
+    var part = this.parts[i];
+    var result = (part == '?') ? JsUnitTest.inspect(params.shift()) : part.replace(/\\\?/, '?');
+    results.push(result);
+  };
+  return results.join('');
+};
+// A generic function for performming AJAX requests
+// It takes one argument, which is an object that contains a set of options
+// All of which are outline in the comments, below
+// From John Resig's book Pro JavaScript Techniques
+// published by Apress, 2006-8
+JsUnitTest.ajax = function( options ) {
+    // Load the options object with defaults, if no
+    // values were provided by the user
+    options = {
+        // The type of HTTP Request
+        type: options.type || "POST",
+        // The URL the request will be made to
+        url: options.url || "",
+        // How long to wait before considering the request to be a timeout
+        timeout: options.timeout || 5000,
+        // Functions to call when the request fails, succeeds,
+        // or completes (either fail or succeed)
+        onComplete: options.onComplete || function(){},
+        onError: options.onError || function(){},
+        onSuccess: options.onSuccess || function(){},
+        // The data type that'll be returned from the server
+        // the default is simply to determine what data was returned from the
+        // and act accordingly.
+        data: options.data || ""
+    };
+    // Create the request object
+    var xml = window.ActiveXObject ? new ActiveXObject('Microsoft.XMLHTTP') : new XMLHttpRequest();
+    // Open the asynchronous POST request
+    xml.open(options.type, options.url, true);
+    // We're going to wait for a request for 5 seconds, before giving up
+    var timeoutLength = 5000;
+    // Keep track of when the request has been succesfully completed
+    var requestDone = false;
+    // Initalize a callback which will fire 5 seconds from now, cancelling
+    // the request (if it has not already occurred).
+    setTimeout(function(){
+         requestDone = true;
+    }, timeoutLength);
+    // Watch for when the state of the document gets updated
+    xml.onreadystatechange = function(){
+        // Wait until the data is fully loaded,
+        // and make sure that the request hasn't already timed out
+        if ( xml.readyState == 4 && !requestDone ) {
+            // Check to see if the request was successful
+            if ( httpSuccess( xml ) ) {
+                // Execute the success callback with the data returned from the server
+                options.onSuccess( httpData( xml, options.type ) );
+            // Otherwise, an error occurred, so execute the error callback
+            } else {
+                options.onError();
+            }
+            // Call the completion callback
+            options.onComplete();
+            // Clean up after ourselves, to avoid memory leaks
+            xml = null;
+        }
+    };
+    // Establish the connection to the server
+    xml.send(null);
+    // Determine the success of the HTTP response
+    function httpSuccess(r) {
+        try {
+            // If no server status is provided, and we're actually
+            // requesting a local file, then it was successful
+            return !r.status && location.protocol == "file:" ||
+                // Any status in the 200 range is good
+                ( r.status >= 200 && r.status < 300 ) ||
+                // Successful if the document has not been modified
+                r.status == 304 ||
+                // Safari returns an empty status if the file has not been modified
+                navigator.userAgent.indexOf("Safari") >= 0 && typeof r.status == "undefined";
+        } catch(e){}
+        // If checking the status failed, then assume that the request failed too
+        return false;
+    }
+    // Extract the correct data from the HTTP response
+    function httpData(r,type) {
+        // Get the content-type header
+        var ct = r.getResponseHeader("content-type");
+        // If no default type was provided, determine if some
+        // form of XML was returned from the server
+        var data = !type && ct && ct.indexOf("xml") >= 0;
+        // Get the XML Document object if XML was returned from
+        // the server, otherwise return the text contents returned by the server
+        data = type == "xml" || data ? r.responseXML : r.responseText;
+        // If the specified type is "script", execute the returned text
+        // response as if it was JavaScript
+        if ( type == "script" )
+            eval.call( window, data );
+        // Return the response data (either an XML Document or a text string)
+        return data;
+    }
+};
+JsUnitTest.Unit.Assertions = {
+  buildMessage: function(message, template) {
+    var args = JsUnitTest.arrayfromargs(arguments).slice(2);
+    return (message ? message + '\n' : '') +
+      new JsUnitTest.Unit.MessageTemplate(template).evaluate(args);
+  },
+  flunk: function(message) {
+    this.assertBlock(message || 'Flunked', function() { return false });
+  },
+  assertBlock: function(message, block) {
+    try {
+      block.call(this) ? this.pass() : this.fail(message);
+    } catch(e) { this.error(e) }
+  },
+  assert: function(expression, message) {
+    message = this.buildMessage(message || 'assert', 'got <?>', expression);
+    this.assertBlock(message, function() { return expression });
+  },
+  assertEqual: function(expected, actual, message) {
+    message = this.buildMessage(message || 'assertEqual', 'expected <?>, actual: <?>', expected, actual);
+    this.assertBlock(message, function() { return expected == actual });
+  },
+  assertNotEqual: function(expected, actual, message) {
+    message = this.buildMessage(message || 'assertNotEqual', 'expected <?>, actual: <?>', expected, actual);
+    this.assertBlock(message, function() { return expected != actual });
+  },
+  assertEnumEqual: function(expected, actual, message) {
+    message = this.buildMessage(message || 'assertEnumEqual', 'expected <?>, actual: <?>', expected, actual);
+    var expected_array = JsUnitTest.flattenArray(expected);
+    var actual_array   = JsUnitTest.flattenArray(actual);
+    this.assertBlock(message, function() {
+      if (expected_array.length == actual_array.length) {
+        for (var i=0; i < expected_array.length; i++) {
+          if (expected_array[i] != actual_array[i]) return false;
+        };
+        return true;
+      }
+      return false;
+    });
+  },
+  assertEnumNotEqual: function(expected, actual, message) {
+    message = this.buildMessage(message || 'assertEnumNotEqual', '<?> was the same as <?>', expected, actual);
+    var expected_array = JsUnitTest.flattenArray(expected);
+    var actual_array   = JsUnitTest.flattenArray(actual);
+    this.assertBlock(message, function() {
+      if (expected_array.length == actual_array.length) {
+        for (var i=0; i < expected_array.length; i++) {
+          if (expected_array[i] != actual_array[i]) return true;
+        };
+        return false;
+      }
+      return true;
+    });
+  },
+  assertHashEqual: function(expected, actual, message) {
+    message = this.buildMessage(message || 'assertHashEqual', 'expected <?>, actual: <?>', expected, actual);
+    var expected_array = JsUnitTest.flattenArray(JsUnitTest.hashToSortedArray(expected));
+    var actual_array   = JsUnitTest.flattenArray(JsUnitTest.hashToSortedArray(actual));
+    var block = function() {
+      if (expected_array.length == actual_array.length) {
+        for (var i=0; i < expected_array.length; i++) {
+          if (expected_array[i] != actual_array[i]) return false;
+        };
+        return true;
+      }
+      return false;
+    };
+    this.assertBlock(message, block);
+  },
+  assertHashNotEqual: function(expected, actual, message) {
+    message = this.buildMessage(message || 'assertHashNotEqual', '<?> was the same as <?>', expected, actual);
+    var expected_array = JsUnitTest.flattenArray(JsUnitTest.hashToSortedArray(expected));
+    var actual_array   = JsUnitTest.flattenArray(JsUnitTest.hashToSortedArray(actual));
+    // from now we recursively zip & compare nested arrays
+    var block = function() {
+      if (expected_array.length == actual_array.length) {
+        for (var i=0; i < expected_array.length; i++) {
+          if (expected_array[i] != actual_array[i]) return true;
+        };
+        return false;
+      }
+      return true;
+    };
+    this.assertBlock(message, block);
+  },
+  assertIdentical: function(expected, actual, message) {
+    message = this.buildMessage(message || 'assertIdentical', 'expected <?>, actual: <?>', expected, actual);
+    this.assertBlock(message, function() { return expected === actual });
+  },
+  assertNotIdentical: function(expected, actual, message) {
+    message = this.buildMessage(message || 'assertNotIdentical', 'expected <?>, actual: <?>', expected, actual);
+    this.assertBlock(message, function() { return expected !== actual });
+  },
+  assertNull: function(obj, message) {
+    message = this.buildMessage(message || 'assertNull', 'got <?>', obj);
+    this.assertBlock(message, function() { return obj === null });
+  },
+  assertNotNull: function(obj, message) {
+    message = this.buildMessage(message || 'assertNotNull', 'got <?>', obj);
+    this.assertBlock(message, function() { return obj !== null });
+  },
+  assertUndefined: function(obj, message) {
+    message = this.buildMessage(message || 'assertUndefined', 'got <?>', obj);
+    this.assertBlock(message, function() { return typeof obj == "undefined" });
+  },
+  assertNotUndefined: function(obj, message) {
+    message = this.buildMessage(message || 'assertNotUndefined', 'got <?>', obj);
+    this.assertBlock(message, function() { return typeof obj != "undefined" });
+  },
+  assertNullOrUndefined: function(obj, message) {
+    message = this.buildMessage(message || 'assertNullOrUndefined', 'got <?>', obj);
+    this.assertBlock(message, function() { return obj == null });
+  },
+  assertNotNullOrUndefined: function(obj, message) {
+    message = this.buildMessage(message || 'assertNotNullOrUndefined', 'got <?>', obj);
+    this.assertBlock(message, function() { return obj != null });
+  },
+  assertMatch: function(expected, actual, message) {
+    message = this.buildMessage(message || 'assertMatch', 'regex <?> did not match <?>', expected, actual);
+    this.assertBlock(message, function() { return new RegExp(expected).exec(actual) });
+  },
+  assertNoMatch: function(expected, actual, message) {
+    message = this.buildMessage(message || 'assertNoMatch', 'regex <?> matched <?>', expected, actual);
+    this.assertBlock(message, function() { return !(new RegExp(expected).exec(actual)) });
+  },
+  assertHasClass: function(element, klass, message) {
+    element = JsUnitTest.$(element);
+    message = this.buildMessage(message || 'assertHasClass', '? doesn\'t have class <?>.', element, klass);
+    this.assertBlock(message, function() {
+      var elementClassName = element.className;
+      return (elementClassName.length > 0 && (elementClassName == klass ||
+        new RegExp("(^|\\s)" + klass + "(\\s|$)").test(elementClassName)));
+      // return !!element.className.match(new RegExp(klass))
+    });
+  },
+  assertNotHasClass: function(element, klass, message) {
+    element = JsUnitTest.$(element);
+    message = this.buildMessage(message || 'assertNotHasClass', '? does have class <?>.', element, klass);
+    this.assertBlock(message, function() {
+      var elementClassName = element.className;
+      return !(elementClassName.length > 0 && (elementClassName == klass ||
+        new RegExp("(^|\\s)" + klass + "(\\s|$)").test(elementClassName)));
+    });
+  },
+  assertHidden: function(element, message) {
+    element = JsUnitTest.$(element);
+    message = this.buildMessage(message || 'assertHidden', '? isn\'t hidden.', element);
+    this.assertBlock(message, function() { return !element.style.display || element.style.display == 'none' });
+  },
+  assertInstanceOf: function(expected, actual, message) {
+    message = this.buildMessage(message || 'assertInstanceOf', '<?> was not an instance of the expected type', actual);
+    this.assertBlock(message, function() { return actual instanceof expected });
+  },
+  assertNotInstanceOf: function(expected, actual, message) {
+    message = this.buildMessage(message || 'assertNotInstanceOf', '<?> was an instance of the expected type', actual);
+    this.assertBlock(message, function() { return !(actual instanceof expected) });
+  },
+  assertRespondsTo: function(method, obj, message) {
+    message = this.buildMessage(message || 'assertRespondsTo', 'object doesn\'t respond to <?>', method);
+    this.assertBlock(message, function() { return (method in obj && typeof obj[method] == 'function') });
+  },
+  assertRaise: function(exceptionName, method, message) {
+    message = this.buildMessage(message || 'assertRaise', '<?> exception expected but none was raised', exceptionName);
+    var block = function() {
+      try {
+        method();
+        return false;
+      } catch(e) {
+        if (e.name == exceptionName) return true;
+        else throw e;
+      }
+    };
+    this.assertBlock(message, block);
+  },
+  assertNothingRaised: function(method, message) {
+    try {
+      method();
+      this.assert(true, "Expected nothing to be thrown");
+    } catch(e) {
+      message = this.buildMessage(message || 'assertNothingRaised', '<?> was thrown when nothing was expected.', e);
+      this.flunk(message);
+    }
+  },
+  _isVisible: function(element) {
+    element = JsUnitTest.$(element);
+    if(!element.parentNode) return true;
+    this.assertNotNull(element);
+    if(element.style && (element.style.display == 'none'))
+      return false;
+    return arguments.callee.call(this, element.parentNode);
+  },
+  assertVisible: function(element, message) {
+    message = this.buildMessage(message, '? was not visible.', element);
+    this.assertBlock(message, function() { return this._isVisible(element) });
+  },
+  assertNotVisible: function(element, message) {
+    message = this.buildMessage(message, '? was not hidden and didn\'t have a hidden parent either.', element);
+    this.assertBlock(message, function() { return !this._isVisible(element) });
+  },
+  assertElementsMatch: function() {
+    var pass = true, expressions = JsUnitTest.arrayfromargs(arguments);
+    var elements = expressions.shift();
+    if (elements.length != expressions.length) {
+      message = this.buildMessage('assertElementsMatch', 'size mismatch: ? elements, ? expressions (?).', elements.length, expressions.length, expressions);
+      this.flunk(message);
+      pass = false;
+    }
+    for (var i=0; i < expressions.length; i++) {
+      var expression = expressions[i];
+      var element    = JsUnitTest.$(elements[i]);
+      if (JsUnitTest.selectorMatch(expression, element)) {
+        pass = true;
+        break;
+      }
+      message = this.buildMessage('assertElementsMatch', 'In index <?>: expected <?> but got ?', index, expression, element);
+      this.flunk(message);
+      pass = false;
+    };
+    this.assert(pass, "Expected all elements to match.");
+  },
+  assertElementMatches: function(element, expression, message) {
+    this.assertElementsMatch([element], expression);
+  }
+};
+JsUnitTest.Unit.Runner = function(testcases) {
+  var argumentOptions = arguments[1] || {};
+  var options = this.options = {};
+  options.testLog = ('testLog' in argumentOptions) ? argumentOptions.testLog : 'testlog';
+  options.resultsURL = this.queryParams.resultsURL;
+  options.testLog = JsUnitTest.$(options.testLog);
+  this.tests = this.getTests(testcases);
+  this.currentTest = 0;
+  this.logger = new JsUnitTest.Unit.Logger(options.testLog);
+  var self = this;
+  JsUnitTest.Event.addEvent(window, "load", function() {
+    setTimeout(function() {
+      self.runTests();
+    }, 0.1);
+  });
+};
+JsUnitTest.Unit.Runner.prototype.queryParams = JsUnitTest.toQueryParams();
+JsUnitTest.Unit.Runner.prototype.portNumber = function() {
+  if (window.location.search.length > 0) {
+    var matches = window.location.search.match(/\:(\d{3,5})\//);
+    if (matches) {
+      return parseInt(matches[1]);
+    }
+  }
+  return null;
+};
+JsUnitTest.Unit.Runner.prototype.getTests = function(testcases) {
+  var tests = [], options = this.options;
+  if (this.queryParams.tests) tests = this.queryParams.tests.split(',');
+  else if (options.tests) tests = options.tests;
+  else if (options.test) tests = [option.test];
+  else {
+    for (testname in testcases) {
+      if (testname.match(/^test/)) tests.push(testname);
+    }
+  }
+  var results = [];
+  for (var i=0; i < tests.length; i++) {
+    var test = tests[i];
+    if (testcases[test])
+      results.push(
+        new JsUnitTest.Unit.Testcase(test, testcases[test], testcases.setup, testcases.teardown)
+      );
+  };
+  return results;
+};
+JsUnitTest.Unit.Runner.prototype.getResult = function() {
+  var results = {
+    tests: this.tests.length,
+    assertions: 0,
+    failures: 0,
+    errors: 0,
+    warnings: 0
+  };
+  for (var i=0; i < this.tests.length; i++) {
+    var test = this.tests[i];
+    results.assertions += test.assertions;
+    results.failures   += test.failures;
+    results.errors     += test.errors;
+    results.warnings   += test.warnings;
+  };
+  return results;
+};
+JsUnitTest.Unit.Runner.prototype.postResults = function() {
+  if (this.options.resultsURL) {
+    // new Ajax.Request(this.options.resultsURL,
+    //   { method: 'get', parameters: this.getResult(), asynchronous: false });
+    var results = this.getResult();
+    var url = this.options.resultsURL + "?";
+    url += "tests="+ this.tests.length + "&";
+    url += "assertions="+ results.assertions + "&";
+    url += "warnings="  + results.warnings + "&";
+    url += "failures="  + results.failures + "&";
+    url += "errors="    + results.errors;
+    JsUnitTest.ajax({
+      url: url,
+      type: 'GET'
+    })
+  }
+};
+JsUnitTest.Unit.Runner.prototype.runTests = function() {
+  var test = this.tests[this.currentTest], actions;
+  if (!test) return this.finish();
+  if (!test.isWaiting) this.logger.start(test.name);
+  test.run();
+  var self = this;
+  if(test.isWaiting) {
+    this.logger.message("Waiting for " + test.timeToWait + "ms");
+    // setTimeout(this.runTests.bind(this), test.timeToWait || 1000);
+    setTimeout(function() {
+      self.runTests();
+    }, test.timeToWait || 1000);
+    return;
+  }
+  this.logger.finish(test.status(), test.summary());
+  if (actions = test.actions) this.logger.appendActionButtons(actions);
+  this.currentTest++;
+  // tail recursive, hopefully the browser will skip the stackframe
+  this.runTests();
+};
+JsUnitTest.Unit.Runner.prototype.finish = function() {
+  this.postResults();
+  this.logger.summary(this.summary());
+};
+JsUnitTest.Unit.Runner.prototype.summary = function() {
+  return new JsUnitTest.Template('#{tests} tests, #{assertions} assertions, #{failures} failures, #{errors} errors, #{warnings} warnings').evaluate(this.getResult());
+};
+JsUnitTest.Unit.Testcase = function(name, test, setup, teardown) {
+  this.name           = name;
+  this.test           = test     || function() {};
+  this.setup          = setup    || function() {};
+  this.teardown       = teardown || function() {};
+  this.messages       = [];
+  this.actions        = {};
+};
+// import JsUnitTest.Unit.Assertions
+for (method in JsUnitTest.Unit.Assertions) {
+  JsUnitTest.Unit.Testcase.prototype[method] = JsUnitTest.Unit.Assertions[method];
+}
+JsUnitTest.Unit.Testcase.prototype.isWaiting         = false;
+JsUnitTest.Unit.Testcase.prototype.timeToWait        = 1000;
+JsUnitTest.Unit.Testcase.prototype.assertions        = 0;
+JsUnitTest.Unit.Testcase.prototype.failures          = 0;
+JsUnitTest.Unit.Testcase.prototype.errors            = 0;
+JsUnitTest.Unit.Testcase.prototype.warnings          = 0;
+JsUnitTest.Unit.Testcase.prototype.isRunningFromRake = window.location.port;
+// JsUnitTest.Unit.Testcase.prototype.isRunningFromRake = window.location.port == 4711;
+JsUnitTest.Unit.Testcase.prototype.wait = function(time, nextPart) {
+  this.isWaiting = true;
+  this.test = nextPart;
+  this.timeToWait = time;
+};
+JsUnitTest.Unit.Testcase.prototype.run = function(rethrow) {
+  try {
+    try {
+      if (!this.isWaiting) this.setup();
+      this.isWaiting = false;
+      this.test();
+    } finally {
+      if(!this.isWaiting) {
+        this.teardown();
+      }
+    }
+  }
+  catch(e) {
+    if (rethrow) throw e;
+    this.error(e, this);
+  }
+};
+JsUnitTest.Unit.Testcase.prototype.summary = function() {
+  var msg = '#{assertions} assertions, #{failures} failures, #{errors} errors, #{warnings} warnings\n';
+  return new JsUnitTest.Template(msg).evaluate(this) +
+    this.messages.join("\n");
+};
+JsUnitTest.Unit.Testcase.prototype.pass = function() {
+  this.assertions++;
+};
+JsUnitTest.Unit.Testcase.prototype.fail = function(message) {
+  this.failures++;
+  var line = "";
+  try {
+    throw new Error("stack");
+  } catch(e){
+    line = (/\.html:(\d+)/.exec(e.stack || '') || ['',''])[1];
+  }
+  this.messages.push("Failure: " + message + (line ? " Line #" + line : ""));
+};
+JsUnitTest.Unit.Testcase.prototype.warning = function(message) {
+  this.warnings++;
+  var line = "";
+  try {
+    throw new Error("stack");
+  } catch(e){
+    line = (/\.html:(\d+)/.exec(e.stack || '') || ['',''])[1];
+  }
+  this.messages.push("Warning: " + message + (line ? " Line #" + line : ""));
+};
+JsUnitTest.Unit.Testcase.prototype.warn = JsUnitTest.Unit.Testcase.prototype.warning;
+JsUnitTest.Unit.Testcase.prototype.info = function(message) {
+  this.messages.push("Info: " + message);
+};
+JsUnitTest.Unit.Testcase.prototype.error = function(error, test) {
+  this.errors++;
+  this.actions['retry with throw'] = function() { test.run(true) };
+  this.messages.push(error.name + ": "+ error.message + "(" + JsUnitTest.inspect(error) + ")");
+};
+JsUnitTest.Unit.Testcase.prototype.status = function() {
+  if (this.failures > 0) return 'failed';
+  if (this.errors > 0) return 'error';
+  if (this.warnings > 0) return 'warning';
+  return 'passed';
+};
+JsUnitTest.Unit.Testcase.prototype.benchmark = function(operation, iterations) {
+  var startAt = new Date();
+  (iterations || 1).times(operation);
+  var timeTaken = ((new Date())-startAt);
+  this.info((arguments[2] || 'Operation') + ' finished ' +
+     iterations + ' iterations in ' + (timeTaken/1000)+'s' );
+  return timeTaken;
+};
+Test = JsUnitTest