[extjs.git] / extjs / examples / classic / ticket-app / test / local / reporter.js

var Test = {};var isCommonJS = typeof window == "undefined" && typeof exports == "object";\r
\r
/**\r
 * Top level namespace for Jasmine, a lightweight JavaScript BDD/spec/testing framework.\r
 *\r
 * @namespace\r
 */\r
var jasmine = {};\r
if (isCommonJS) exports.jasmine = jasmine;\r
/**\r
 * @private\r
 */\r
jasmine.unimplementedMethod_ = function() {\r
  throw new Error("unimplemented method");\r
};\r
\r
/**\r
 * Use <code>jasmine.undefined</code> instead of <code>undefined</code>, since <code>undefined</code> is just\r
 * a plain old variable and may be redefined by somebody else.\r
 *\r
 * @private\r
 */\r
jasmine.undefined = jasmine.___undefined___;\r
\r
/**\r
 * Show diagnostic messages in the console if set to true\r
 *\r
 */\r
jasmine.VERBOSE = false;\r
\r
/**\r
 * Default interval in milliseconds for event loop yields (e.g. to allow network activity or to refresh the screen with the HTML-based runner). Small values here may result in slow test running. Zero means no updates until all tests have completed.\r
 *\r
 */\r
jasmine.DEFAULT_UPDATE_INTERVAL = 250;\r
\r
/**\r
 * Maximum levels of nesting that will be included when an object is pretty-printed\r
 */\r
jasmine.MAX_PRETTY_PRINT_DEPTH = 40;\r
\r
/**\r
 * Default timeout interval in milliseconds for waitsFor() blocks.\r
 */\r
jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;\r
\r
/**\r
 * By default exceptions thrown in the context of a test are caught by jasmine so that it can run the remaining tests in the suite.\r
 * Set to false to let the exception bubble up in the browser.\r
 *\r
 */\r
jasmine.CATCH_EXCEPTIONS = true;\r
\r
jasmine.getGlobal = function() {\r
  function getGlobal() {\r
    return this;\r
  }\r
\r
  return getGlobal();\r
};\r
\r
/**\r
 * Allows for bound functions to be compared.  Internal use only.\r
 *\r
 * @ignore\r
 * @private\r
 * @param base {Object} bound 'this' for the function\r
 * @param name {Function} function to find\r
 */\r
jasmine.bindOriginal_ = function(base, name) {\r
  var original = base[name];\r
  if (original.apply) {\r
    return function() {\r
      return original.apply(base, arguments);\r
    };\r
  } else {\r
    // IE support\r
    return jasmine.getGlobal()[name];\r
  }\r
};\r
\r
jasmine.setTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'setTimeout');\r
jasmine.clearTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearTimeout');\r
jasmine.setInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'setInterval');\r
jasmine.clearInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearInterval');\r
\r
jasmine.MessageResult = function(values) {\r
  this.type = 'log';\r
  this.values = values;\r
  this.trace = new Error(); // todo: test better\r
};\r
\r
jasmine.MessageResult.prototype.toString = function() {\r
  var text = "";\r
  for (var i = 0; i < this.values.length; i++) {\r
    if (i > 0) text += " ";\r
    if (jasmine.isString_(this.values[i])) {\r
      text += this.values[i];\r
    } else {\r
      text += jasmine.pp(this.values[i]);\r
    }\r
  }\r
  return text;\r
};\r
\r
jasmine.ExpectationResult = function(params) {\r
  this.type = 'expect';\r
  this.matcherName = params.matcherName;\r
  this.passed_ = params.passed;\r
  this.expected = params.expected;\r
  this.actual = params.actual;\r
  this.message = this.passed_ ? 'Passed.' : params.message;\r
\r
  var trace = (params.trace || new Error(this.message));\r
  this.trace = this.passed_ ? '' : trace;\r
};\r
\r
jasmine.ExpectationResult.prototype.toString = function () {\r
  return this.message;\r
};\r
\r
jasmine.ExpectationResult.prototype.passed = function () {\r
  return this.passed_;\r
};\r
\r
/**\r
 * Getter for the Jasmine environment. Ensures one gets created\r
 */\r
jasmine.getEnv = function() {\r
  var env = jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env();\r
  return env;\r
};\r
\r
/**\r
 * @ignore\r
 * @private\r
 * @param value\r
 * @returns {Boolean}\r
 */\r
jasmine.isArray_ = function(value) {\r
  return jasmine.isA_("Array", value);\r
};\r
\r
/**\r
 * @ignore\r
 * @private\r
 * @param value\r
 * @returns {Boolean}\r
 */\r
jasmine.isString_ = function(value) {\r
  return jasmine.isA_("String", value);\r
};\r
\r
/**\r
 * @ignore\r
 * @private\r
 * @param value\r
 * @returns {Boolean}\r
 */\r
jasmine.isNumber_ = function(value) {\r
  return jasmine.isA_("Number", value);\r
};\r
\r
/**\r
 * @ignore\r
 * @private\r
 * @param {String} typeName\r
 * @param value\r
 * @returns {Boolean}\r
 */\r
jasmine.isA_ = function(typeName, value) {\r
  return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';\r
};\r
\r
/**\r
 * Pretty printer for expecations.  Takes any object and turns it into a human-readable string.\r
 *\r
 * @param value {Object} an object to be outputted\r
 * @returns {String}\r
 */\r
jasmine.pp = function(value) {\r
  var stringPrettyPrinter = new jasmine.StringPrettyPrinter();\r
  stringPrettyPrinter.format(value);\r
  return stringPrettyPrinter.string;\r
};\r
\r
/**\r
 * Returns true if the object is a DOM Node.\r
 *\r
 * @param {Object} obj object to check\r
 * @returns {Boolean}\r
 */\r
jasmine.isDomNode = function(obj) {\r
  return obj.nodeType > 0;\r
};\r
\r
/**\r
 * Returns a matchable 'generic' object of the class type.  For use in expecations of type when values don't matter.\r
 *\r
 * @example\r
 * // don't care about which function is passed in, as long as it's a function\r
 * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function));\r
 *\r
 * @param {Class} clazz\r
 * @returns matchable object of the type clazz\r
 */\r
jasmine.any = function(clazz) {\r
  return new jasmine.Matchers.Any(clazz);\r
};\r
\r
/**\r
 * Returns a matchable subset of a JSON object. For use in expectations when you don't care about all of the\r
 * attributes on the object.\r
 *\r
 * @example\r
 * // don't care about any other attributes than foo.\r
 * expect(mySpy).toHaveBeenCalledWith(jasmine.objectContaining({foo: "bar"});\r
 *\r
 * @param sample {Object} sample\r
 * @returns matchable object for the sample\r
 */\r
jasmine.objectContaining = function (sample) {\r
    return new jasmine.Matchers.ObjectContaining(sample);\r
};\r
\r
/**\r
 * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks.\r
 *\r
 * Spies should be created in test setup, before expectations.  They can then be checked, using the standard Jasmine\r
 * expectation syntax. Spies can be checked if they were called or not and what the calling params were.\r
 *\r
 * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs).\r
 *\r
 * Spies are torn down at the end of every spec.\r
 *\r
 * Note: Do <b>not</b> call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.\r
 *\r
 * @example\r
 * // a stub\r
 * var myStub = jasmine.createSpy('myStub');  // can be used anywhere\r
 *\r
 * // spy example\r
 * var foo = {\r
 *   not: function(bool) { return !bool; }\r
 * }\r
 *\r
 * // actual foo.not will not be called, execution stops\r
 * spyOn(foo, 'not');\r
\r
 // foo.not spied upon, execution will continue to implementation\r
 * spyOn(foo, 'not').andCallThrough();\r
 *\r
 * // fake example\r
 * var foo = {\r
 *   not: function(bool) { return !bool; }\r
 * }\r
 *\r
 * // foo.not(val) will return val\r
 * spyOn(foo, 'not').andCallFake(function(value) {return value;});\r
 *\r
 * // mock example\r
 * foo.not(7 == 7);\r
 * expect(foo.not).toHaveBeenCalled();\r
 * expect(foo.not).toHaveBeenCalledWith(true);\r
 *\r
 * @constructor\r
 * @see spyOn, jasmine.createSpy, jasmine.createSpyObj\r
 * @param {String} name\r
 */\r
jasmine.Spy = function(name) {\r
  /**\r
   * The name of the spy, if provided.\r
   */\r
  this.identity = name || 'unknown';\r
  /**\r
   *  Is this Object a spy?\r
   */\r
  this.isSpy = true;\r
  /**\r
   * The actual function this spy stubs.\r
   */\r
  this.plan = function() {\r
  };\r
  /**\r
   * Tracking of the most recent call to the spy.\r
   * @example\r
   * var mySpy = jasmine.createSpy('foo');\r
   * mySpy(1, 2);\r
   * mySpy.mostRecentCall.args = [1, 2];\r
   */\r
  this.mostRecentCall = {};\r
\r
  /**\r
   * Holds arguments for each call to the spy, indexed by call count\r
   * @example\r
   * var mySpy = jasmine.createSpy('foo');\r
   * mySpy(1, 2);\r
   * mySpy(7, 8);\r
   * mySpy.mostRecentCall.args = [7, 8];\r
   * mySpy.argsForCall[0] = [1, 2];\r
   * mySpy.argsForCall[1] = [7, 8];\r
   */\r
  this.argsForCall = [];\r
  this.calls = [];\r
};\r
\r
/**\r
 * Tells a spy to call through to the actual implemenatation.\r
 *\r
 * @example\r
 * var foo = {\r
 *   bar: function() { // do some stuff }\r
 * }\r
 *\r
 * // defining a spy on an existing property: foo.bar\r
 * spyOn(foo, 'bar').andCallThrough();\r
 */\r
jasmine.Spy.prototype.andCallThrough = function() {\r
  this.plan = this.originalValue;\r
  return this;\r
};\r
\r
/**\r
 * For setting the return value of a spy.\r
 *\r
 * @example\r
 * // defining a spy from scratch: foo() returns 'baz'\r
 * var foo = jasmine.createSpy('spy on foo').andReturn('baz');\r
 *\r
 * // defining a spy on an existing property: foo.bar() returns 'baz'\r
 * spyOn(foo, 'bar').andReturn('baz');\r
 *\r
 * @param {Object} value\r
 */\r
jasmine.Spy.prototype.andReturn = function(value) {\r
  this.plan = function() {\r
    return value;\r
  };\r
  return this;\r
};\r
\r
/**\r
 * For throwing an exception when a spy is called.\r
 *\r
 * @example\r
 * // defining a spy from scratch: foo() throws an exception w/ message 'ouch'\r
 * var foo = jasmine.createSpy('spy on foo').andThrow('baz');\r
 *\r
 * // defining a spy on an existing property: foo.bar() throws an exception w/ message 'ouch'\r
 * spyOn(foo, 'bar').andThrow('baz');\r
 *\r
 * @param {String} exceptionMsg\r
 */\r
jasmine.Spy.prototype.andThrow = function(exceptionMsg) {\r
  this.plan = function() {\r
    throw exceptionMsg;\r
  };\r
  return this;\r
};\r
\r
/**\r
 * Calls an alternate implementation when a spy is called.\r
 *\r
 * @example\r
 * var baz = function() {\r
 *   // do some stuff, return something\r
 * }\r
 * // defining a spy from scratch: foo() calls the function baz\r
 * var foo = jasmine.createSpy('spy on foo').andCall(baz);\r
 *\r
 * // defining a spy on an existing property: foo.bar() calls an anonymnous function\r
 * spyOn(foo, 'bar').andCall(function() { return 'baz';} );\r
 *\r
 * @param {Function} fakeFunc\r
 */\r
jasmine.Spy.prototype.andCallFake = function(fakeFunc) {\r
  this.plan = fakeFunc;\r
  return this;\r
};\r
\r
/**\r
 * Resets all of a spy's the tracking variables so that it can be used again.\r
 *\r
 * @example\r
 * spyOn(foo, 'bar');\r
 *\r
 * foo.bar();\r
 *\r
 * expect(foo.bar.callCount).toEqual(1);\r
 *\r
 * foo.bar.reset();\r
 *\r
 * expect(foo.bar.callCount).toEqual(0);\r
 */\r
jasmine.Spy.prototype.reset = function() {\r
  this.wasCalled = false;\r
  this.callCount = 0;\r
  this.argsForCall = [];\r
  this.calls = [];\r
  this.mostRecentCall = {};\r
};\r
\r
jasmine.createSpy = function(name) {\r
\r
  var spyObj = function() {\r
    spyObj.wasCalled = true;\r
    spyObj.callCount++;\r
    var args = jasmine.util.argsToArray(arguments);\r
    spyObj.mostRecentCall.object = this;\r
    spyObj.mostRecentCall.args = args;\r
    spyObj.argsForCall.push(args);\r
    spyObj.calls.push({object: this, args: args});\r
    return spyObj.plan.apply(this, arguments);\r
  };\r
\r
  var spy = new jasmine.Spy(name);\r
\r
  for (var prop in spy) {\r
    spyObj[prop] = spy[prop];\r
  }\r
\r
  spyObj.reset();\r
\r
  return spyObj;\r
};\r
\r
/**\r
 * Determines whether an object is a spy.\r
 *\r
 * @param {jasmine.Spy|Object} putativeSpy\r
 * @returns {Boolean}\r
 */\r
jasmine.isSpy = function(putativeSpy) {\r
  return putativeSpy && putativeSpy.isSpy;\r
};\r
\r
/**\r
 * Creates a more complicated spy: an Object that has every property a function that is a spy.  Used for stubbing something\r
 * large in one call.\r
 *\r
 * @param {String} baseName name of spy class\r
 * @param {Array} methodNames array of names of methods to make spies\r
 */\r
jasmine.createSpyObj = function(baseName, methodNames) {\r
  if (!jasmine.isArray_(methodNames) || methodNames.length === 0) {\r
    throw new Error('createSpyObj requires a non-empty array of method names to create spies for');\r
  }\r
  var obj = {};\r
  for (var i = 0; i < methodNames.length; i++) {\r
    obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]);\r
  }\r
  return obj;\r
};\r
\r
/**\r
 * All parameters are pretty-printed and concatenated together, then written to the current spec's output.\r
 *\r
 * Be careful not to leave calls to <code>jasmine.log</code> in production code.\r
 */\r
jasmine.log = function() {\r
  var spec = jasmine.getEnv().currentSpec;\r
  spec.log.apply(spec, arguments);\r
};\r
\r
/**\r
 * Function that installs a spy on an existing object's method name.  Used within a Spec to create a spy.\r
 *\r
 * @example\r
 * // spy example\r
 * var foo = {\r
 *   not: function(bool) { return !bool; }\r
 * }\r
 * spyOn(foo, 'not'); // actual foo.not will not be called, execution stops\r
 *\r
 * @see jasmine.createSpy\r
 * @param obj\r
 * @param methodName\r
 * @return {jasmine.Spy} a Jasmine spy that can be chained with all spy methods\r
 */\r
