// script.aculo.us unittest.js v1.7.0, Fri Jan 19 19:16:36 CET 2007

 // Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
 // (c) 2005, 2006 Jon Tirsen (http://www.tirsen.com)
 // (c) 2005, 2006 Michael Schuerig (http://www.schuerig.de/michael/)
 //
 // script.aculo.us is freely distributable under the terms of an MIT-style license.
 // For details, see the script.aculo.us web site: http://script.aculo.us/

 // experimental, Firefox-only
 Event.simulateMouse = function(element, eventName) {
 var options = Object.extend({
 pointerX: 0,
 pointerY: 0,
 buttons: 0,
 ctrlKey: false,
 altKey: false,
 shiftKey: false,
 metaKey: false
 }, arguments[2] || {});
 var oEvent = document.createEvent("MouseEvents");
 oEvent.initMouseEvent(eventName, true, true, document.defaultView,
 options.buttons, options.pointerX, options.pointerY, options.pointerX, options.pointerY,
 options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, 0, $(element));

 if(this.mark) Element.remove(this.mark);
 this.mark = document.createElement('div');
 this.mark.appendChild(document.createTextNode(" "));
 document.body.appendChild(this.mark);
 this.mark.style.position = 'absolute';
 this.mark.style.top = options.pointerY + "px";
 this.mark.style.left = options.pointerX + "px";
 this.mark.style.width = "5px";
 this.mark.style.height = "5px;";
 this.mark.style.borderTop = "1px solid red;"
 this.mark.style.borderLeft = "1px solid red;"

 if(this.step)
 alert('['+new Date().getTime().toString()+'] '+eventName+'/'+Test.Unit.inspect(options));

 $(element).dispatchEvent(oEvent);
 };

 // Note: Due to a fix in Firefox 1.0.5/6 that probably fixed "too much", this doesn't work in 1.0.6 or DP2.
 // You need to downgrade to 1.0.4 for now to get this working
 // See https://bugzilla.mozilla.org/show_bug.cgi?id=289940 for the fix that fixed too much
 Event.simulateKey = function(element, eventName) {
 var options = Object.extend({
 ctrlKey: false,
 altKey: false,
 shiftKey: false,
 metaKey: false,
 keyCode: 0,
 charCode: 0
 }, arguments[2] || {});

 var oEvent = document.createEvent("KeyEvents");
 oEvent.initKeyEvent(eventName, true, true, window,
 options.ctrlKey, options.altKey, options.shiftKey, options.metaKey,
 options.keyCode, options.charCode );
 $(element).dispatchEvent(oEvent);
 };

 Event.simulateKeys = function(element, command) {
 for(var i=0; i<command.length; i++) {
 Event.simulateKey(element,'keypress',{charCode:command.charCodeAt(i)});
 }
 };

 var Test = {}
 Test.Unit = {};

 // security exception workaround
 Test.Unit.inspect = Object.inspect;

 Test.Unit.Logger = Class.create();
 Test.Unit.Logger.prototype = {
 initialize: function(log) {
 this.log = $(log);
 if (this.log) {
 this._createLogTable();
 }
 },
 start: function(testName) {
 if (!this.log) return;
 this.testName = testName;
 this.lastLogLine = document.createElement('tr');
 this.statusCell = document.createElement('td');
 this.nameCell = document.createElement('td');
 this.nameCell.className = "nameCell";
 this.nameCell.appendChild(document.createTextNode(testName));
 this.messageCell = document.createElement('td');
 this.lastLogLine.appendChild(this.statusCell);
 this.lastLogLine.appendChild(this.nameCell);
 this.lastLogLine.appendChild(this.messageCell);
 this.loglines.appendChild(this.lastLogLine);
 },
 finish: function(status, summary) {
 if (!this.log) return;
 this.lastLogLine.className = status;
 this.statusCell.innerHTML = status;
 this.messageCell.innerHTML = this._toHTML(summary);
 this.addLinksToResults();
 },
 message: function(message) {
 if (!this.log) return;
 this.messageCell.innerHTML = this._toHTML(message);
 },
 summary: function(summary) {
 if (!this.log) return;
 this.logsummary.innerHTML = this._toHTML(summary);
 },
 _createLogTable: function() {
 this.log.innerHTML =
 '<div id="logsummary"></div>' +
 '<table id="logtable">' +
 '<thead><tr><th>Status</th><th>Test</th><th>Message</th></tr></thead>' +
 '<tbody id="loglines"></tbody>' +
 '</table>';
 this.logsummary = $('logsummary')
 this.loglines = $('loglines');
 },
 _toHTML: function(txt) {
 return txt.escapeHTML().replace(/\n/g,"<br/>");
 },
 addLinksToResults: function(){
 $$("tr.failed .nameCell").each( function(td){ // todo: limit to children of this.log
 td.title = "Run only this test"
 Event.observe(td, 'click', function(){ window.location.search = "?tests=" + td.innerHTML;});
 });
 $$("tr.passed .nameCell").each( function(td){ // todo: limit to children of this.log
 td.title = "Run all tests"
 Event.observe(td, 'click', function(){ window.location.search = "";});
 });
 }
 }

 Test.Unit.Runner = Class.create();
 Test.Unit.Runner.prototype = {
 initialize: function(testcases) {
 this.options = Object.extend({
 testLog: 'testlog'
 }, arguments[1] || {});
 this.options.resultsURL = this.parseResultsURLQueryParameter();
 this.options.tests = this.parseTestsQueryParameter();
 if (this.options.testLog) {
 this.options.testLog = $(this.options.testLog) || null;
 }
 if(this.options.tests) {
 this.tests = [];
 for(var i = 0; i < this.options.tests.length; i++) {
 if(/^test/.test(this.options.tests[i])) {
 this.tests.push(new Test.Unit.Testcase(this.options.tests[i], testcases[this.options.tests[i]], testcases["setup"], testcases["teardown"]));
 }
 }
 } else {
 if (this.options.test) {
 this.tests = [new Test.Unit.Testcase(this.options.test, testcases[this.options.test], testcases["setup"], testcases["teardown"])];
 } else {
 this.tests = [];
 for(var testcase in testcases) {
 if(/^test/.test(testcase)) {
 this.tests.push(
 new Test.Unit.Testcase(
 this.options.context ? ' -> ' + this.options.titles[testcase] : testcase,
 testcases[testcase], testcases["setup"], testcases["teardown"]
 ));
 }
 }
 }
 }
 this.currentTest = 0;
 this.logger = new Test.Unit.Logger(this.options.testLog);
 setTimeout(this.runTests.bind(this), 1000);
 },
 parseResultsURLQueryParameter: function() {
 return window.location.search.parseQuery()["resultsURL"];
 },
 parseTestsQueryParameter: function(){
 if (window.location.search.parseQuery()["tests"]){
 return window.location.search.parseQuery()["tests"].split(',');
 };
 },
 // Returns:
 // "ERROR" if there was an error,
 // "FAILURE" if there was a failure, or
 // "SUCCESS" if there was neither
 getResult: function() {
 var hasFailure = false;
 for(var i=0;i<this.tests.length;i++) {
 if (this.tests[i].errors > 0) {
 return "ERROR";
 }
 if (this.tests[i].failures > 0) {
 hasFailure = true;
 }
 }
 if (hasFailure) {
 return "FAILURE";
 } else {
 return "SUCCESS";
 }
 },
 postResults: function() {
 if (this.options.resultsURL) {
 new Ajax.Request(this.options.resultsURL,
 { method: 'get', parameters: 'result=' + this.getResult(), asynchronous: false });
 }
 },
 runTests: function() {
 var test = this.tests[this.currentTest];
 if (!test) {
 // finished!
 this.postResults();
 this.logger.summary(this.summary());
 return;
 }
 if(!test.isWaiting) {
 this.logger.start(test.name);
 }
 test.run();
 if(test.isWaiting) {
 this.logger.message("Waiting for " + test.timeToWait + "ms");
 setTimeout(this.runTests.bind(this), test.timeToWait || 1000);
 } else {
 this.logger.finish(test.status(), test.summary());
 this.currentTest++;
 // tail recursive, hopefully the browser will skip the stackframe
 this.runTests();
 }
 },
 summary: function() {
 var assertions = 0;
 var failures = 0;
 var errors = 0;
 var messages = [];
 for(var i=0;i<this.tests.length;i++) {
 assertions += this.tests[i].assertions;
 failures += this.tests[i].failures;
 errors += this.tests[i].errors;
 }
 return (
 (this.options.context ? this.options.context + ': ': '') +
 this.tests.length + " tests, " +
 assertions + " assertions, " +
 failures + " failures, " +
 errors + " errors");
 }
 }

 Test.Unit.Assertions = Class.create();
 Test.Unit.Assertions.prototype = {
 initialize: function() {
 this.assertions = 0;
 this.failures = 0;
 this.errors = 0;
 this.messages = [];
 },
 summary: function() {
 return (
 this.assertions + " assertions, " +
 this.failures + " failures, " +
 this.errors + " errors" + "\n" +
 this.messages.join("\n"));
 },
 pass: function() {
 this.assertions++;
 },
 fail: function(message) {
 this.failures++;
 this.messages.push("Failure: " + message);
 },
 info: function(message) {
 this.messages.push("Info: " + message);
 },
 error: function(error) {
 this.errors++;
 this.messages.push(error.name + ": "+ error.message + "(" + Test.Unit.inspect(error) +")");
 },
 status: function() {
 if (this.failures > 0) return 'failed';
 if (this.errors > 0) return 'error';
 return 'passed';
 },
 assert: function(expression) {
 var message = arguments[1] || 'assert: got "' + Test.Unit.inspect(expression) + '"';
 try { expression ? this.pass() :
 this.fail(message); }
 catch(e) { this.error(e); }
 },
 assertEqual: function(expected, actual) {
 var message = arguments[2] || "assertEqual";
 try { (expected == actual) ? this.pass() :
 this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
 '", actual "' + Test.Unit.inspect(actual) + '"'); }
 catch(e) { this.error(e); }
 },
 assertInspect: function(expected, actual) {
 var message = arguments[2] || "assertInspect";
 try { (expected == actual.inspect()) ? this.pass() :
 this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
 '", actual "' + Test.Unit.inspect(actual) + '"'); }
 catch(e) { this.error(e); }
 },
 assertEnumEqual: function(expected, actual) {
 var message = arguments[2] || "assertEnumEqual";
 try { $A(expected).length == $A(actual).length &&
 expected.zip(actual).all(function(pair) { return pair[0] == pair[1] }) ?
 this.pass() : this.fail(message + ': expected ' + Test.Unit.inspect(expected) +
 ', actual ' + Test.Unit.inspect(actual)); }
 catch(e) { this.error(e); }
 },
 assertNotEqual: function(expected, actual) {
 var message = arguments[2] || "assertNotEqual";
 try { (expected != actual) ? this.pass() :
 this.fail(message + ': got "' + Test.Unit.inspect(actual) + '"'); }
 catch(e) { this.error(e); }
 },
 assertIdentical: function(expected, actual) {
 var message = arguments[2] || "assertIdentical";
 try { (expected === actual) ? this.pass() :
 this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
 '", actual "' + Test.Unit.inspect(actual) + '"'); }
 catch(e) { this.error(e); }
 },
 assertNotIdentical: function(expected, actual) {
 var message = arguments[2] || "assertNotIdentical";
 try { !(expected === actual) ? this.pass() :
 this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
 '", actual "' + Test.Unit.inspect(actual) + '"'); }
 catch(e) { this.error(e); }
 },
 assertNull: function(obj) {
 var message = arguments[1] || 'assertNull'
 try { (obj==null) ? this.pass() :
 this.fail(message + ': got "' + Test.Unit.inspect(obj) + '"'); }
 catch(e) { this.error(e); }
 },
 assertMatch: function(expected, actual) {
 var message = arguments[2] || 'assertMatch';
 var regex = new RegExp(expected);
 try { (regex.exec(actual)) ? this.pass() :
 this.fail(message + ' : regex: "' + Test.Unit.inspect(expected) + ' did not match: ' + Test.Unit.inspect(actual) + '"'); }
 catch(e) { this.error(e); }
 },
 assertHidden: function(element) {
 var message = arguments[1] || 'assertHidden';
 this.assertEqual("none", element.style.display, message);
 },
 assertNotNull: function(object) {
 var message = arguments[1] || 'assertNotNull';
 this.assert(object != null, message);
 },
 assertType: function(expected, actual) {
 var message = arguments[2] || 'assertType';
 try {
 (actual.constructor == expected) ? this.pass() :
 this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
 '", actual "' + (actual.constructor) + '"'); }
 catch(e) { this.error(e); }
 },
 assertNotOfType: function(expected, actual) {
 var message = arguments[2] || 'assertNotOfType';
 try {
 (actual.constructor != expected) ? this.pass() :
 this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
 '", actual "' + (actual.constructor) + '"'); }
 catch(e) { this.error(e); }
 },
 assertInstanceOf: function(expected, actual) {
 var message = arguments[2] || 'assertInstanceOf';
 try {
 (actual instanceof expected) ? this.pass() :
 this.fail(message + ": object was not an instance of the expected type"); }
 catch(e) { this.error(e); }
 },
 assertNotInstanceOf: function(expected, actual) {
 var message = arguments[2] || 'assertNotInstanceOf';
 try {
 !(actual instanceof expected) ? this.pass() :
 this.fail(message + ": object was an instance of the not expected type"); }
 catch(e) { this.error(e); }
 },
 assertRespondsTo: function(method, obj) {
 var message = arguments[2] || 'assertRespondsTo';
 try {
 (obj[method] && typeof obj[method] == 'function') ? this.pass() :
 this.fail(message + ": object doesn't respond to [" + method + "]"); }
 catch(e) { this.error(e); }
 },
 assertReturnsTrue: function(method, obj) {
 var message = arguments[2] || 'assertReturnsTrue';
 try {
 var m = obj[method];
 if(!m) m = obj['is'+method.charAt(0).toUpperCase()+method.slice(1)];
 m() ? this.pass() :
 this.fail(message + ": method returned false"); }
 catch(e) { this.error(e); }
 },
 assertReturnsFalse: function(method, obj) {
 var message = arguments[2] || 'assertReturnsFalse';
 try {
 var m = obj[method];
 if(!m) m = obj['is'+method.charAt(0).toUpperCase()+method.slice(1)];
 !m() ? this.pass() :
 this.fail(message + ": method returned true"); }
 catch(e) { this.error(e); }
 },
 assertRaise: function(exceptionName, method) {
 var message = arguments[2] || 'assertRaise';
 try {
 method();
 this.fail(message + ": exception expected but none was raised"); }
 catch(e) {
 ((exceptionName == null) || (e.name==exceptionName)) ? this.pass() : this.error(e);
 }
 },
 assertElementsMatch: function() {
 var expressions = $A(arguments), elements = $A(expressions.shift());
 if (elements.length != expressions.length) {
 this.fail('assertElementsMatch: size mismatch: ' + elements.length + ' elements, ' + expressions.length + ' expressions');
 return false;
 }
 elements.zip(expressions).all(function(pair, index) {
 var element = $(pair.first()), expression = pair.last();
 if (element.match(expression)) return true;
 this.fail('assertElementsMatch: (in index ' + index + ') expected ' + expression.inspect() + ' but got ' + element.inspect());
 }.bind(this)) && this.pass();
 },
 assertElementMatches: function(element, expression) {
 this.assertElementsMatch([element], expression);
 },
 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;
 },
 _isVisible: function(element) {
 element = $(element);
 if(!element.parentNode) return true;
 this.assertNotNull(element);
 if(element.style && Element.getStyle(element, 'display') == 'none')
 return false;

 return this._isVisible(element.parentNode);
 },
 assertNotVisible: function(element) {
 this.assert(!this._isVisible(element), Test.Unit.inspect(element) + " was not hidden and didn't have a hidden parent either. " + ("" || arguments[1]));
 },
 assertVisible: function(element) {
 this.assert(this._isVisible(element), Test.Unit.inspect(element) + " was not visible. " + ("" || arguments[1]));
 },
 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.Unit.Testcase = Class.create();
 Object.extend(Object.extend(Test.Unit.Testcase.prototype, Test.Unit.Assertions.prototype), {
 initialize: function(name, test, setup, teardown) {
 Test.Unit.Assertions.prototype.initialize.bind(this)();
 this.name = name;

 if(typeof test == 'string') {
 test = test.gsub(/(\.should[^\(]+\()/,'{0}this,');
 test = test.gsub(/(\.should[^\(]+)\(this,\)/,'{1}(this)');
 this.test = function() {
 eval('with(this){'+test+'}');
 }
 } else {
 this.test = test || function() {};
 }

 this.setup = setup || function() {};
 this.teardown = teardown || function() {};
 this.isWaiting = false;
 this.timeToWait = 1000;
 },
 wait: function(time, nextPart) {
 this.isWaiting = true;
 this.test = nextPart;
 this.timeToWait = time;
 },
 run: function() {
 try {
 try {
 if (!this.isWaiting) this.setup.bind(this)();
 this.isWaiting = false;
 this.test.bind(this)();
 } finally {
 if(!this.isWaiting) {
 this.teardown.bind(this)();
 }
 }
 }
 catch(e) { this.error(e); }
 }
 });

 // *EXPERIMENTAL* BDD-style testing to please non-technical folk
 // This draws many ideas from RSpec http://rspec.rubyforge.org/

 Test.setupBDDExtensionMethods = function(){
 var METHODMAP = {
 shouldEqual: 'assertEqual',
 shouldNotEqual: 'assertNotEqual',
 shouldEqualEnum: 'assertEnumEqual',
 shouldBeA: 'assertType',
 shouldNotBeA: 'assertNotOfType',
 shouldBeAn: 'assertType',
 shouldNotBeAn: 'assertNotOfType',
 shouldBeNull: 'assertNull',
 shouldNotBeNull: 'assertNotNull',

 shouldBe: 'assertReturnsTrue',
 shouldNotBe: 'assertReturnsFalse',
 shouldRespondTo: 'assertRespondsTo'
 };
 Test.BDDMethods = {};
 for(m in METHODMAP) {
 Test.BDDMethods[m] = eval(
 'function(){'+
 'var args = $A(arguments);'+
 'var scope = args.shift();'+
 'scope.'+METHODMAP[m]+'.apply(scope,(args || []).concat([this])); }');
 }
 [Array.prototype, String.prototype, Number.prototype].each(
 function(p){ Object.extend(p, Test.BDDMethods) }
 );
 }

 Test.context = function(name, spec, log){
 Test.setupBDDExtensionMethods();

 var compiledSpec = {};
 var titles = {};
 for(specName in spec) {
 switch(specName){
 case "setup":
 case "teardown":
 compiledSpec[specName] = spec[specName];
 break;
 default:
 var testName = 'test'+specName.gsub(/\s+/,'-').camelize();
 var body = spec[specName].toString().split('\n').slice(1);
 if(/^\{/.test(body[0])) body = body.slice(1);
 body.pop();
 body = body.map(function(statement){
 return statement.strip()
 });
 compiledSpec[testName] = body.join('\n');
 titles[testName] = specName;
 }
 }
 new Test.Unit.Runner(compiledSpec, { titles: titles, testLog: log || 'testlog', context: name });
 };