jsunitcore.js

Javascript code for developing the virtual keyboard

            Math.abs(expected - actual) < tolerance
            );
}

function assertContains() {
    _validateArguments(2, arguments);
    var contained = nonCommentArg(1, 2, arguments);
    var container = nonCommentArg(2, 2, arguments);
    assertTrue(
            "Expected '" + container + "' to contain '" + contained + "'",
            container.indexOf(contained) != -1
            );
}

function standardizeHTML(html) {
    var translator = document.createElement("DIV");
    translator.innerHTML = html;
    return translator.innerHTML;
}

function isLoaded() {
    return isTestPageLoaded;
}

function setUp() {
}

function tearDown() {
}

function getFunctionName(aFunction) {
    var regexpResult = aFunction.toString().match(/function(\s*)(\w*)/);
    if (regexpResult && regexpResult.length >= 2 && regexpResult[2]) {
        return regexpResult[2];
    }
    return 'anonymous';
}

function getStackTrace() {
    var result = '';

    if (typeof(arguments.caller) != 'undefined') { // IE, not ECMA
        for (var a = arguments.caller; a != null; a = a.caller) {
            result += '> ' + getFunctionName(a.callee) + '\n';
            if (a.caller == a) {
                result += '*';
                break;
            }
        }
    }
    else { // Mozilla, not ECMA
        // fake an exception so we can get Mozilla's error stack
        var testExcp;
        try
        {
            foo.bar;
        }
        catch(testExcp)
        {
            var stack = parseErrorStack(testExcp);
            for (var i = 1; i < stack.length; i++)
            {
                result += '> ' + stack[i] + '\n';
            }
        }
    }

    return result;
}

function parseErrorStack(excp)
{
    var stack = [];
    var name;

    if (!excp || !excp.stack)
    {
        return stack;
    }

    var stacklist = excp.stack.split('\n');

    for (var i = 0; i < stacklist.length - 1; i++)
    {
        var framedata = stacklist[i];

        name = framedata.match(/^(\w*)/)[1];
        if (!name) {
            name = 'anonymous';
        }

        stack[stack.length] = name;
    }
    // remove top level anonymous functions to match IE

    while (stack.length && stack[stack.length - 1] == 'anonymous')
    {
        stack.length = stack.length - 1;
    }
    return stack;
}

function JsUnitException(comment, message) {
    this.isJsUnitException = true;
    this.comment = comment;
    this.jsUnitMessage = message;
    this.stackTrace = getStackTrace();
}

function warn() {
    if (top.tracer != null)
        top.tracer.warn(arguments[0], arguments[1]);
}

function inform() {
    if (top.tracer != null)
        top.tracer.inform(arguments[0], arguments[1]);
}

function info() {
    inform(arguments[0], arguments[1]);
}

function debug() {
    if (top.tracer != null)
        top.tracer.debug(arguments[0], arguments[1]);
}

function setJsUnitTracer(aJsUnitTracer) {
    top.tracer = aJsUnitTracer;
}

function trim(str) {
    if (str == null)
        return null;

    var startingIndex = 0;
    var endingIndex = str.length - 1;

    while (str.substring(startingIndex, startingIndex + 1) == ' ')
        startingIndex++;

    while (str.substring(endingIndex, endingIndex + 1) == ' ')
        endingIndex--;

    if (endingIndex < startingIndex)
        return '';

    return str.substring(startingIndex, endingIndex + 1);
}

function isBlank(str) {
    return trim(str) == '';
}

// the functions push(anArray, anObject) and pop(anArray)
// exist because the JavaScript Array.push(anObject) and Array.pop()
// functions are not available in IE 5.0

function push(anArray, anObject) {
    anArray[anArray.length] = anObject;
}
function pop(anArray) {
    if (anArray.length >= 1) {
        delete anArray[anArray.length - 1];
        anArray.length--;
    }
}

function jsUnitGetParm(name)
{
    if (typeof(top.jsUnitParmHash[name]) != 'undefined')
    {
        return top.jsUnitParmHash[name];
    }
    return null;
}

if (top && typeof(top.xbDEBUG) != 'undefined' && top.xbDEBUG.on && top.testManager)
{
    top.xbDebugTraceObject('top.testManager.containerTestFrame', 'JSUnitException');
    // asserts
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', '_displayStringForValue');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'error');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'argumentsIncludeComments');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'commentArg');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'nonCommentArg');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', '_validateArguments');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', '_assert');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'assert');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'assertTrue');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'assertEquals');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'assertNotEquals');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'assertNull');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'assertNotNull');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'assertUndefined');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'assertNotUndefined');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'assertNaN');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'assertNotNaN');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'isLoaded');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'setUp');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'tearDown');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'getFunctionName');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'getStackTrace');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'warn');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'inform');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'debug');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'setJsUnitTracer');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'trim');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'isBlank');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'newOnLoadEvent');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'push');
    top.xbDebugTraceFunction('top.testManager.containerTestFrame', 'pop');
}

function newOnLoadEvent() {
    isTestPageLoaded = true;
}

function jsUnitSetOnLoad(windowRef, onloadHandler)
{
    var isKonqueror = navigator.userAgent.indexOf('Konqueror/') != -1 ||
                      navigator.userAgent.indexOf('Safari/') != -1;

    if (typeof(windowRef.attachEvent) != 'undefined') {
        // Internet Explorer, Opera
        windowRef.attachEvent("onload", onloadHandler);
    } else if (typeof(windowRef.addEventListener) != 'undefined' && !isKonqueror) {
        // Mozilla, Konqueror
        // exclude Konqueror due to load issues
        windowRef.addEventListener("load", onloadHandler, false);
    } else if (typeof(windowRef.document.addEventListener) != 'undefined' && !isKonqueror) {
        // DOM 2 Events
        // exclude Mozilla, Konqueror due to load issues
        windowRef.document.addEventListener("load", onloadHandler, false);
    } else if (typeof(windowRef.onload) != 'undefined' && windowRef.onload) {
        windowRef.jsunit_original_onload = windowRef.onload;
        windowRef.onload = function() {
            windowRef.jsunit_original_onload();
            onloadHandler();
        };
    } else {
        // browsers that do not support windowRef.attachEvent or
        // windowRef.addEventListener will override a page's own onload event
        windowRef.onload = onloadHandler;
    }
}

jsUnitSetOnLoad(window, newOnLoadEvent);

top.JSUNIT_JSCORE_LOCATION = findPath('jsUnitCore.js');
/**
 *  return full path to the script
 *
 *  @param {String} sname script name
 *  @return {String, Null} mixed string full path or null
 *  @scope public
 */
function findPath (sname /* :String */) /* :String */{
  var sc = document.getElementsByTagName('script'),
      sr = new RegExp('^(.*/|)('+sname+')([#?]|$)');
  for (var i=0,scL=sc.length; i<scL; i++) {
    // matched desired script
    var m = String(sc[i].src).match(sr);
    if (m) {
      /*
      *  we've matched the full path
      */
      if (m[1].match(/^((https?|file)\:\/{2,}|\w:[\\])/)) return m[1];
      /*
      *  we've matched absolute path from the site root
      */
      if (m[1].indexOf("/")==0) return m[1];
      b = document.getElementsByTagName('base');
      if (b[0] && b[0].href) return b[0].href+m[1];
      /*
      *  return matching part of the document location and path to js file
      */
      return (document.location.pathname.match(/(.*[\/\\])/)[0]+m[1]).replace(/^\/+(?=\w:)/,"");
    }
  }
  return null;
}