var spyOn = function(obj, methodName) {\r
  return jasmine.getEnv().currentSpec.spyOn(obj, methodName);\r
};\r
if (isCommonJS) exports.spyOn = spyOn;\r
\r
/**\r
 * Creates a Jasmine spec that will be added to the current suite.\r
 *\r
 * // TODO: pending tests\r
 *\r
 * @example\r
 * it('should be true', function() {\r
 *   expect(true).toEqual(true);\r
 * });\r
 *\r
 * @param {String} desc description of this specification\r
 * @param {Function} func defines the preconditions and expectations of the spec\r
 */\r
var it = function(desc, func) {\r
  return jasmine.getEnv().it(desc, func);\r
};\r
if (isCommonJS) exports.it = it;\r
\r
/**\r
 * Creates a <em>disabled</em> Jasmine spec.\r
 *\r
 * A convenience method that allows existing specs to be disabled temporarily during development.\r
 *\r
 * @param {String} desc description of this specification\r
 * @param {Function} func defines the preconditions and expectations of the spec\r
 */\r
var xit = function(desc, func) {\r
  return jasmine.getEnv().xit(desc, func);\r
};\r
if (isCommonJS) exports.xit = xit;\r
\r
/**\r
 * Starts a chain for a Jasmine expectation.\r
 *\r
 * It is passed an Object that is the actual value and should chain to one of the many\r
 * jasmine.Matchers functions.\r
 *\r
 * @param {Object} actual Actual value to test against and expected value\r
 * @return {jasmine.Matchers}\r
 */\r
var expect = function(actual) {\r
  return jasmine.getEnv().currentSpec.expect(actual);\r
};\r
if (isCommonJS) exports.expect = expect;\r
\r
/**\r
 * Defines part of a jasmine spec.  Used in cominbination with waits or waitsFor in asynchrnous specs.\r
 *\r
 * @param {Function} func Function that defines part of a jasmine spec.\r
 */\r
var runs = function(func) {\r
  jasmine.getEnv().currentSpec.runs(func);\r
};\r
if (isCommonJS) exports.runs = runs;\r
\r
/**\r
 * Waits a fixed time period before moving to the next block.\r
 *\r
 * @deprecated Use waitsFor() instead\r
 * @param {Number} timeout milliseconds to wait\r
 */\r
var waits = function(timeout) {\r
  jasmine.getEnv().currentSpec.waits(timeout);\r
};\r
if (isCommonJS) exports.waits = waits;\r
\r
/**\r
 * Waits for the latchFunction to return true before proceeding to the next block.\r
 *\r
 * @param {Function} latchFunction\r
 * @param {String} optional_timeoutMessage\r
 * @param {Number} optional_timeout\r
 */\r
var waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {\r
  jasmine.getEnv().currentSpec.waitsFor.apply(jasmine.getEnv().currentSpec, arguments);\r
};\r
if (isCommonJS) exports.waitsFor = waitsFor;\r
\r
/**\r
 * A function that is called before each spec in a suite.\r
 *\r
 * Used for spec setup, including validating assumptions.\r
 *\r
 * @param {Function} beforeEachFunction\r
 */\r
var beforeEach = function(beforeEachFunction) {\r
  jasmine.getEnv().beforeEach(beforeEachFunction);\r
};\r
if (isCommonJS) exports.beforeEach = beforeEach;\r
\r
/**\r
 * A function that is called after each spec in a suite.\r
 *\r
 * Used for restoring any state that is hijacked during spec execution.\r
 *\r
 * @param {Function} afterEachFunction\r
 */\r
var afterEach = function(afterEachFunction) {\r
  jasmine.getEnv().afterEach(afterEachFunction);\r
};\r
if (isCommonJS) exports.afterEach = afterEach;\r
\r
/**\r
 * Defines a suite of specifications.\r
 *\r
 * Stores the description and all defined specs in the Jasmine environment as one suite of specs. Variables declared\r
 * are accessible by calls to beforeEach, it, and afterEach. Describe blocks can be nested, allowing for specialization\r
 * of setup in some tests.\r
 *\r
 * @example\r
 * // TODO: a simple suite\r
 *\r
 * // TODO: a simple suite with a nested describe block\r
 *\r
 * @param {String} description A string, usually the class under test.\r
 * @param {Function} specDefinitions function that defines several specs.\r
 */\r
var describe = function(description, specDefinitions) {\r
  return jasmine.getEnv().describe(description, specDefinitions);\r
};\r
if (isCommonJS) exports.describe = describe;\r
\r
/**\r
 * Disables a suite of specifications.  Used to disable some suites in a file, or files, temporarily during development.\r
 *\r
 * @param {String} description A string, usually the class under test.\r
 * @param {Function} specDefinitions function that defines several specs.\r
 */\r
var xdescribe = function(description, specDefinitions) {\r
  return jasmine.getEnv().xdescribe(description, specDefinitions);\r
};\r
if (isCommonJS) exports.xdescribe = xdescribe;\r
\r
\r
// Provide the XMLHttpRequest class for IE 5.x-6.x:\r
jasmine.XmlHttpRequest = (typeof XMLHttpRequest == "undefined") ? function() {\r
  function tryIt(f) {\r
    try {\r
      return f();\r
    } catch(e) {\r
    }\r
    return null;\r
  }\r
\r
  var xhr = tryIt(function() {\r
    return new ActiveXObject("Msxml2.XMLHTTP.6.0");\r
  }) ||\r
    tryIt(function() {\r
      return new ActiveXObject("Msxml2.XMLHTTP.3.0");\r
    }) ||\r
    tryIt(function() {\r
      return new ActiveXObject("Msxml2.XMLHTTP");\r
    }) ||\r
    tryIt(function() {\r
      return new ActiveXObject("Microsoft.XMLHTTP");\r
    });\r
\r
  if (!xhr) throw new Error("This browser does not support XMLHttpRequest.");\r
\r
  return xhr;\r
} : XMLHttpRequest;\r
/**\r
 * @namespace\r
 */\r
jasmine.util = {};\r
\r
/**\r
 * Declare that a child class inherit it's prototype from the parent class.\r
 *\r
 * @private\r
 * @param {Function} childClass\r
 * @param {Function} parentClass\r
 */\r
jasmine.util.inherit = function(childClass, parentClass) {\r
  /**\r
   * @private\r
   */\r
  var subclass = function() {\r
  };\r
  subclass.prototype = parentClass.prototype;\r
  childClass.prototype = new subclass();\r
};\r
\r
jasmine.util.formatException = function(e) {\r
  var lineNumber;\r
  if (e.line) {\r
    lineNumber = e.line;\r
  }\r
  else if (e.lineNumber) {\r
    lineNumber = e.lineNumber;\r
  }\r
\r
  var file;\r
\r
  if (e.sourceURL) {\r
    file = e.sourceURL;\r
  }\r
  else if (e.fileName) {\r
    file = e.fileName;\r
  }\r
\r
  var message = (e.name && e.message) ? (e.name + ': ' + e.message) : e.toString();\r
\r
  if (file && lineNumber) {\r
    message += ' in ' + file + ' (line ' + lineNumber + ')';\r
  }\r
\r
  return message;\r
};\r
\r
jasmine.util.htmlEscape = function(str) {\r
  if (!str) return str;\r
  return str.replace(/&/g, '&amp;')\r
    .replace(/</g, '&lt;')\r
    .replace(/>/g, '&gt;');\r
};\r
\r
jasmine.util.argsToArray = function(args) {\r
  var arrayOfArgs = [];\r
  for (var i = 0; i < args.length; i++) arrayOfArgs.push(args[i]);\r
  return arrayOfArgs;\r
};\r
\r
jasmine.util.extend = function(destination, source) {\r
  for (var property in source) destination[property] = source[property];\r
  return destination;\r
};\r
\r
/**\r
 * Base class for pretty printing for expectation results.\r
 */\r
jasmine.PrettyPrinter = function() {\r
  this.ppNestLevel_ = 0;\r
};\r
\r
/**\r
 * Formats a value in a nice, human-readable string.\r
 *\r
 * @param value\r
 */\r
jasmine.PrettyPrinter.prototype.format = function(value) {\r
  this.ppNestLevel_++;\r
  try {\r
    if (value === jasmine.undefined) {\r
      this.emitScalar('undefined');\r
    } else if (value === null) {\r
      this.emitScalar('null');\r
    } else if (value === jasmine.getGlobal()) {\r
      this.emitScalar('<global>');\r
    } else if (value.jasmineToString) {\r
      this.emitScalar(value.jasmineToString());\r
    } else if (typeof value === 'string') {\r
      this.emitString(value);\r
    } else if (jasmine.isSpy(value)) {\r
      this.emitScalar("spy on " + value.identity);\r
    } else if (value instanceof RegExp) {\r
      this.emitScalar(value.toString());\r
    } else if (typeof value === 'function') {\r
      this.emitScalar('Function');\r
    } else if (typeof value.nodeType === 'number') {\r
      this.emitScalar('HTMLNode');\r
    } else if (value instanceof Date) {\r
      this.emitScalar('Date(' + value + ')');\r
    } else if (value.__Jasmine_been_here_before__) {\r
      this.emitScalar('<circular reference: ' + (jasmine.isArray_(value) ? 'Array' : 'Object') + '>');\r
    } else if (jasmine.isArray_(value) || typeof value == 'object') {\r
      value.__Jasmine_been_here_before__ = true;\r
      if (jasmine.isArray_(value)) {\r
        this.emitArray(value);\r
      } else {\r
        this.emitObject(value);\r
      }\r
      delete value.__Jasmine_been_here_before__;\r
    } else {\r
      this.emitScalar(value.toString());\r
    }\r
  } finally {\r
    this.ppNestLevel_--;\r
  }\r
};\r
\r
jasmine.PrettyPrinter.prototype.iterateObject = function(obj, fn) {\r
  for (var property in obj) {\r
    if (!obj.hasOwnProperty(property)) continue;\r
    if (property == '__Jasmine_been_here_before__') continue;\r
    fn(property, obj.__lookupGetter__ ? (obj.__lookupGetter__(property) !== jasmine.undefined && \r
                                         obj.__lookupGetter__(property) !== null) : false);\r
  }\r
};\r
\r
jasmine.PrettyPrinter.prototype.emitArray = jasmine.unimplementedMethod_;\r
jasmine.PrettyPrinter.prototype.emitObject = jasmine.unimplementedMethod_;\r
jasmine.PrettyPrinter.prototype.emitScalar = jasmine.unimplementedMethod_;\r
jasmine.PrettyPrinter.prototype.emitString = jasmine.unimplementedMethod_;\r
\r
jasmine.StringPrettyPrinter = function() {\r
  jasmine.PrettyPrinter.call(this);\r
\r
  this.string = '';\r
};\r
jasmine.util.inherit(jasmine.StringPrettyPrinter, jasmine.PrettyPrinter);\r
\r
jasmine.StringPrettyPrinter.prototype.emitScalar = function(value) {\r
  this.append(value);\r
};\r
\r
jasmine.StringPrettyPrinter.prototype.emitString = function(value) {\r
  this.append("'" + value + "'");\r
};\r
\r
jasmine.StringPrettyPrinter.prototype.emitArray = function(array) {\r
  if (this.ppNestLevel_ > jasmine.MAX_PRETTY_PRINT_DEPTH) {\r
    this.append("Array");\r
    return;\r
  }\r
\r
  this.append('[ ');\r
  for (var i = 0; i < array.length; i++) {\r
    if (i > 0) {\r
      this.append(', ');\r
    }\r
    this.format(array[i]);\r
  }\r
  this.append(' ]');\r
};\r
\r
jasmine.StringPrettyPrinter.prototype.emitObject = function(obj) {\r
  if (this.ppNestLevel_ > jasmine.MAX_PRETTY_PRINT_DEPTH) {\r
    this.append("Object");\r
    return;\r
  }\r
\r
  var self = this;\r
  this.append('{ ');\r
  var first = true;\r
\r
  this.iterateObject(obj, function(property, isGetter) {\r
    if (first) {\r
      first = false;\r
    } else {\r
      self.append(', ');\r
    }\r
\r
    self.append(property);\r
    self.append(' : ');\r
    if (isGetter) {\r
      self.append('<getter>');\r
    } else {\r
      self.format(obj[property]);\r
    }\r
  });\r
\r
  this.append(' }');\r
};\r
\r
jasmine.StringPrettyPrinter.prototype.append = function(value) {\r
  this.string += value;\r
};\r
/**\r
 * Formats a value in a nice, human-readable string.\r
 *\r
 * @param value\r
 */\r
jasmine.PrettyPrinter.prototype.format = function(value) {\r
  if (this.ppNestLevel_ > 40) {\r
    throw new Error('jasmine.PrettyPrinter: format() nested too deeply!');\r
  }\r
\r
  this.ppNestLevel_++;\r
  try {\r
    if (value === jasmine.undefined) {\r
      this.emitScalar('undefined');\r
    } else if (value === null) {\r
      this.emitScalar('null');\r
    } else if (value === jasmine.getGlobal()) {\r
      this.emitScalar('<global>');\r
    } else if (value.expectedClass) {   //override of value instanceof jasmine.Matchers.Any\r
      this.emitScalar(value.toString());\r
    } else if (typeof value === 'string') {\r
      this.emitString(value);\r
    } else if (jasmine.isSpy(value)) {\r
      this.emitScalar("spy on " + value.identity);\r
    } else if (value instanceof RegExp) {\r
      this.emitScalar(value.toString());\r
    } else if (typeof value === 'function') {\r
      this.emitScalar('Function');\r
    } else if (typeof value.nodeType === 'number') {\r
      this.emitScalar('HTMLNode');\r
    } else if (value instanceof Date) {\r
      this.emitScalar('Date(' + value + ')');\r
    } else if (value.__Jasmine_been_here_before__) {\r
      this.emitScalar('<circular reference: ' + (jasmine.isArray_(value) ? 'Array' : 'Object') + '>');\r
    } else if (jasmine.isArray_(value) || typeof value == 'object') {\r
      value.__Jasmine_been_here_before__ = true;\r
      if (jasmine.isArray_(value)) {\r
        this.emitArray(value);\r
      } else {\r
        this.emitObject(value);\r
      }\r
      delete value.__Jasmine_been_here_before__;\r
    } else {\r
      this.emitScalar(value.toString());\r
    }\r
  } catch (e) {\r
  } finally {\r
    this.ppNestLevel_--;\r
  }\r
};\r
\r
\r
// Extend: creates whitespaces indent\r
jasmine.StringPrettyPrinter.prototype.getIndent = function () {\r
    var whiteSpaces = "",\r
        i;\r
        \r
    for (i = 0; i < this.ws; i++) {\r
        whiteSpaces += " ";\r
    }\r
\r
    return whiteSpaces;\r
};\r
\r
// Override: pre-format object\r
jasmine.StringPrettyPrinter.prototype.emitObject = function(obj) {\r
  var self = this,\r
      first = true,\r
      indent;\r
      \r
  this.append('{\n');\r
  if(!this.ws) {\r
      this.ws = 0;\r
  }\r
  this.ws += 4;\r
  indent = this.getIndent();\r
  var i = 0;\r
  this.iterateObject(obj, function(property, isGetter) {\r
      \r
    if (first) {\r
      first = false;\r
    } else {\r
      self.append(',\n');\r
    }\r
\r
    self.append(indent + property);\r
    self.append(' : ');\r
    if (isGetter) {\r
      self.append('<getter>');\r
    } else {\r
      if (typeof obj[property] !== "object") {\r
         self.format(obj[property]);   \r
      } else {\r
         self.append("<Object>");\r
      }\r
    }\r
  });\r
  \r
  this.ws -= 4;\r
  indent = this.getIndent();\r
  \r
  this.append(indent + '\n'+ indent +'}');\r
\r
};\r
/**\r
 * Basic browsers detection.\r
 */\r
jasmine.browser = {};\r
jasmine.browser.isIE = !!window.ActiveXObject;\r
jasmine.browser.isIE6 = jasmine.browser.isIE && !window.XMLHttpRequest;\r
jasmine.browser.isIE7 = jasmine.browser.isIE && !!window.XMLHttpRequest && !document.documentMode;\r
jasmine.browser.isIE8 = jasmine.browser.isIE && !!window.XMLHttpRequest && !!document.documentMode && !window.performance;\r
jasmine.browser.isIE9 = jasmine.browser.isIE && !!window.performance;\r
jasmine.browser.isSafari3 = /safari/.test(navigator.userAgent.toLowerCase()) && /version\/3/.test(navigator.userAgent.toLowerCase());\r
jasmine.browser.isOpera = !!window.opera;\r
jasmine.browser.isOpera11 = jasmine.browser.isOpera && parseInt(window.opera.version(), 10) > 10;\r
jasmine.array = {};\r
\r
  /**\r
     * Checks whether or not the specified item exists in the array.\r
     * Array.prototype.indexOf is missing in Internet Explorer, unfortunately.\r
     * We always have to use this static method instead for consistency\r
     * @param {Array} array The array to check\r
     * @param {Mixed} item The item to look for\r
     * @param {Number} from (Optional) The index at which to begin the search\r
     * @return {Number} The index of item in the array (or -1 if it is not found)\r
     */\r
jasmine.array.indexOf = function(array, item, from){\r
    if (array.indexOf) {\r
        return array.indexOf(item, from);\r
    }\r
        \r
    var i, length = array.length;\r
\r
    for (i = (from < 0) ? Math.max(0, length + from) : from || 0; i < length; i++){\r
    if (array[i] === item) {\r
                return i;\r
            }\r
    }\r
\r
    return -1;\r
};\r
\r
 /**\r
  * Removes the specified item from the array. If the item is not found nothing happens.\r
  * @param {Array} array The array\r
  * @param {Mixed} item The item to remove\r
  * @return {Array} The passed array itself\r
  */\r
jasmine.array.remove = function(array, item) {\r
    var index = this.indexOf(array, item);\r
\r
    if (index !== -1) {\r
        array.splice(index, 1);\r
    }\r
    \r
    return array;\r
};/**\r
 * Creates an HTMLElement.\r
 * @param {Object/HTMLElement} config Ext DomHelper style element config object.\r
 * If no tag is specified (e.g., {tag:'input'}) then a div will be automatically generated with the specified attributes.\r
 * @return {HTMLElement} The created HTMLElement\r
 */\r
jasmine.Dom = function(config) {\r
    var element, children, length, child, i, property;\r
    \r
    config = config || {};\r
    \r
    if (config.tagName) {\r
        return config;\r
    }\r
    \r
    element = document.createElement(config.tag || "div");\r
        children = config.children || [];\r
        length = children.length;\r
\r
    delete config.tag;\r
    \r
    for (i = 0; i < length; i++) {\r
        child = children[i];\r
        element.appendChild(new jasmine.Dom(child));\r
    }\r
    delete config.children;\r
    \r
    if (config.cls) {\r
        jasmine.Dom.setCls(element, config.cls);\r
        delete config.cls;\r
    }\r
\r
    if (config.html) {\r
        jasmine.Dom.setHTML(element, config.html);\r
        delete config.html;\r
    }\r
\r
    if (config.style) {\r
        jasmine.Dom.setStyle(element, config.style);\r
        delete config.style;\r
    }\r
    \r
    for (property in config) {\r
        if (!config.hasOwnProperty(property)) {\r
            continue;\r
        }\r
        element[property] = config[property];\r
    }\r
\r
    return element;\r
};\r
\r
/**\r
 * Adds className to an HTMLElement.\r
 * @param {HTMLElement} element The HTMLElement\r
 * @param {String} cls The className string\r
 */\r
jasmine.Dom.addCls = function (element, cls) {\r
    var split, length, i;\r
    \r
    if (!element.className) {\r
        jasmine.Dom.setCls(element, cls);\r
        return;\r
    }\r
    \r
    split = element.className.split(" ");\r
    length = split.length;\r
    \r
    for (i = 0; i < length; i++) {\r
        if (split[i] == cls) {\r
            return;\r
        }\r
    }\r
    \r
    element.className = element.className + " " + cls;\r
};\r
\r
/**\r
 * Removes className to HTMLElement.\r
 * @param {HTMLElement} element The HTMLElement\r
 * @param {String} cls The className string\r
 */\r
jasmine.Dom.removeCls = function(element, cls) {\r
    var split, length, classArray, i;\r
    \r
    if (!element.className) {\r
        return;\r
    }\r
    \r
    classArray = [];\r
    split = element.className.split(" ");\r
    length = split.length;\r
    \r
    for (i = 0; i < length; i++) {\r
        if (split[i] !== cls) {\r
            classArray.push(split[i]);\r
        }\r
    }\r
    \r
    element.className = classArray.join(" ");    \r
};\r
\r
/**\r
 * Checks if a dom element has a className.\r
 * @param {HTMLElement} element The HTMLElement\r
 * @param {String} cls The className string\r
 * @return {Boolean}\r
 */\r
jasmine.Dom.hasCls = function(element, cls) {\r
    var split, length, classArray, i;\r
    \r
    if (!element.className) {\r
        return;\r
    }\r
    \r
    split = element.className.split(" ");\r
    length = split.length;\r
    \r
    for (i = 0; i < length; i++) {\r
        if (split[i] === cls) {\r
            return true;\r
        }\r
    }\r
    \r
    return false;   \r
};\r
\r
/**\r
 * Sets HTMLElement className.\r
 * @param {HTMLElement} element The HTMLElement\r
 * @param {String} cls The className string\r
 */\r
jasmine.Dom.setCls = function(element, cls) {\r
    element.className = cls;\r
};\r
\r
/**\r
 * Sets HTMLElement innerHTML\r
 * @param {HTMLElement} element The HTMLElement\r
 * @param {String} html The innerHTML text\r
 */\r
jasmine.Dom.setHTML = function(element, html) {\r
    element.innerHTML = html;\r
};\r
\r
/**\r
 * Sets HTMLElement style\r
 * @param {HTMLElement} element The HTMLElement\r
 * @param {String} style The style property to set\r
 */\r
jasmine.Dom.setStyle = function(element, style) {\r
    var property;\r
    for (property in style) {\r
        if (style.hasOwnProperty(property)) {\r
            element.style[property] = style[property];\r
        }\r
    }\r
};\r
Test.OptionsImpl = function() {\r
    this.optionCheckBoxesEl = {};\r
    this.options = this.urlDecode(window.location.search.substring(1));\r
    this.options.remote = window.location.toString().search("http:") !== -1;\r
    this.startAutoReloadTask();\r
    \r
};\r
\r
Test.OptionsImpl.prototype.get = function() {\r
    return this.options;\r
};\r
\r
/**\r
 * Takes an object and converts it to an encoded URL.\r
 * @param {Object} o The object to encode\r
 * @return {String}\r
 */\r
Test.OptionsImpl.prototype.urlEncode = function(object) {\r
    var buf = [],\r
        e = encodeURIComponent,\r
        value, property, length, i;\r
\r
    for (property in object) {\r
        if(!object.hasOwnProperty(property)) {\r
            continue;\r
        }\r
        value = object[property];\r
        if (jasmine.isArray_(value)) {\r
            length = value.length;\r
            for (i = 0; i < length; i++) {\r
                buf.push(property + '=' + e(value[i]));\r
            }\r
        } else {\r
            buf.push(property + '=' + e(value));\r
        }\r
    }\r
    return buf.join('&');\r
};\r
\r
Test.hashString = function (s, hash) {\r
    hash = hash || 0;\r
\r
    // see http://www.cse.yorku.ca/~oz/hash.html\r
    for (var c, i = 0, n = s.length; i < n; ++i) {\r
        c = s.charCodeAt(i);\r
        hash = c + (hash << 6) + (hash << 16) - hash;\r
    }\r
\r
    return hash;\r
};\r
\r
/**\r
 * Takes an encoded URL and and converts it to an object. Example:\r
 * @param {String} string\r
 * @return {Object} A literal with members\r
 */\r
Test.OptionsImpl.prototype.urlDecode = function(string) {\r
    var obj = {},\r
        pairs, d, name, value, pair, i, length;\r
        \r
    if (string != "") {\r
        pairs = string.split('&');\r
        d = decodeURIComponent;\r
        length = pairs.length;\r
        for (i = 0; i < length; i++) {\r
            pair = pairs[i].split('=');\r
            name = d(pair[0]);\r
            value = d(pair[1]);\r
            obj[name] = !obj[name] ? value : [].concat(obj[name]).concat(value);\r
        }\r
    }\r
    function parseStringOrId (str) {\r
        var id = parseInt(str, 10);\r
        if (String(id) !== str) {\r
            id = Test.hashString(str);\r
        }\r
        return id;\r
    }\r
    \r
    if (obj.specs) {\r
        obj.specs = jasmine.isArray_(obj.specs) ? obj.specs : [obj.specs];\r
        length = obj.specs.length;\r
        for (i = 0; i < length; i++) {\r
            obj.specs[i] = parseStringOrId(obj.specs[i]);\r
        }\r
    } else {\r
        obj.specs = [];\r
    }\r
    \r
    if (obj.suites) {\r
        obj.suites = jasmine.isArray_(obj.suites) ? obj.suites : [obj.suites];\r
        length = obj.suites.length;\r
        for (i = 0; i < length; i++) {\r
            obj.suites[i] = parseStringOrId(obj.suites[i]);\r
        }\r
    } else {\r
        obj.suites = [];\r
    }\r
    \r
    return obj;\r
};\r
\r
/**\r
 * Renders option checkbox and label.\r
 * @param {String} name The option name.\r
 * @param {String} labelText The label text.\r
 * @return {HTMLElement} The option HTMLElement\r
 */ \r
Test.OptionsImpl.prototype.renderCheckbox = function(name, labelText) {\r
    var me = this,\r
        checkbox = new jasmine.Dom({\r
            tag: "input",\r
            cls: "option " + name,\r
            type: "checkbox",\r
            onclick: function() {\r
                me.onCheckboxClick.apply(me, arguments);\r
            }\r
        });\r
        \r
    me.optionCheckBoxesEl[name] = checkbox; \r
      \r
    return new jasmine.Dom({\r
        tag: "span",\r
        cls: "show",\r
        children: [checkbox,{\r
            tag: "label",\r
            html: labelText\r
        }]\r
    });\r
};\r
\r
/**\r
 * Checks options checkboxs if needed. \r
 */\r
Test.OptionsImpl.prototype.check = function() {\r
    var property, checkbox;\r
    \r
    for (property in this.options) {\r
        if (!this.options.hasOwnProperty(property)) {\r
            continue;\r
        }\r
        checkbox = this.optionCheckBoxesEl[property];\r
        if (checkbox) {\r
            checkbox.checked = this.options[property];\r
        }\r
    }\r
};\r
\r
/**\r
 * Options checkbox check/uncked handler.\r
 * @param {HTMLElement} el The checkbox HTMLElement\r
 */\r
Test.OptionsImpl.prototype.onCheckboxClick = function(event) {\r
    var el, opt, row, length, i;\r
    event = event || window.event;\r
    el = event.target || event.srcElement;\r
    opt = el.className.split(" ")[1];\r
    if (el.checked) { \r
       this.options[opt] = true;\r
    } else {\r
        delete this.options[opt];\r
    }\r
};\r
\r
/**\r
 * Reloads current page with reporter options.\r
 */\r
Test.OptionsImpl.prototype.reloadWindow = function(reset) {\r
    if (reset) {\r
        this.options.specs = [];\r
        this.options.suites = [];\r
    }\r
\r
    window.location.search = this.urlEncode(this.options);\r
};\r
\r
/**\r
 * Starts autoReload task.\r
 */\r
Test.OptionsImpl.prototype.startAutoReloadTask = function() {\r
    var me = this;\r
    if (me.options.autoReload) {\r
        var interval = setInterval(function() {\r
            if (Test.SandBox.isRunning()) {\r
                clearInterval(interval);\r
            \r
                setTimeout(function() {\r
                    me.reloadWindow();\r
                }, 2000);\r
            }\r
        }, 1500);\r
    }\r
};\r
\r
Test.OptionsImpl.prototype.isChecked = function(o) {\r
    var specs = this.options.specs,\r
        suites = this.options.suites,\r
        id = o.id;\r
\r
    if (o.suite) {\r
        return specs && jasmine.array.indexOf(specs, id) !== -1;\r
    } else {\r
        return suites && jasmine.array.indexOf(suites, id) !== -1;\r
    }\r
\r
    return false;\r
};\r
\r
Test.Options = new Test.OptionsImpl();Test.SandBoxImpl = function(){};\r
\r
Test.SandBoxImpl.prototype.domReady = function(fn) {\r
    if (document.addEventListener) {\r
        window.addEventListener('load', fn, false);\r
    } else {\r
        window.attachEvent('onload', fn, false);\r
    }\r
};  \r
\r
Test.SandBoxImpl.prototype.setup = function(config) {\r
    var me = this;\r
    me.requires = config.requires;  \r
    me.domReady(function() {\r
        me.reporter = new Test.Reporter();\r
        me.createIframe();\r
    });\r
};\r
\r
Test.SandBoxImpl.prototype.createIframe = function() {\r
    var me = this,\r
        iframe,\r
        win,\r
        doc;\r
\r
    me.options = Test.Options.get();\r
\r
\r
    var src = me.options.quirksMode ? 'iframe-quirks.html?loadSpecs=true' : 'iframe.html?loadSpecs=true';\r
    \r
    src += '&compiled=' + !!me.options.compiled;\r
\r
    if (me.options.specsset) {\r
        src += '&specsset=' + me.options.specsset;\r
    }\r
    \r
    iframe = new jasmine.Dom({\r
        tag: "iframe",\r
        cls: "sandboxIframe",\r
        name: "sandbox",\r
        frameBorder: 0,\r
        src: src\r
    });\r
\r
    me.reporter.getIframeContainer().appendChild(iframe);\r
    \r
    win = iframe.contentWindow || window.frames[iframe.name];\r
    doc = iframe.contentDocument || win.document;\r
    this.iframe = iframe;\r
    this.win = win;\r
    this.doc = doc;\r
};\r
\r
Test.SandBoxImpl.prototype.getIframe = function() {\r
    return this.iframe;\r
};\r
\r
Test.SandBoxImpl.prototype.getWin = function() {\r
    return this.win;\r
};\r
\r
Test.SandBoxImpl.prototype.getDoc = function() {\r
    return this.doc;\r
};\r
\r
Test.SandBoxImpl.prototype.getBody = function() {\r
    return this.getDoc().body;\r
};\r
\r
Test.SandBoxImpl.prototype.getHead = function() {\r
    return this.getDoc().getElementsByTagName("head")[0];\r
};\r
\r
Test.SandBoxImpl.prototype.save = function(spec) {\r
    var doc = this.getDoc(),\r
        sb = doc.createElement("div"),\r
        body = this.getBody(),\r
        children = body && body.childNodes || [],\r
        length = children.length,\r
        i = 0,\r
        child,\r
        lwas = this.lengthWas || (this.lengthWas = 0);\r
\r
    if (!this.options || !this.options.disableBodyClean) {\r
        //this.clearComponents();\r
        //this.clearDomElements();\r
    }\r
\r
    if (length != lwas) {\r
        if (!window.headless) {\r
            this.reporter.log(">> Warning the document.body dom element contains childNodes after spec execution !<br/>" +\r
                "Spec : " + jasmine.util.htmlEscape(spec.getFullName()) + ' <a href="?' +\r
                Test.Options.urlEncode({specs: [spec.id], suites:[], disableBodyClean: true}) + '">Load this spec only and disable body autoclean</a><br/>',\r
                "warning");\r
        } else {\r
            this.reporter.log("Warning: " + spec.getFullName() + "doesn't clean properly the document.body.");\r
        }\r
        this.lengthWas = length;\r
    }\r
\r
};\r
\r
Test.SandBoxImpl.prototype.clearDomElements = function() {\r
    var doc = this.getDoc(),\r
        bd = this.getBody(),\r
        children = bd.childNodes,\r
        length = children.length,\r
        i, child;\r
\r
    if (!this.options.disableBodyClean) {\r
        for (i = 0; i < length; i++) {\r
            child = children[i];\r
            if (child) {\r
                bd.removeChild(child);\r
            }\r
        }\r
    }\r
}\r
\r
Test.SandBoxImpl.prototype.clearComponents = function() {\r
    var me = this,\r
        win = me.getWin(),\r
        comps, c, len, i;\r
\r
    if(win.Ext && win.Ext.ComponentManager) {\r
        comps = win.Ext.ComponentManager.all.getArray();\r
        len = comps.length;\r
        for(i=0; i<len; i++) {\r
            c = comps[i];\r
            c.destroy();\r
        }\r
    }\r
};\r
\r
Test.SandBoxImpl.prototype.isRunning = function() {\r
    return !this.getWin().jasmine.getEnv().currentRunner_.queue.isRunning();\r
};\r
\r
Test.SandBoxImpl.prototype.iScope = function(o) {\r
    if (typeof o === "function") {\r
        o = "(" + o.toString() + ")();";\r
    }\r
    return Test.SandBox.getWin().eval(o);\r
};\r
\r
Test.SandBox = new Test.SandBoxImpl();\r
var iScope = Test.SandBox.iScope; /**\r
 * @class Test.CodeHighLighter\r
 * A javascript simple source code higlighter and beautifier (optional).\r
 */\r
Test.CodeHighLighter = function(config) {        \r
    /**\r
     * @cfg {String} source The source string to process.\r
     */\r
    this.source = config.source;\r
    this.lineNumber = config.lineNumber;\r
    this.linesFromJsCoverage = config.linesFromJsCoverage;\r
    \r
    this.beautify = config.beautify || this.lineNumber === undefined;\r
    this.highLightCode = config.highLightCode === false ? false : true;\r
    \r
    this.matchedComments = [];\r
    this.matchedStrings = [];\r
};\r
\r
/**\r
 * Regular expressions.\r
 */\r
Test.CodeHighLighter.prototype.regExps = {\r
    strings: /"([^\\"\n]|\\.)*"|'([^\\'\n]|\\.)*'|"([^\\"\n]|\\\n)*"|'([^\\'\n]|\\\n)*'/gm,\r
    comments: /\/\/.*$|\/\*[\s\S]*?\*\//gm,\r
    operators: /([\+\-\*\/=\?!]{1,3}|[\-\+]{1,2})/g,\r
    numbers: /\b([0-9]+)\b/g,\r
    keywords: [/\b(break)\b/g, /\b(case)\b/g, /\b(catch)\b/g, /\b(continue)\b/g, /\b(default)\b/g,\r
                /\b(delete)\b/g, /\b(do)\b/g, /\b(else)\b/g, /\b(false)\b/g, /\b(for)\b/g, /\b(function)\b/g,\r
                /\b(if)\b/g, /\b(in)\b/g, /\b(instanceof)\b/g, /\b(new)\b/g, /\b(null)\b/g,\r
                /\b(return)\b/g, /\b(switch)\b/g, /\b(this)\b/g, /\b(throw)\b/g, /\b(true)\b/g,\r
                /\b(try)\b/g,/\b(typeof)\b/g, /\b(var)\b/g, /\b(while)\b/g, /\b(with)\b/g],\r
    commasInsideParenthesis: /\(([^\(\)\{\}])+\)/g,\r
    arrayWithOneElement: /\[\n([^,\]]*)\n\]/g,\r
    commaBracket: /,\n\s*\{/g,\r
    multipleWhiteSpaces: /(\s+)/g,\r
    semiColon: /;/g,\r
    comma: /,/g,\r
    openedBrackets: /([\{\[])/g,\r
    closedBrackets: /([\}\]])/g,\r
    emptyObject: /\{\n\s*\n\}/g,\r
    openedBracketsWithNewLine: /[\{\[]$/g,\r
    closedBracketsWithNewLine: /^\s*[\}\]]/g,\r
    unwantedNewLines: /\n([\n,;\)])/g,\r
    newLine: /\n/g,\r
    firstSpaces: /^(\s)+/\r
};\r
\r
/**\r
 * Populates an array of matched objects.\r
 * @param {String} value The match result.\r
 * @param {Number} index The index of the match.\r
 * @param {Array} matchedObjects The array of matches to populate.\r
 * @param {String} css The css to apply to the match.\r
 * @return {Boolean} Returns <tt>true</tt> is the match is inside another.\r
 */\r
Test.CodeHighLighter.prototype.matchObjects = function(value, index, matchedObjects, css) {\r
    matchedObjects.push({\r
        origValue: value,\r
        value: '<span class="jsHl'+ css +'">' + jasmine.util.htmlEscape(value).replace("$","$\b") + '</span>',\r
        start: index,\r
        end: index + value.length\r
    });\r
};\r
\r
/**\r
 * Checks if a match is inside another matches.\r
 * @param {Object} matchedObject The checked match.\r
 * @param {Array} matchedOthers The array that contains other matches.\r
 * @return {Boolean} Returns <tt>true</tt> is the match is inside another.\r
 */\r
Test.CodeHighLighter.prototype.isInside = function(matchedObject, matchedOthers) {\r
    var start = matchedObject.start,\r
        end = matchedObject.end,\r
        length = matchedOthers.length,\r
        matchedOther, i;\r
\r
    for (i = 0; i < length; i++) {\r
        matchedOther = matchedOthers[i];\r
        if (matchedOther.start < start && start < matchedOther.end) {\r
            return true;\r
        } \r
    }\r
    return false;\r
};\r
\r
/**\r
 * This function get rid of any matches that are inside of other matches.\r
 * If a match isn't inside another it is replaced by a string in {@link #source}\r
 * in order to protect it from {@link #processOperatorsNumbersKeywords} replace tricks.\r
 * @param {Array} matchedObjects The array of matches to check.\r
 * @param {Array} matchedOthers The array that contains other matches.\r
 * @param {String} protect The replacement string\r
 */\r
Test.CodeHighLighter.prototype.fixOverlaps = function(matchedObjects, matchedOthers, protect) {\r
    var result = [],\r
        length = matchedObjects.length,\r
        matchedObject,\r
        i;\r
        \r
    for (i = 0; i < length; i++) {\r
        matchedObject = matchedObjects[i];\r
        if (!this.isInside(matchedObject, matchedOthers)) {\r
            this.source = this.source.replace(matchedObject.origValue, protect);\r
            result.push(matchedObject);\r
        }\r
    }\r
    return result;\r
};\r
\r
/**\r
 * Replaces Strings and Comments in javascript source code.\r
 */\r
Test.CodeHighLighter.prototype.saveStringsAndComments = function() {\r
    var commentsRe = this.regExps.comments,\r
        stringsRe = this.regExps.strings,\r
        exec;\r
        \r
    \r
    while((exec = commentsRe.exec(this.source))) {\r
        this.matchObjects(exec[0], exec.index, this.matchedComments, "Comment");\r
    }\r
    \r
    while((exec = stringsRe.exec(this.source))) {\r
        this.matchObjects(exec[0], exec.index, this.matchedStrings, "String");\r
    }\r
\r
    this.matchedComments = this.fixOverlaps(this.matchedComments, this.matchedStrings, "%%%%comment%%%%");\r
    this.matchedStrings = this.fixOverlaps(this.matchedStrings, this.matchedComments, '%%%%string%%%%');\r
};\r
\r
/**\r
 * Process strings and comments saved by {@link #saveStringsAndComments}.\r
 */\r
Test.CodeHighLighter.prototype.processStringsAndComments = function() {\r
    var matches = this.matchedComments,\r
        length = matches ? matches.length : 0,\r
        value, i;\r
\r
    for (i = 0; i < length; i++) {\r
        value = matches[i].value;\r
        this.source = this.source.replace("%%%%comment%%%%", value);\r
    }\r
    \r
    matches = this.matchedStrings;\r
    length = matches ? matches.length : 0;\r
    \r
    for (i = 0; i < length; i++) {\r
        value = matches[i].value;\r
        this.source = this.source.replace('%%%%string%%%%', value);\r
    }\r
};\r
\r
/**\r
 * Highlight operators, numbers and keywords.\r
 */\r
Test.CodeHighLighter.prototype.processOperatorsNumbersKeywords = function() {\r
   var regexps = this.regExps,\r
        keywords = regexps.keywords,\r
        length = keywords.length,\r
        i;\r
        \r
    this.source = jasmine.util.htmlEscape(this.source).replace(\r
        regexps.operators, '<span class="jsHlOperator">$1</span>').replace(\r
        regexps.numbers, '<span class="jsHlNumber">$1</span>');\r
            \r
    for (i = 0; i < length; i++) {\r
        this.source = this.source.replace(keywords[i], '<span class="jsHlKeyword">$1</span>');\r
    }\r
};\r
    \r
/**\r
 * Format and highligth javascript sources.\r
 * @return The HTML formatted and highlighted code\r
 */\r
Test.CodeHighLighter.prototype.process = function() {\r
    this.saveStringsAndComments();\r
    \r
    if (this.beautify) {\r
        this.prepareIndent();\r
        this.doIndent();\r
    }\r
    \r
    this.processOperatorsNumbersKeywords();\r
\r
    this.processStringsAndComments();\r
\r
    return this.source;\r
};\r
\r
/**\r
 * Render sources with line numbers.\r
 * @return The HTML formatted and highlighted code\r
 */\r
Test.CodeHighLighter.prototype.renderJsSources = function() {\r
    var result = 'No code found.',\r
        linesFromJsCoverage = this.linesFromJsCoverage,\r
        lineNumber = this.lineNumber,\r
        source = this.source,\r
        lines, line, i, errorCls, length, lineNumberCls;\r
\r
    if (source) {\r
        source = this.highLightCode ? this.process() : source;\r
        lines = source.split("\n");\r
        length = lines.length;\r
     \r
        result = '<table border="0" cellpadding="0" cellspacing="0"><tbody><tr><td class="lineNumbers">';\r
        for (i = 0; i < length; i++) {\r
            errorCls = "";\r
            lineNumberCls = "";\r
            if (lineNumber) {\r
                errorCls = i === (lineNumber - 1) ? " error" : "";\r
            }\r
            if (linesFromJsCoverage) {\r
                lineNumberCls = !isNaN(linesFromJsCoverage[i + 1]) ? " lineNumberGreen" : "";\r
                lineNumberCls = linesFromJsCoverage[i + 1] === 0 ? " lineNumberRed" : lineNumberCls;\r
\r
            }\r
            result += '<div class="lineNumber' + errorCls + lineNumberCls + '">' + (i + 1) +'</div>';\r
        }\r
\r
        result += '</td><td><pre class="code">'+ source +'</pre></td></tr></tbody></table>';\r
    }\r
    \r
    this.source = result;\r
\r
    return this.source;\r
};\r
\r
/**\r
 * Prepares source code. It crops double whitespace and append new lines.\r
 * This function is used generally to preformat the code that come from a \r
 * Function.prototype.toString.\r
 */\r
Test.CodeHighLighter.prototype.prepareIndent = function() {\r
    var regexps = this.regExps,\r
        matches, length, i, m;\r
        \r
    this.source = this.source.replace(\r
                regexps.multipleWhiteSpaces, " ").replace(\r
                regexps.semiColon, ";\n").replace(\r
                regexps.comma, ",\n").replace(\r
                regexps.openedBrackets, "$1\n").replace(\r
                regexps.closedBrackets, "\n$1\n");\r
\r
    \r
    // remove newline after commas inside code parenthesis\r
    matches = this.source.match(regexps.commasInsideParenthesis);\r
\r
    length = matches ? matches.length : 0;\r
    for (i = 0; i < length; i++) {\r
        m = matches[i];\r
        this.source = this.source.replace(m, m.replace(regexps.newLine, ""));\r
    }\r
    \r
    // fixes various bad formatting\r
    this.source = this.source.replace(regexps.arrayWithOneElement, "[$1]").replace(\r
        regexps.emptyObject, "{}").replace(\r
        regexps.commaBracket, ", {").replace(\r
        regexps.unwantedNewLines, "$1");\r
};\r
\r
/**\r
 * Creates a string composed of n whitespaces\r
 * @param {Number} number The number of white spaces.\r
 * @return {String} A multiple whitespace string.\r
 */\r
Test.CodeHighLighter.prototype.addWhiteSpaces = function (number) {\r
    var whiteSpaces = "",\r
        i;\r
        \r
    for (i = 0; i < number; i++) {\r
        whiteSpaces += " ";\r
    }\r
\r
    return whiteSpaces;\r
};\r
\r
/**\r
 * Indents pre-formatted source code.\r
 */\r
Test.CodeHighLighter.prototype.doIndent = function() {\r
    var regexps = this.regExps, \r
        results = [],\r
        indent = 0,\r
        sources = this.source.split("\n"),\r
        length = sources.length,\r
        whiteSpaces = "",\r
        source, i;\r
\r
    for (i = 0; i < length; i++) {\r
        source = sources[i].replace(regexps.firstSpaces, '');\r
        if (source !== "") {\r
            if (source.search(regexps.closedBracketsWithNewLine) !== -1) {\r
                indent = Math.max(indent - 4, 0);\r
                whiteSpaces = this.addWhiteSpaces(indent);\r
            }\r
            results.push(whiteSpaces + source);\r
            if (source.search(regexps.openedBracketsWithNewLine) !== -1) {\r
                indent += 4;\r
                whiteSpaces = this.addWhiteSpaces(indent);\r
            }\r
        }\r
    }\r
    this.source = results.join("\n");\r
};\r
/**\r
 * Init allowedGlobals array.\r
 */\r
Test.BadGlobalsImpl = function(reporter) {\r
    this.results = [];\r
};\r
\r
Test.BadGlobalsImpl.prototype.setup = function() {\r
    var me = this, \r
        win = Test.SandBox.getWin(),\r
        property;\r
        \r
    // whitelist support    \r
    win.addGlobal = function() {\r
        me.addGlobal.apply(me, arguments);\r
    };\r
    \r
    me.allowedGlobals = {};\r
    for (property in win) {\r
        me.allowedGlobals[property] = true;\r
    }\r
    // add firebug globals variables to white list\r
    me.allowedGlobals._firebug = true;\r
    me.allowedGlobals._createFirebugConsole = true;\r
    me.allowedGlobals.loadFirebugConsole = true;\r
    me.allowedGlobals.console = true;\r
};\r
\r
\r
/**\r
 * Append to suite HTMLElement warning messages if improper global variables are found.\r
 * @param {HTMLElement} suiteEl The suite HTMLElement.\r
 */\r
Test.BadGlobalsImpl.prototype.report = function(info, suite) {\r
    var allowedGlobals = this.allowedGlobals,\r
        win = Test.SandBox.getWin(),\r
        property, message, value;\r
    \r
    for (property in win) {\r
        if (!allowedGlobals[property]) {\r
            value = jasmine.pp(win[property]);\r
            message = ">> Bad global variable found in " + (suite ? suite.description : "global scope") + "<br/>" + property + " = " + value;\r
            info.log(message, "warning");        \r
            this.results[property] = {\r
                where: (suite ? ('in suite' + suite.description) : "global scope"),\r
                value: value\r
            };\r
            allowedGlobals[property] = true;\r
        }\r
    }    \r
};\r
\r
Test.BadGlobalsImpl.prototype.addGlobal = function(property) {\r
    this.allowedGlobals[property] = true;\r
};\r
\r
if (!jasmine.browser.isIE && !jasmine.browser.isOpera) {\r
    Test.BadGlobals = new Test.BadGlobalsImpl();\r
}/**\r
 * @singleton Test.jsCoverage\r
 * The jscoverage manager.\r
 */\r
Test.jsCoverage = {\r
    executed: 0,\r
    coverage: {},\r
\r
    isEnabled: function() {\r
        return !!Test.SandBox.getWin()._$jscoverage;\r
    },\r
\r
    getCoverage: function() {\r
        return this.coverage;\r
    },\r
    \r
    getSandBoxCoverage: function() {\r
        return Test.SandBox.getWin()._$jscoverage;\r
    },\r
/**\r
 * Adds suite to the jscoverage manager.\r
 * @param {jasmine.Suite} The jasmine suite.\r
 */\r
    add: function(suite) {\r
        var coverage = this.getSandBoxCoverage(),\r
        filename, file, property, statement;\r
        \r
        if (!coverage) {\r
            return;\r
        }\r
        filename = this.getFileName(suite.coverageFile);\r
        file = coverage[filename];\r
        if (coverage && file) {\r
            for (property in file) {\r
                if (!file.hasOwnProperty(property)) {\r
                   continue;\r
                }\r
                statement = file[property];\r
            }\r
        }  \r
    },\r
/**\r
 * This methods try to find the corresponding javascript source file.\r
 * @param {String} The filename.\r
 */\r
    getFileName: function(filename) {\r
        var coverage = this.getSandBoxCoverage(), \r
        property;\r
        \r
        if (!coverage || !filename) {\r
            return;\r
        }\r
        \r
        if (coverage[filename]) {\r
            return filename;\r
        }\r
        \r
        for (property in coverage) {\r
            if (property.search(filename) !== -1) {\r
                return property;\r
            }\r
        }\r
    },\r
/**\r
 * Updates suite coverage results after execution.\r
 * @param {jasmine.Suite} The jasmine suite.\r
 */\r
    update: function(suite) {\r
        var coverage = this.getSandBoxCoverage(),\r
            statements = 0,\r
            executed = 0,\r
            property, statement, filename, file;\r
            \r
        if (!coverage) {\r
            return;\r
        }\r
        \r
        filename = this.getFileName(suite.coverageFile);\r
        file = coverage[filename];\r
        \r
        if (file) {\r
            suite.jscoverage = {\r
                file: []\r
            };\r
            \r
            for (property in file) {\r
                if (!file.hasOwnProperty(property)) {\r
                   continue;\r
                }\r
                statement = file[property];\r
                \r
                suite.jscoverage.file[property] = statement;\r
                \r
                if (!isNaN(property) && statement !== undefined) {\r
                    statements = statements + 1;\r
                    if (statement !== 0) {\r
                        this.executed = this.executed + 1;\r
                        executed = executed + 1;\r
                    }\r
                }\r
            }\r
            suite.jscoverage.percentage = ((executed/statements) * 100).toFixed(2);\r
            suite.jscoverage.statements = statements;\r
            suite.jscoverage.executed = executed;\r
            this.coverage[filename] = suite.jscoverage.file;\r
            this.coverage[filename].percentage = suite.jscoverage.percentage;\r
            this.coverage[filename].statements = suite.jscoverage.statements;\r
            this.coverage[filename].executed = suite.jscoverage.executed;\r
        }\r
    },\r
/**\r
 * Returns suite coverage text.\r
 * @param {jasmine.Suite} The jasmine suite.\r
 * @return {String} The Code coverage text<\r
 */\r
   getSuiteCoverage: function(suite) {\r
	    if (suite.jscoverage) {\r
        	return " - Code coverage: " + suite.jscoverage.percentage + "%";\r
		}\r
		return '';\r
   },\r
/**\r
 * Gets total code coverage.\r
 * @return {String} A string with total code coverage.\r
 */\r
    getTotal: function() {\r
        if (this.percentage) {\r
            return " - Code coverage: " + this.percentage + "%";\r
        }\r
        \r
        return '';\r
    },\r
\r
    updateTotal: function() {\r
        var coverage = this.getSandBoxCoverage(),\r
            statements = 0,\r
            file, filename, statement, property, fstatements, fexecuted, create;\r
        \r
        if(!coverage) {\r
            return "";\r
        }\r
        \r
        for (filename in coverage) {\r
            if (!coverage.hasOwnProperty(filename)) {\r
               continue;\r
            }\r
            file = coverage[filename];\r
            fstatements = 0;\r
            fexecuted = 0;\r
            \r
            create = !this.coverage[filename];\r
            if (create) {\r
                this.coverage[filename] = [];\r
            }\r
            for (property in file) {\r
                if (!file.hasOwnProperty(property)) {\r
                   continue;\r
                }\r
                statement = file[property];\r
  \r
                if (!isNaN(property)) {\r
                    if (statement !== undefined) {\r
                        statements = statements + 1;\r
                        fstatements = fstatements + 1;\r
                    }\r
                    if (create) {\r
                        this.coverage[filename][property] = 0;\r
                    }\r
                }\r
            }\r
            \r
            if (create) {\r
                this.coverage[filename].source = file.source;\r
                this.coverage[filename].statements = fstatements;\r
                this.coverage[filename].executed = fexecuted;\r
                this.coverage[filename].percentage = ((fexecuted/fstatements) * 100).toFixed(2);\r
            } \r
\r
        }\r
        this.statements = statements;\r
        this.percentage = ((this.executed/statements) * 100).toFixed(2);\r
    }\r
    \r
};Test.panel = {};\r
/**\r
 * Renders Jasmine Blocks executed by spec.\r
 * @param {Jasmine.spec} spec The spec.\r
 * @param {HTMLElement} panelsEl The HTMLElement which encapsulate the tools panels.\r
 */\r
Test.panel.Blocks = function(config) {\r
    var blocks = config.spec.queue.blocks,\r
        length = blocks.length,\r
        cls = "panel blocks",\r
        children = [],\r
        i, block, codeHighLighter;\r
\r
    for (i = 0; i < length; i++) {\r
        block = blocks[i];\r
        if (block.func) {\r
            children.push({\r
                cls: "blockTitle " + (block.func.typeName || "specSources"),\r
                html: block.func.typeName || 'it("' + jasmine.util.htmlEscape(config.spec.description) + '")'\r
            });\r
\r
            codeHighLighter = new Test.CodeHighLighter({\r
                source: block.func.toString()\r
            });\r
\r
            children.push({\r
                cls: "sources",\r
                html: codeHighLighter.renderJsSources()\r
            });\r
        }\r
    }\r
    \r
    this.el = new jasmine.Dom({\r
        cls: cls, \r
        children: children\r
    });\r
\r
    return this;\r
};\r
\r
Test.panel.Blocks.prototype.remove = function() {\r
    this.el.parentNode.removeChild(this.el);\r
};/**\r
 * Renders spec dom sandbox tool.\r
 * @param {Jasmine.spec} spec The spec.\r
 * @param {HTMLElement} panelsEl The HTMLElement which encapsulate the tools panels.\r
 */\r
Test.panel.Sandbox = function(config) {\r
    this.persist = true;\r
\r
    this.render();\r
\r
    return this;\r
};\r
\r
/**\r
 * Renders spec dom sandbox innerHTML.\r
 * @return {HTMElement} The formatted dom sandbox innerHTML.\r
 */\r
Test.panel.Sandbox.prototype.render = function() {\r
    this.el = new jasmine.Dom({\r
        cls: "panel sandbox hideMe"\r
    });\r
};/**\r
 * Renders infos panel.\r
 */\r
Test.panel.Infos = function() {\r
    this.el = new jasmine.Dom({\r
                tag: "div",\r
                cls: "panel infos",\r
                children: [{\r
                    cls: "logs"\r
                }]\r
    });\r
    this.logs = this.el.childNodes[0];\r
    this.persist = true;\r
    return this;\r
};\r
\r
/**\r
 * Print a message into console.\r
 * @param {String} message The message.\r
 * @param {String} cls (optional) an extra cls to add to the message.\r
 */\r
Test.panel.Infos.prototype.log = function(message, cls) {\r
    var log = this.logs.appendChild(new jasmine.Dom({\r
        cls: "infoMessage",\r
        html: message\r
    }));\r
    \r
    if (cls) {\r
        jasmine.Dom.addCls(log, cls);\r
    }\r
};/**\r
 * @class jasmine.panel.jsCoverage\r
 * Creates and renders a per spec jscoverage panel.\r
 * @param {Object} config The configuration object.\r
 */\r
Test.panel.jsCoverage = function(config) {\r
    this.el = new jasmine.Dom({\r
        tag: "div",\r
        cls: "panel jsCoverage",\r
        children: [{\r
            cls: "sources",\r
            html: new Test.CodeHighLighter({\r
                        source: config.suite.jscoverage.file.source.join("\n"),\r
                        linesFromJsCoverage: config.suite.jscoverage.file,\r
                        highLightCode: false\r
                    }).renderJsSources()\r
        }]\r
    });\r
    return this; \r
};\r
\r
Test.panel.jsCoverage.prototype.remove = function() {\r
    this.el.parentNode.removeChild(this.el);\r
};/**\r
 * @class jasmine.panel.jsCoverageSummary\r
 * Creates and renders the persistant jscoverage summary panel.\r
 * @param {Object} config The configuration object.\r
 */\r
Test.panel.jsCoverageSummary = function(config) {\r
    var me = this;\r
    \r
    me.el = new jasmine.Dom({\r
        tag: "div",\r
        cls: "panel jsCoverageSummary hideMe",\r
        onclick: function() {\r
            me.onClick.apply(me, arguments);\r
        },\r
        children: [{\r
            cls: "sbody"\r
        }]\r
    });\r
    \r
    me.body = me.el.childNodes[0];\r
    me.persist = true;\r
    this.renderSummary();\r
    return me; \r
};\r
\r
/**\r
 * Renders summary view.\r
 */\r
Test.panel.jsCoverageSummary.prototype.renderSummary = function() {\r
    var coverage = Test.jsCoverage.getCoverage(),\r
        filename, result;\r
        \r
    if (!this.summary) {\r
        result = '<table class="summary" border="0" cellpadding="0" cellspacing="0"><tbody>';\r
        result += '<tr class="line header"><td class="fileName">File</td><td class="statements">Statements</td><td class="executed">Executed</td><td class="percentage">Percentage</td></tr>';    \r
        result += '<tr class="line total">';\r
        result += '<td class="fileName">Total</td>';\r
        result += '<td class="statements">' + Test.jsCoverage.statements + "</td>";\r
        result += '<td class="executed">' + Test.jsCoverage.executed + "</td>";\r
        result += '<td class="percentage">' + this.renderPercentage(Test.jsCoverage.percentage) + "</td>";\r
        result += '</tr>';\r
        \r
        for (filename in coverage) {\r
            if (!coverage.hasOwnProperty(filename)) {\r
                continue;\r
            }\r
            result += '<tr class="line">';\r
            result += '<td class="fileName"><a>' + filename + "</a></td>";\r
            result += '<td class="statements">' + coverage[filename].statements + "</td>";\r
            result += '<td class="executed">' + coverage[filename].executed + "</td>";\r
            result += '<td class="percentage">' + this.renderPercentage(coverage[filename].percentage) + "</td>";\r
            result += '</tr>';\r
        }\r
        result += '</tbody></table>';\r
        this.summary = result;\r
    }\r
    this.body.innerHTML = this.summary;\r
};\r
\r
/**\r
 * Renders percentage progress bar.\r
 * @return {String} The progressbar html.\r
 */\r
Test.panel.jsCoverageSummary.prototype.renderPercentage = function(percent) {\r
    var result = percent + '%<div class="limit" style="width:300px;">';\r
        result += '<div class="result" style="width:' + 3 * percent + 'px;"></div>';\r
    \r
        result += '</div>';\r
    return result;\r
};\r
\r
/**\r
 * Renders percentage progress bar.\r
 * @return {String} The progressbar html.\r
 */\r
Test.panel.jsCoverageSummary.prototype.onClick = function(event) {\r
    var el;\r
        event = event || window.event;\r
        el = event.target || event.srcElement;\r
\r
    if (el.tagName === "A") {\r
        this.renderSource(Test.jsCoverage.getCoverage()[el.innerHTML]);\r
    }\r
    \r
    if (jasmine.Dom.hasCls(el,"back")) {\r
        this.renderSummary();\r
    }\r
};\r
\r
/**\r
 * Renders file source.\r
 */\r
Test.panel.jsCoverageSummary.prototype.renderSource = function(coverage) {\r
    this.body.innerHTML = "";\r
    this.body.appendChild(new jasmine.Dom({\r
        cls: "back",\r
        html: "Back"\r
    }));\r
    \r
    this.body.appendChild(new jasmine.Dom({\r
            cls: "sources",\r
            html: new Test.CodeHighLighter({\r
                        source: coverage.source.join("\n"),\r
                        linesFromJsCoverage: coverage,\r
                        highLightCode: false\r
                    }).renderJsSources()\r
    }));\r
};/**\r
 * Renders stack trace tool.\r
 * @param {Jasmine.spec} The jasmine spec.\r
 * @return {HTMLElement} The created HTMLElement.\r
 */\r
Test.panel.StackTrace = function(config) {\r
    this.spec = config.spec;\r
    this.badLinesEls = [];\r
    \r
    var resultItems = this.spec.results().getItems(),\r
        length = resultItems.length,\r
        result,\r
        error,\r
        lines,\r
        i;\r
\r
    if (jasmine.browser.isIE || !this.spec.hasError) {\r
        return this;\r
    }\r
    \r
    for (i = 0; i < length; i++) {\r
        result = resultItems[i];\r
        if (result.type == "expect" && result.passed && !result.passed()) {\r
            if (result.error) {\r
                error = result.error;\r
                break;\r
            }\r
        }\r
    }   \r
    \r
    if (error) {\r
        lines = this.extractStackTrace(error);\r
\r
        this.el = new jasmine.Dom({\r
                tag: "div",\r
                cls: "panel stackTrace",\r
                children: this.renderStackLines(lines)\r
        });\r
    }\r
\r
    return this;\r
};\r
\r
/**\r
 * Extracts error stack trace.\r
 * @param {Error} e The javascript error object.\r
 * @return {Array} An array which contains all stack trace files and lineNumbers.\r
 */\r
Test.panel.StackTrace.prototype.extractStackTrace = function(error) {\r
    var stack = error.stack || error.stackTrace,\r
        results = [],\r
        lines, line, length, i, extract, file, lineNumber;\r
    \r
    if (stack) {\r
        lines = stack.split("\n");\r
        length = lines.length;\r
        for(i = 0; i < length; i++) {\r
            line = lines[i];\r
            if (line.search("jasmine.js") === -1) {\r
                extract = this.extractFileAndLine(line);\r
                if (extract) {\r
                    results.push(extract);\r
                }\r
            }\r
        }\r
    } else {\r
        file = error.sourceURL || error.fileName;  \r
        lineNumber = error.line || error.lineNumber;\r
\r
        if (file && lineNumber) {\r
            results.push({\r
                file: file,\r
                lineNumber: lineNumber\r
            });\r
        }\r
    }\r
    return results;\r
};\r
\r
/**\r
 * Extracts filename and line number from a stack trace line.\r
 * @param {String} line The stack trace line.\r
 * @return {Object} An object containing the filename and the line number or null.\r
 */\r
Test.panel.StackTrace.prototype.extractRe = /((http:\/\/|file:\/\/\/).*\.js)[^:]*:(\d*)/;\r
Test.panel.StackTrace.prototype.extractFileAndLine = function(line) {\r
    var result = line.match(this.extractRe);\r
\r
    if (!result) {\r
        return null;\r
    }\r
\r
    return {\r
        file: result[1],\r
        lineNumber: result[3]\r
    }; \r
};\r
\r
/**\r
 * Render stack trace lines.\r
 * @param {String} file The filename.\r
 * @param {String/Number} lineNumber The line number.\r
 * @return {Array} An array containing all strace trace HTMLElements.\r
 */\r
Test.panel.StackTrace.prototype.renderStackLines = function(lines) {\r
    var els = [],\r
        length = lines.length,\r
        el, line, i, file, lineNumber;\r
\r
    for (i = 0; i < length; i++) {\r
        line = lines[i];\r
        file = line.file;\r
        lineNumber = parseInt(line.lineNumber, 0);\r
        el = new jasmine.Dom({\r
            cls: "stackTraceLine",\r
            children: [{\r
                cls: "fileName",\r
                html: "File: "+ file + " (line " + lineNumber + ")"\r
            },{\r
                cls: "sources",\r
                html: this.renderTraceFileSource(file, lineNumber) \r
            }]\r
        });\r
        \r
        this.badLinesEls.push({\r
            el: el.childNodes[1],\r
            line: lineNumber\r
        });\r
        els.push(el);\r
    }\r
    \r
    return els;\r
};\r
\r
/**\r
 * Downloads source file.\r
 * @param {String} url The filename url.\r
 * @return {String} The file source or null.\r
 */\r
Test.panel.StackTrace.prototype.getFile = function(file) {\r
    var request;\r
\r
    if (jasmine.browser.isIE || Test.Options.remote) {\r
        return null;\r
    }\r
    this.downloadedFiles = this.downloadedFiles || {};\r
\r
    if (!this.downloadedFiles[file]) {\r
        request = new XMLHttpRequest();\r
        \r
        if (!request) {\r
            return null;\r
        }\r
        request.open("GET", file + "?" + (new Date()).getTime(), false);\r
\r
        request.send("");\r
\r
        this.downloadedFiles[file] = request.responseText;        \r
    }\r
    \r
    return this.downloadedFiles[file];\r
};\r
\r
/**\r
 * Renders stack trace source file.\r
 * @param {String} file The filename.\r
 * @param {String/Number} lineNumber The line number.\r
 * @return {HTMLElement} The javascript source file HTMLElement.\r
 */\r
Test.panel.StackTrace.prototype.jscoverageFileRe = /(http:\/\/|file:\/\/\/)[^\/]*/;\r
\r
Test.panel.StackTrace.prototype.renderTraceFileSource = function (file, lineNumber) {\r
    var highLightCode = true,\r
        source, instrumented_file, i, length, line;\r
\r
    if (Test.SandBox.getWin()._$jscoverage) {\r
        instrumented_file = SandBox.getWin()._$jscoverage[file.replace(this.jscoverageFileRe, "")];\r
        if (instrumented_file) {\r
            highLightCode = false;\r
            source = instrumented_file.source.join("\n");\r
            linesFromJsCoverage = {};\r
            length = instrumented_file.length;\r
            for (i = 0; i < length; i++) {\r
                line = instrumented_file[i];\r
                if (line === 0) {\r
                    linesFromJsCoverage[i-1] = true;\r
                }\r
            }\r
        }\r
    }\r
    source = source || this.getFile(file);\r
    \r
    return new Test.CodeHighLighter({\r
        source: source,\r
        highLightCode: highLightCode,\r
        lineNumber: lineNumber\r
    }).renderJsSources();\r
};\r
\r
/**\r
 * Ensure that line which contains the error is visible without scroll.\r
 */\r
Test.panel.StackTrace.prototype.afterRender = function() {\r
    var length = this.badLinesEls.length,\r
        badLine, firstChild, el, i, lineHeigth, visiblesLines;\r
\r
    for (i = 0; i < length; i++) {\r
        badLine = this.badLinesEls[i];\r
        el = badLine.el;\r
        lineHeigth = 16;\r
        visiblesLines = el.clientHeight/lineHeigth;\r
        el.scrollTop = Math.max(badLine.line - visiblesLines/2, 0) * lineHeigth;\r
    }\r
    \r
    this.badLinesEls = [];\r
};\r
\r
Test.panel.StackTrace.prototype.remove = function() {\r
    this.el.parentNode.removeChild(this.el);\r
};/**\r
 * @class Test.panel.TabPanel\r
 * Renders inspection tools htmlElement.\r
 * @param {Object} config The configuration object.\r
 */\r
Test.panel.TabPanel = function(config) {\r
    var me = this;  \r
    \r
    me.options = Test.Options.get();\r
    \r
    me.spec = config.spec;\r
    me.container = config.container;\r
    me.el = new jasmine.Dom({\r
        cls: "tabpanel",\r
        onclick: function() {\r
            me.onTabPanelClick.apply(me, arguments);\r
        },\r
        children: [{\r
            cls: "toolBar"\r
        },{\r
            cls: "panels"\r
        }]\r
    });\r
        \r
    me.toolbar = me.el.childNodes[0];\r
    me.body = me.el.childNodes[1];\r
\r
    me.children = [];\r
    me.tabs = [];\r
    \r
    \r
    me.container.appendChild(me.el);\r
    me.renderToolBar();\r
    me.add(new Test.panel.Infos({}));\r
    me.add(new Test.panel.Sandbox({}));\r
    \r
    if (me.options.panel) {\r
        me.activatePanel(me.options.panel);\r
    }\r
    \r
    return me;\r
};\r
\r
/**\r
 * Adds a panel.\r
 * @param {Object} panel the panel to be added to this tabPanel.\r
 */\r
Test.panel.TabPanel.prototype.add = function(panel) {\r
    if (panel.el) {\r
        this.body.appendChild(panel.el);\r
    }\r
    if (panel.afterRender) {\r
        panel.afterRender();\r
    }\r
    this.children.push(panel);\r
    \r
    if (panel.afterRender) {\r
        panel.afterRender();\r
    }\r
};\r
\r
/**\r
 * Adds a tab\r
 * @param {Object} panel the panel to be added to this tabPanel.\r
 */\r
Test.panel.TabPanel.prototype.addTab = function(cls, name, persist) {\r
    var el = this.toolbar.appendChild(new jasmine.Dom({\r
        tag: "span",\r
        cls: "toolbarTab " + cls,\r
        html: name\r
    }));\r
    \r
    this.tabs.push({\r
        el: el, \r
        persist: persist\r
    });\r
};\r
\r
/**\r
 * Activate a tool panel and render it if needed.\r
 * @param {String} cls The panel className.\r
 */\r
Test.panel.TabPanel.prototype.activatePanel = function(cls) {\r
    var children = this.children,\r
        length = children.length,\r
        rendered = false,\r
        child, i;\r
        \r
    for(i = 0; i < length; i++) {\r
        child = children[i].el;\r
        jasmine.Dom.addCls(child, "hideMe"); \r
        if (jasmine.Dom.hasCls(child, cls)) {\r
            jasmine.Dom.removeCls(child, "hideMe");\r
            if (children[i].persist && cls !== "jsCoverageSummary") {\r
                this.options.panel = cls;\r
            } else {\r
                delete this.options.panel;\r
            }\r
            rendered = true;\r
        }\r
    }\r
\r
    if (rendered) {\r
        return;\r
    }\r
    \r
    if (this.spec) {\r
        if (cls === "blocks") {\r
            this.add(new Test.panel.Blocks({\r
                spec: this.spec\r
            }));\r
        }\r
\r
        if (cls === "stackTrace") {\r
            this.add(new Test.panel.StackTrace({\r
                spec: this.spec\r
            })); \r
        }\r
    }\r
    \r
    if (this.suite && this.suite.jscoverage) {\r
        if (cls === "jsCoverage") {\r
            this.add(new Test.panel.jsCoverage({\r
                suite: this.suite\r
            })); \r
        }        \r
    }\r
};\r
\r
/**\r
 * Reporter HTMLElement click dispatcher.\r
 * @param {Event} event The event\r
 */\r
Test.panel.TabPanel.prototype.onTabPanelClick = function(event) {\r
    var el;\r
        event = event || window.event;\r
        el = event.target || event.srcElement;\r
\r
    if (jasmine.Dom.hasCls(el, "toolbarTab")) {\r
        this.onTabClick(el);\r
    }\r
};\r
\r
/**\r
 * Handle spec tools tab click.\r
 * @param {HTMLElement} el The tab HTMLElement.\r
 */\r
Test.panel.TabPanel.prototype.onTabClick = function(el) {\r
    var tools, panels, length, child, i;\r
    \r
    jasmine.Dom.addCls(el, "selected");\r
\r
    tools = this.toolbar.childNodes;\r
    panels = this.body.childNodes;\r
\r
    length = tools.length;\r
    for(i = 0; i < length; i++) {\r
        child = tools[i];\r
        if (child != el) {    \r
            jasmine.Dom.removeCls(child, "selected");\r
        }\r
    }\r
    this.activatePanel(el.className.split(" ")[1]);\r
};\r
\r
\r
/**\r
 * Renders inspection tabpanel toolbar which contain tabs.\r
 * @param {jasmine.Spec} spec The jasmine spec.\r
 * @param {HTMLElement} toolBarEl The toolbar HTMLElement\r
 */\r
Test.panel.TabPanel.prototype.renderToolBar = function() {\r
    var spec = this.spec,\r
        suite = this.suite,\r
        toolbar = this.toolbar;\r
        \r
    if (this.tabs.length === 0) {\r
        this.addTab("infos selected", "Console", true);\r
        this.addTab("sandbox", "Iframe", true);\r
    } else {\r
        jasmine.Dom.addCls(this.tabs[0].el, "selected");\r
    }\r
    \r
    if (spec) {\r
        this.addTab("blocks", "Blocks");\r
        \r
        if (!jasmine.browser.isIE && !jasmine.browser.isOpera && this.spec.hasError) {\r
            this.addTab("stackTrace", "Stack Trace");\r
        }\r
    }\r
    \r
    if (suite && suite.jscoverage) {\r
        this.addTab("jsCoverage", "Suite Coverage");      \r
    }\r
};\r
\r
/**\r
 * Removes all non-persistant tabs.\r
 */\r
Test.panel.TabPanel.prototype.resetToolBar = function() {\r
    var children = this.tabs,\r
        length = children.length, \r
        child, i;\r
\r
    for (i = length - 1; i >= 0; i--) {\r
        child = children[i];\r
        if (!child.persist) {\r
            this.toolbar.removeChild(child.el);\r
            jasmine.array.remove(children, child);\r
        }\r
        jasmine.Dom.removeCls(child.el, "selected");\r
    }\r
    \r
    this.renderToolBar();\r
};\r
\r
/**\r
 * Removes all non-persistant panels.\r
 */\r
Test.panel.TabPanel.prototype.resetPanels = function() {\r
    var children = this.children,\r
        length = children.length, \r
        child, i;\r
\r
    for (i = length - 1; i >= 0; i--) {\r
        child = children[i];\r
        if (!child.persist) {\r
            child.remove();\r
            jasmine.array.remove(children, child);\r
        }\r
        jasmine.Dom.addCls(child.el, "hideMe");\r
    }\r
    \r
    if (children[0]) {\r
        jasmine.Dom.removeCls(children[0].el, "hideMe");\r
    }\r
};\r
\r
/**\r
 * Sets TabPanel current spec.\r
 */\r
Test.panel.TabPanel.prototype.setSpec = function(spec) {\r
    this.spec = spec;\r
    delete this.suite;\r
    this.resetToolBar();\r
    this.resetPanels();\r
};\r
\r
/**\r
 * Sets TabPanel current suite.\r
 */\r
Test.panel.TabPanel.prototype.setSuite = function(suite) {\r
    this.suite = suite;\r
    delete this.spec;\r
    this.resetToolBar();\r
    this.resetPanels();\r
};\r
\r
/**\r
 * Resize TabPanel dom element.\r
 */\r
Test.panel.TabPanel.prototype.resize = function(val) {\r
    this.el.style.height = val + "px";\r
    this.body.style.height = val - 40 + "px";\r
};\r
\r
/**\r
 * Adds jscoverage persistant panel.\r
 */\r
Test.panel.TabPanel.prototype.addCoverageSummary = function() {\r
    this.addTab("jsCoverageSummary", "Coverage Summary", true);\r
    this.add(new Test.panel.jsCoverageSummary({}));\r
};/**\r
 * @class Test.panel.TreeGrid\r
 * Creates and renders reporter treegrid.\r
 * @param {Object} config The configuration object.\r
 */\r
Test.panel.TreeGrid = function(config) {\r
    var me = this;\r
    me.options = Test.Options.get();\r
    \r
    me.el = document.body.appendChild(new jasmine.Dom({\r
        tag: "div",\r
        cls: "treegrid",\r
        onmousedown: function() {\r
            me.onMouseDown.apply(me, arguments);\r
        },\r
        onmouseup: function() {\r
            me.onMouseUp.apply(me, arguments);\r
        },\r
        onmousemove: function() {\r
            me.onMouseMove.apply(me, arguments);\r
        },\r
        children: [{\r
            cls: "header",\r
            children: [{\r
                    cls: "logo",\r
                    html: "Sencha"\r
                },{\r
                    cls: "statusMessage"\r
                },{\r
                    cls: "toolBar",\r
                    children: [{\r
                        tag: "span",\r
                        cls: "options",\r
                        children: [\r
                            Test.Options.renderCheckbox("showPassed", "Show passed"),\r
                            Test.Options.renderCheckbox("showDisabled", "Show disabled"),\r
                            Test.Options.renderCheckbox("collapseAll", "Collapse all"),\r
                            Test.Options.renderCheckbox("disableBodyClean", "Disable Body Autoclean"),\r
                            Test.Options.renderCheckbox("disableCacheBuster", "Disable CacheBuster"),\r
                            Test.Options.renderCheckbox("showTimings", "Show Timings"),\r
                            Test.Options.renderCheckbox("verbose", "Show jasmine logs"),\r
                            Test.Options.renderCheckbox("autoReload", "Automatic reload"),\r
                            Test.Options.renderCheckbox("quirksMode", "Quirks Mode")\r
                        ]\r
                },{\r
                    tag: "a",\r
                    cls: "actionLink",\r
                    html: "Run checked",\r
                    onclick: function() {\r
                        Test.Options.reloadWindow();\r
                    }\r
                },{\r
                    tag: "a",\r
                    cls: "actionLink",\r
                    html: "Run all",\r
                    onclick: function() {\r
                        Test.Options.reloadWindow(true);\r
                    }\r
                }]\r
            }]\r
            },{\r
            tag: "div",\r
            cls: "tbody",\r
            onclick: function() {\r
                me.onBodyClick.apply(me, arguments);\r
            }\r
            }, {\r
              cls: "resizer",\r
              html: "......"\r
            }]\r
    }));\r
    me.tabPanel = new Test.panel.TabPanel({\r
        container: me.el\r
    });\r
  \r
    Test.Options.check();\r
    me.header = me.el.childNodes[0];\r
    me.statusMessage = me.header.childNodes[1];\r
    me.toolBar = me.header.childNodes[2];\r
    me.body = me.el.childNodes[1];\r
    me.resizer = me.el.childNodes[2];    \r
    \r
    me.suites = {};\r
    me.specs = {};\r
    me.suitesEls = {};\r
    me.specsEls = {};\r
    if (me.options.resizer) {\r
        me.tabPanel.resize(parseInt(me.options.resizer, 10));\r
    }\r
    me.resizeBody();\r
    window.onresize = function() {\r
        me.resizeBody();\r
    };\r
};\r
\r
/**\r
 * Renders suite htmlElement.\r
 * @param {jasmine.Suite} suite The jasmine suite.\r
 * @return {HTMLElement} The suite HTMLElement\r
 */\r
Test.panel.TreeGrid.prototype.addSuite = function(suite) {\r
    var options = {},\r
        parent = suite.parentSuite,\r
        padding = 18,\r
        prefix = suite.isDisabled() ? "xdescribe :" : "describe: ",\r
        cls = "noexpand", \r
        row, property;\r
    \r
    if (suite.children_.length !== 0) {\r
        cls = this.options.collapseAll ? "expand" : "collapse";\r
    } \r
    \r
    if (parent) {\r
        this.suitesEls[parent.id] || this.addSuite(parent);\r
        while(parent) {\r
            padding += 18;\r
            parent = parent.parentSuite;\r
        }\r
    }\r
    row = this.createRow(this.options.collapseAll && suite.parentSuite, suite);\r
    for (property in this.options) {\r
        if (!this.options.hasOwnProperty(property)) {\r
            continue;\r
        }\r
        options[property] = this.options[property];\r
    }\r
\r
    options.suite = suite.id;\r
    delete options.spec;\r
    \r
    this.suitesEls[suite.id] = new jasmine.Dom({\r
        tag: "div",\r
        id: "suite-" + suite.id,\r
        cls: "suite " + (suite.isDisabled() ? "disabled" : ""),\r
        style: {\r
            "paddingLeft": padding + "px"\r
        },\r
        children: [{\r
            cls: cls\r
        },{\r
            tag: "span",\r
            cls: "description",\r
            html: prefix + suite.description\r
        }]\r
    });\r
    \r
    row.appendChild(this.suitesEls[suite.id]);\r
    var clear = new jasmine.Dom({ tag: 'div' });\r
    clear.style.clear = 'both';\r
    row.appendChild(clear);\r
    this.suites[suite.id] = suite;\r
    \r
    return this.suitesEls[suite.id];\r
};\r
\r
/**\r
 * Updates suite dom element by adding a code coverage percentage to it's description.\r
 * @param {HTMLElement} The suite dom element.\r
 * @param {jasmine.Suite} The jasmine suite.\r
 */\r
Test.panel.TreeGrid.prototype.updateSuiteEl = function(suite, text) {\r
	var description = this.suitesEls[suite.id].childNodes[1];\r
   jasmine.Dom.setHTML(description, description.innerHTML + text);\r
};\r
\r
/**\r
 * Renders spec htmlElement.\r
 * @param {jasmine.Spec} spec The jasmine spec.\r
 * @return {HTMLElement} The spec HTMLElement\r
 */\r
Test.panel.TreeGrid.prototype.addSpec = function(spec) {\r
    var options = {},\r
        padding = 18,\r
        suite = spec.suite,\r
        suffix = spec.time ? " (" + spec.time + "s)" : "",\r
        row, prefix, status, property, specEl, resultPanel;\r
        \r
    if (spec.isEnabled()) {\r
        prefix = "it ";\r
        status = spec.results().passed() ? "passed" : "failed";\r
    } else {\r
        prefix = "xit ";\r
        status = "disabled";\r
    }\r
    \r
    if (suite) {\r
        this.suitesEls[suite.id] || this.addSuite(suite);\r
        while(suite) {\r
            padding += 18;\r
            suite = suite.parentSuite;\r
        }\r
    }\r
    \r
    row = this.createRow(this.options.collapseAll, spec);\r
    for (property in this.options) {\r
        if (this.options.hasOwnProperty(property)) {\r
            options[property] = this.options[property];\r
        }\r
    }\r
\r
    options.spec = spec.id;\r
    delete options.suite;\r
    \r
    specEl = {\r
        id: "spec-" + spec.id,\r
        cls: "spec " + status,\r
        style: {\r
            "paddingLeft": padding + "px"\r
        },\r
        children: [{\r
            cls: this.options.collapseAll ? "expand" : "collapse"\r
        },{\r
            tag: "span",\r
            cls: "description",\r
            html: prefix + spec.description + suffix\r
        }]\r
    };\r
\r
    resultPanel = this.renderSpecResults(spec);\r
    if (this.options.collapseAll) {\r
        resultPanel.style.display = "none";\r
    }\r
    \r
    if (resultPanel.innerHTML === "") {\r
        specEl.children[0].cls = "noexpand";\r
    }\r
    \r
    specEl.children.push(resultPanel);\r
    \r
    specEl = new jasmine.Dom(specEl);\r
    this.specsEls[spec.id] = specEl;\r
    this.specs[spec.id] = spec;\r
    row.appendChild(specEl);\r
    jasmine.Dom.addCls(row, status);\r
    var clear = new jasmine.Dom({ tag: 'div' });\r
    clear.style.clear = 'both';\r
    row.appendChild(clear);\r
};\r
\r
/**\r
 * Returns a suite by id.\r
 * @param {String/Number} id The suite id.\r
 * @return {jasmine.Suite} The jasmine suite.\r
 */\r
Test.panel.TreeGrid.prototype.getSuite = function(id) {\r
    return this.suites[parseInt(id, 10)];\r
};\r
\r
/**\r
 * Returns a spec by id.\r
 * @param {String/Number} id The spec id.\r
 * @return {jasmine.Spec} The jasmine spec.\r
 */\r
Test.panel.TreeGrid.prototype.getSpec = function(id) {\r
    return this.specs[parseInt(id, 10)];\r
};\r
\r
/**\r
 * Body elements click event dispatcher.\r
 */\r
Test.panel.TreeGrid.prototype.onBodyClick = function(event) {\r
    event = event || window.event;\r
    var el = event.target || event.srcElement,\r
        cls = el.className,\r
        i;\r
        \r
    if (cls) {\r
        if (jasmine.Dom.hasCls(el, "collapse")) {\r
            this.onCollapse(el);\r
            return;\r
        }\r
\r
        if (jasmine.Dom.hasCls(el, "expand")) {\r
            this.onExpand(el);\r
            return;\r
        }\r
        if (jasmine.Dom.hasCls(el, "select-checkbox")) {\r
            this.onCheck(el);\r
            return;\r
        }\r
        for (i = 0; i < 6; i++) {\r
            if (cls && jasmine.Dom.hasCls(el, "row")) {\r
                this.onRowClick(el);\r
                return;\r
            }\r
            el = el.parentNode;\r
            if (!el) {\r
                break;\r
            }\r
            cls = el.className;\r
        }\r
    }\r
};\r
\r
/**\r
 * Checkboxes listener.\r
 */\r
Test.panel.TreeGrid.prototype.onCheck = function(el) {\r
    var next = el.parentNode.nextSibling,\r
        id;\r
\r
    if (jasmine.Dom.hasCls(next,"spec")) {\r
        id = parseInt(next.id.replace("spec-", ""), 10);\r
        if (el.checked) {\r
            if (jasmine.array.indexOf(this.options.specs, id) === -1) {\r
                this.options.specs.push(id);\r
            }\r
        } else {\r
            jasmine.array.remove(this.options.specs, id);\r
        }\r
    } else {\r
        id = parseInt(next.id.replace("suite-", ""), 10);\r
        if (el.checked) {\r
            if (jasmine.array.indexOf(this.options.suites, id) === -1) {\r
                this.options.suites.push(id);\r
            }\r
        } else {\r
            jasmine.array.remove(this.options.suites, id);\r
        }\r
    }\r
};\r
\r
/**\r
 * Returns row dom element by spec or suite.\r
 * @param {jasmine.Suite/jasmine.Spec} o A suite or a spec.\r
 * @return {HTMLElement} The row dom element.\r
 */\r
Test.panel.TreeGrid.prototype.getRow = function(o) {\r
    if (!o.suite && this.suitesEls[o.id]) {\r
        return this.suitesEls[o.id].parentNode;\r
    } else if (this.specsEls[o.id]) {\r
        return this.specsEls[o.id].parentNode;\r
    }\r
};\r
\r
/**\r
 * Iterates nested rows calling the supplied function.\r
 * @param {HTMLElement} row The row.\r
 * @param {Function} fn The function.\r
 * @param {Boolean} recursive recurse in all children suite (default to true)\r
 */\r
Test.panel.TreeGrid.prototype.onEachRow = function(row, fn, recursive) {\r
    var me = this,\r
        id = row.childNodes[1].id, \r
        traverse = function(s, func) {\r
            var children = s.children_,\r
                i, child, length, r;\r
        \r
            if (children) {\r
                length = children.length;\r
                for (i = 0; i < length; i++) {\r
                    child = children[i];\r
                    r = me.getRow(child);\r
                    if (r) {\r
                        func.call(me, r, child);\r
                        if (child.children_ && recursive !== false) {\r
                            traverse(child, func);\r
                        }\r
                    }\r
                }\r
            }\r
        },\r
        spec, suite;\r
    \r
    if (id.search("suite") !== -1) {\r
        suite = this.getSuite(id.replace("suite-", ""));\r
        traverse(suite, fn);\r
    } else {\r
        spec = this.getSpec(id.replace("spec-", ""));\r
        traverse(spec, fn);\r
    }\r
};\r
\r
/**\r
 * Collapse click handler.\r
 */\r
Test.panel.TreeGrid.prototype.onCollapse = function(el) {\r
    el = el.parentNode;\r
    jasmine.Dom.setCls(el.childNodes[0], "expand");\r
    \r
    if (jasmine.Dom.hasCls(el, "suite")) {\r
        this.onEachRow(el.parentNode, function(row, o) {\r
            var childNode = row.childNodes[1],\r
                icon = childNode.childNodes[0],\r
                content = childNode.childNodes[2];\r
                \r
            row.style.display = "none";\r
            if (jasmine.Dom.hasCls(icon, "collapse")) {\r
                jasmine.Dom.setCls(icon, "expand");\r
            }\r
            if (o.suite) {\r
                content.style.display = "none";\r
            }\r
        });\r
    } else {\r
        el.childNodes[2].style.display = "none";\r
    }\r
};\r
\r
/**\r
 * Expand click handler.\r
 */\r
Test.panel.TreeGrid.prototype.onExpand = function(el) {\r
    el = el.parentNode;\r
    jasmine.Dom.setCls(el.childNodes[0], "collapse");\r
    \r
    if (jasmine.Dom.hasCls(el, "suite")) {\r
        this.onEachRow(el.parentNode, function(row, o) {\r
            row.style.display = "block";\r
        }, false);\r
    } else {\r
        el.childNodes[2].style.display = "block";\r
    }\r
};\r
\r
/**\r
 * Row click click handler.\r
 */\r
Test.panel.TreeGrid.prototype.onRowClick = function(el) {\r
    var rows = el.parentNode.childNodes,\r
        length = rows.length, \r
        id, i;\r
        \r
    for (i = 0; i < length; i++) {\r
        jasmine.Dom.removeCls(rows[i], "selected");\r
    }\r
    \r
    jasmine.Dom.addCls(el, "row selected");\r
    id = el.childNodes[1].id;\r
    \r
    if (id.search("spec") !== -1) {\r
        this.tabPanel.setSpec(this.getSpec(id.replace("spec-", "")));\r
    }\r
    if (id.search("suite") !== -1) {\r
        this.tabPanel.setSuite(this.getSuite(id.replace("suite-", "")));\r
    }\r
};\r
\r
/**\r
 * Creates row dom element.\r
 * @param {Boolean} hide Sets the row visibility.\r
 * @param {jasmine.Suite/jasmine.Spec} The suite or the spec.\r
 * @return {HTMLElement} The row.\r
 */\r
Test.panel.TreeGrid.prototype.createRow = function(hide, o) {\r
    var row = this.body.appendChild(new jasmine.Dom({\r
            tag: "div",\r
            cls: "row",\r
            style: {\r
                display: hide ? "none" : "block" \r
            },\r
            children: [{\r
                cls: "checkbox-col",\r
                children: [{\r
                    tag: "input",\r
                    cls: "select-checkbox",\r
                    type: "checkbox"\r
                }]\r
            }]\r
\r
        }));\r
    \r
    if (Test.Options.isChecked(o)) {\r
        row.childNodes[0].childNodes[0].checked = true;\r
    }\r
        \r
    return row;\r
};\r
\r
/**\r
 * Resizer\r
 */\r
 \r
/**\r
 * MouseDown event listener. (resizing starts)\r
 */\r
Test.panel.TreeGrid.prototype.onMouseDown = function(event) {\r
    var el;\r
    \r
    event = event || window.event;\r
    el = event.target || event.srcElement;\r
\r
    if (jasmine.Dom.hasCls(el, "resizer")) {\r
        if (event.preventDefault) {\r
            event.preventDefault();\r
        } else {\r
            event.returnValue = false;\r
        }\r
        \r
        this.pageY = event.pageY || event.clientY;\r
\r
        this.startHeight = this.tabPanel.el.clientHeight;\r
        document.body.style.cursor = "row-resize";\r
    }\r
};\r
\r
/**\r
 * MouseDown event listener. (resize in progress)\r
 */\r
Test.panel.TreeGrid.prototype.onMouseMove = function(event) {\r
    var el, diff;\r
    if (this.pageY) {\r
        event = event || window.event;\r
        el = event.target || event.srcElement;\r
        diff = Math.max(200, this.startHeight - ((event.pageY || event.clientY)- this.pageY));\r
        diff = Math.min(diff, document.body.clientHeight - 200);\r
        \r
        this.tabPanel.resize(diff);\r
        this.options.resizer = diff;\r
        this.resizeBody();\r
    }\r
};\r
\r
/**\r
 * MouseUp event listener. (resize ends)\r
 */\r
Test.panel.TreeGrid.prototype.onMouseUp = function(event) {\r
    document.body.style.cursor = "auto";\r
    delete this.pageY;\r
};\r
\r
\r
/**\r
 * Returns treegrid innerHeight.\r
 * @return {Number} The innerHeight.\r
 */\r
Test.panel.TreeGrid.prototype.getInnerHeight = function() {\r
   return (window.innerHeight || document.documentElement.clientHeight) - this.header.offsetTop * 2;\r
};\r
\r
/**\r
 * Resizes treegrid.\r
 */\r
Test.panel.TreeGrid.prototype.resizeBody = function() {\r
    var height = this.getInnerHeight();\r
    \r
    height -= this.resizer.offsetHeight + this.tabPanel.el.offsetHeight + this.header.offsetHeight;\r
    height -= 2;\r
    height = Math.max(30, height);\r
    this.body.style.height = height + 'px';\r
};\r
\r
/**\r
 * End of Resizer\r
 */\r
 \r
/**\r
 * Renders specs results.\r
 * @param {jasmine.Spec} spec The spec.\r
 * @return {HTMLElement} The spec results dom element.\r
 */\r
Test.panel.TreeGrid.prototype.renderSpecResults = function(spec) {\r
     var resultItems = spec.results().getItems(),\r
        length = resultItems.length,\r
        resultsEl,\r
        resultEl,\r
        result,\r
        i;\r
            \r
    resultsEl = new jasmine.Dom({\r
        cls: "results"   \r
    });\r
        \r
    for (i = 0; i < length; i++) {\r
        result = resultItems[i];\r
        if (result.type === "expect" && result.passed) {\r
            \r
            if (!result.passed()) {\r
                resultEl = this.renderFailedResult(result);\r
            } else {\r
                resultEl = this.renderPassedResult(result);\r
            }\r
            \r
            if (i === 0) {\r
                jasmine.Dom.addCls(resultEl, "first");\r
            }\r
            \r
            resultsEl.appendChild(resultEl);\r
            \r
            if (result.error) {\r
                break;\r
            }\r
        }\r
    }\r
\r
    return resultsEl;\r
};\r
\r
/**\r
 * Renders failed spec result.\r
 * @param {Object} result The spec result.\r
 * @return {HTMLElement} The spec result message HTMLElement\r
 */\r
Test.panel.TreeGrid.prototype.renderFailedResult = function(result) {\r
    var message = result.message,\r
        children;\r
\r
    children = [{\r
        cls: "prettyPrint",\r
        html: jasmine.util.htmlEscape(message)\r
    }];\r
    \r
    return new jasmine.Dom({\r
        cls: "resultMessage fail",\r
        children: children\r
    });\r
};\r
\r
\r
/**\r
 * Renders failed spec result.\r
 * @param {Object} result The spec result.\r
 * @return {HTMLElement} The spec result message HTMLElement\r
 */\r
Test.panel.TreeGrid.prototype.renderPassedResult = function(result) {\r
    var children = [{\r
        cls: "prettyPrint",\r
        html: "Actual: " + jasmine.pp(result.actual) + "\nExpected: " + jasmine.pp(result.expected) + "\nMatcher: " + result.matcherName + "."\r
    }];\r
    \r
    return new jasmine.Dom({\r
        cls: "resultMessage pass",\r
        children: children\r
    });\r
};\r
\r
/**\r
 * Returns tabPanel console.\r
 */\r
Test.panel.TreeGrid.prototype.getInfoPanel = function() {\r
    return this.tabPanel.children[0];\r
};\r
\r
/**\r
 * Print a message into info console.\r
 * @param {String} message The message.\r
 * @param {String} cls (optional) an extra cls to add to the message.\r
 */\r
Test.panel.TreeGrid.prototype.log = function(message, cls) {\r
    this.getInfoPanel().log(message, cls);\r
};\r
\r
/**\r
 * Sets statubar message, this method can also add a className.\r
 * @param {String} message The message.\r
 * @param {String} cls The className (optional).\r
 */ \r
Test.panel.TreeGrid.prototype.setStatus = function(message, cls) {\r
    jasmine.Dom.setHTML(this.statusMessage, message);\r
    if (cls) {\r
        jasmine.Dom.addCls(this.statusMessage, cls);\r
    }\r
};/**\r
 * @class Test.Reporter\r
 * The Sencha Unit Tests Reporter\r
 */\r
\r
Test.Reporter = function(config) {\r
    config = config || {};\r
    this.options = Test.Options.get();\r
    this.runnedSpecsCount = 0;\r
    this.failedSpecsCount = 0;\r
    this.disabledSpecsCount = 0;\r
    this.optionCheckBoxesEl = {};\r
    this.treeGrid = new Test.panel.TreeGrid({});\r
    \r
};\r
\r
/**\r
 * Called before runner execution.\r
 * @param {jasmine.Runner} runner The Jasmine Runner\r
 */ \r
Test.Reporter.prototype.reportRunnerStarting = function(runner) {\r
    this.runner = runner;\r
    this.startedAt = new Date();\r
    if (Test.BadGlobals) {\r
        Test.BadGlobals.setup();\r
    }\r
    this.logger = this.treeGrid;\r
    \r
    this.log(">> Started at " + this.startedAt.toString(), "info");\r
        \r
    if (!this.options.remote) {\r
        this.log(">> Warning! Because you access TestReporter locally, stack trace report isn't available.", "warning");\r
    }\r
\r
    this.runner.filter(this.options.suites, this.options.specs);\r
\r
    if (Test.BadGlobals) {\r
        Test.BadGlobals.report(this.logger);\r
    }\r
};\r
\r
\r
/**\r
 * Called after Jasmine runner execution ends.\r
 * @param {jasmine.Runner} runner The Jasmine Runner\r
 */ \r
Test.Reporter.prototype.reportRunnerResults = function(runner) {\r
    Test.jsCoverage.updateTotal();\r
    this.renderResults(runner);\r
};\r
\r
/**\r
 * Called before spec execution.\r
 * @param {jasmine.Runner} suite The Jasmine spec\r
 */ \r
Test.Reporter.prototype.reportSuiteStarting = function(suite) {\r
	if (this.options.showTimings) {\r
		suite.startedAt = new Date();\r
	}\r
	if (Test.jsCoverage.isEnabled()) {\r
    	Test.jsCoverage.add(suite);\r
    }\r
};\r
/**\r
 * Called after suite execution ends.\r
 * @param {jasmine.Runner} suite A Jasmine suite\r
 */ \r
Test.Reporter.prototype.reportSuiteResults = function(suite) {\r
    var suiteEl = this.treeGrid ? this.treeGrid.suitesEls[suite.id] : undefined,\r
        status;\r
\r
    if (suite.isEnabled()) {\r
		if (this.options.showTimings) {\r
			suite.time =  (((new Date()).getTime() - suite.startedAt.getTime())/ 1000).toFixed(3);\r
		}\r
		\r
        Test.jsCoverage.update(suite);\r
        \r
        if (!suite.parentSuite && Test.BadGlobals) {\r
            Test.BadGlobals.report(this.logger, suite);\r
        }\r
        \r
        if (this.treeGrid && this.options.showPassed && !suiteEl) {\r
            suiteEl = this.treeGrid.addSuite(suite);\r
        }\r
        \r
        if (suiteEl) {\r
            status = suite.results().passed() ? "passed" : "failed";\r
            jasmine.Dom.addCls(suiteEl, status);\r
            jasmine.Dom.addCls(suiteEl.parentNode, status);\r
\r
			if (Test.jsCoverage.isEnabled()) {\r
				this.treeGrid.updateSuiteEl(suite, Test.jsCoverage.getSuiteCoverage(suite));\r
			}\r
			\r
			if (suite.time) {\r
				this.treeGrid.updateSuiteEl(suite, " (" + suite.time + "s)");\r
			}\r
        }\r
        \r
    } else if (this.treeGrid && this.options.showDisabled && !suiteEl) {\r
        this.treeGrid.addSuite(suite);\r
    }\r
    \r
};\r
\r
/**\r
 * Called before spec execution.\r
 * @param {jasmine.Runner} suite The Jasmine spec\r
 */ \r
Test.Reporter.prototype.reportSpecStarting = function(spec) {\r
    this.currentSpec = spec;\r
\r
    if (spec.isEnabled()) {\r
        if (this.options.showTimings) {\r
		    spec.startedAt = new Date();\r
	}\r
        this.treeGrid.setStatus("Running: " + jasmine.util.htmlEscape(spec.getFullName()));\r
    }\r
};\r
\r
/**\r
 * Called after spec execution.\r
 * @param {jasmine.Runner} suite The Jasmine spec\r
 */ \r
Test.Reporter.prototype.reportSpecResults = function(spec) {\r
    var results, status;\r
\r
        if (spec.isEnabled()) {\r
            if (this.options.showTimings) {\r
			    spec.time = (((new Date()).getTime() - spec.startedAt.getTime())/ 1000).toFixed(3);\r
		    }\r
            results = spec.results();\r
            status = results.passed() ? "passed" : "failed";\r
\r
            if(status === "failed") {\r
                this.failedSpecsCount = this.failedSpecsCount + 1;\r
            }\r
			\r
            if ((status === "failed" || this.options.showPassed) && spec.isEnabled() && this.treeGrid) {\r
                this.treeGrid.addSpec(spec);\r
            }\r
\r
            Test.SandBox.save(spec);\r
            \r
\r
            this.runnedSpecsCount = this.runnedSpecsCount + 1;\r
        } else {\r
            this.disabledSpecsCount = this.disabledSpecsCount + 1;\r
            if (this.treeGrid && this.options.showDisabled) {\r
                this.treeGrid.addSpec(spec);\r
            }\r
        }\r
};\r
\r
/**\r
 * Updates runner message with failed and passed specs\r
 * @param {jasmine.Runner} runner The jasmine runner.\r
 */\r
Test.Reporter.prototype.renderResults = function(runner) {\r
    var cls = (this.failedSpecsCount > 0) ? "failed" : "passed",\r
        runTime,\r
        message;\r
        \r
    runTime = (new Date().getTime() - this.startedAt.getTime()) / 1000;\r
\r
    message = this.runnedSpecsCount + " spec" +\r
              (this.runnedSpecsCount === 1 ? "" : "s" ) + " ran, " +\r
              this.failedSpecsCount + " failure" +\r
              (this.failedSpecsCount === 1 ? "" : "s") +\r
              " and " + this.disabledSpecsCount + " disabled";\r
                 \r
    message += " in " + runTime + "s";\r
    \r
    message += Test.jsCoverage.getTotal() + ".";\r
    \r
    if (this.treeGrid) {\r
        if (Test.SandBox.getWin()._$jscoverage) {\r
            this.treeGrid.tabPanel.addCoverageSummary();\r
        }\r
        this.treeGrid.setStatus(message, cls);\r
    }\r
    this.log(">> Finished at " + new Date().toString(), "info");\r
\r
};\r
\r
Test.Reporter.prototype.log = function() {        \r
    if (this.options.verbose || arguments.length === 2) {\r
        this.logger.log.apply(this.logger, arguments);\r
    }\r
};\r
\r
Test.Reporter.prototype.getIframeContainer = function() {\r
    if (this.treeGrid) {\r
        return this.treeGrid.tabPanel.children[1].el;\r
    }\r
    return document.body;\r
};\r