Update to 2.5.1

- Merges #1193 from @seanparmlee
- Fixes #1189

.codeclimate.yml

@@ -0,0 +1,7 @@
+languages:
+  JavaScript: true
+exclude_paths:
+- "lib/*"
+- "dist/*"
+- "grunt/*"
+- "images/*"

.editorconfig

@@ -0,0 +1,16 @@
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+
+[*.{js, json, sh, yml, gemspec}]
+indent_style = space
+indent_size = 2
+
+[{Rakefile, .jshintrc}]
+indent_style = space
+indent_size = 2
+
+[*.{py}]
+indent_style = space
+indent_size = 4

.travis.yml

@@ -2,7 +2,7 @@ language: ruby
 
 sudo: false
 
-rvm: 2.2.0
+rvm: 2.2.2
 
 script: $TEST_COMMAND
 

CONTRIBUTING.md

@@ -115,6 +115,15 @@ Jasmine uses the [Jasmine NPM package](http://github.com/jasmine/jasmine-npm) to
 
 ...and then the results will print to the console. All specs run except those that expect a browser (the specs in `spec/html` are ignored).
 
+The easiest way to run the tests in **Internet Explorer** is to run a VM that has IE installed. It's easy to do this with VirtualBox.
+
+1. Download and install [VirtualBox](https://www.virtualbox.org/wiki/Downloads).
+1. Download a VM image [from Microsoft](https://developer.microsoft.com/en-us/microsoft-edge/tools/vms/). Select "VirtualBox" as the platform.
+1. Unzip the downloaded archive. There should be an OVA file inside.
+1. In VirtualBox, choose `File > Import Appliance` and select the OVA file. Accept the default settings in the dialog that appears. Now you have a Windows VM!
+1. Run the VM and start IE.
+1. With `bundle exec rake jasmine` running on your host machine, navigate to `http://10.0.2.2:8888` in IE.
+
 ## Before Committing or Submitting a Pull Request
 
 1. Ensure all specs are green in browser *and* node

MIT.LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2014 Pivotal Labs
+Copyright (c) 2008-2016 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

README.md

@@ -9,7 +9,7 @@
 
 Jasmine is a Behavior Driven Development testing framework for JavaScript. It does not rely on browsers, DOM, or any JavaScript framework. Thus it's suited for websites, [Node.js](http://nodejs.org) projects, or anywhere that JavaScript can run.
 
-Documentation & guides live here: [http://jasmine.github.io](http://jasmine.github.io/)  
+Documentation & guides live here: [http://jasmine.github.io](http://jasmine.github.io/)
 For a quick start guide of Jasmine 2.0, see the beginning of [http://jasmine.github.io/2.0/introduction.html](http://jasmine.github.io/2.0/introduction.html)
 
 Upgrading from Jasmine 1.x? Check out the [2.0 release notes](https://github.com/jasmine/jasmine/blob/v2.0.0/release_notes/20.md) for a list of what's new (including breaking interface changes). You can also read the [upgrade guide](http://jasmine.github.io/2.0/upgrading.html).
@@ -29,6 +29,9 @@ For the Jasmine Ruby Gem:<br>
 For the Jasmine Python Egg:<br>
 [https://github.com/jasmine/jasmine-py](https://github.com/jasmine/jasmine-py)
 
+For the Jasmine headless browser gulp plugin:<br>
+[https://github.com/jasmine/gulp-jasmine-browser](https://github.com/jasmine/gulp-jasmine-browser)
+
 To install Jasmine standalone on your local box:
 
 * Download the standalone distribution for your desired release from the [releases page](https://github.com/jasmine/jasmine/releases)
@@ -73,4 +76,4 @@ Jasmine tests itself across many browsers (Safari, Chrome, Firefox, PhantomJS, a
 * [Christian Williams](mailto:antixian666@gmail.com), Cloud Foundry
 * Sheel Choksi
 
-Copyright (c) 2008-2015 Pivotal Labs. This software is licensed under the MIT License.
+Copyright (c) 2008-2016 Pivotal Labs. This software is licensed under the MIT License.

grunt/config/compass.js

@@ -5,6 +5,7 @@ module.exports = {
       sassDir: 'src/html',
       outputStyle: 'compact',
       noLineComments: true,
+      bundleExec: true
     }
   }
 };

lib/console/console.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2008-2015 Pivotal Labs
+Copyright (c) 2008-2016 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

lib/jasmine-core/boot.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2008-2015 Pivotal Labs
+Copyright (c) 2008-2016 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

lib/jasmine-core/jasmine-html.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2008-2015 Pivotal Labs
+Copyright (c) 2008-2016 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -209,9 +209,10 @@ jasmineRequire.HtmlReporter = function(j$) {
 
       if (specsExecuted < totalSpecsDefined) {
         var skippedMessage = 'Ran ' + specsExecuted + ' of ' + totalSpecsDefined + ' specs - run all';
+        var skippedLink = order && order.random ? '?random=true' : '?';
         alert.appendChild(
           createDom('span', {className: 'jasmine-bar jasmine-skipped'},
-            createDom('a', {href: '?', title: 'Run all specs'}, skippedMessage)
+            createDom('a', {href: skippedLink, title: 'Run all specs'}, skippedMessage)
           )
         );
       }
@@ -237,15 +238,22 @@ jasmineRequire.HtmlReporter = function(j$) {
 
       alert.appendChild(createDom('span', {className: statusBarClassName}, statusBarMessage, seedBar));
 
-      for(i = 0; i < failedSuites.length; i++) {
+      var errorBarClassName = 'jasmine-bar jasmine-errored';
+      var errorBarMessagePrefix = 'AfterAll ';
+
+      for(var i = 0; i < failedSuites.length; i++) {
         var failedSuite = failedSuites[i];
         for(var j = 0; j < failedSuite.failedExpectations.length; j++) {
-          var errorBarMessage = 'AfterAll ' + failedSuite.failedExpectations[j].message;
-          var errorBarClassName = 'jasmine-bar jasmine-errored';
-          alert.appendChild(createDom('span', {className: errorBarClassName}, errorBarMessage));
+          alert.appendChild(createDom('span', {className: errorBarClassName}, errorBarMessagePrefix + failedSuite.failedExpectations[j].message));
         }
       }
 
+      var globalFailures = (doneResult && doneResult.failedExpectations) || [];
+      for(i = 0; i < globalFailures.length; i++) {
+        var failure = globalFailures[i];
+        alert.appendChild(createDom('span', {className: errorBarClassName}, errorBarMessagePrefix + failure.message));
+      }
+
       var results = find('.jasmine-results');
       results.appendChild(summary);
 
@@ -309,7 +317,7 @@ jasmineRequire.HtmlReporter = function(j$) {
         setMenuModeTo('jasmine-failure-list');
 
         var failureNode = find('.jasmine-failures');
-        for (var i = 0; i < failures.length; i++) {
+        for (i = 0; i < failures.length; i++) {
           failureNode.appendChild(failures[i]);
         }
       }

lib/jasmine-core/jasmine.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2008-2015 Pivotal Labs
+Copyright (c) 2008-2016 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -23,7 +23,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 var getJasmineRequireObj = (function (jasmineGlobal) {
   var jasmineRequire;
 
-  if (typeof module !== 'undefined' && module.exports) {
+  if (typeof module !== 'undefined' && module.exports && typeof exports !== 'undefined') {
     if (typeof global !== 'undefined') {
       jasmineGlobal = global;
     } else {
@@ -47,9 +47,10 @@ var getJasmineRequireObj = (function (jasmineGlobal) {
     jRequire.base(j$, jasmineGlobal);
     j$.util = jRequire.util();
     j$.errors = jRequire.errors();
+    j$.formatErrorMsg = jRequire.formatErrorMsg();
     j$.Any = jRequire.Any(j$);
     j$.Anything = jRequire.Anything(j$);
-    j$.CallTracker = jRequire.CallTracker();
+    j$.CallTracker = jRequire.CallTracker(j$);
     j$.MockDate = jRequire.MockDate();
     j$.Clock = jRequire.Clock();
     j$.DelayedFunctionScheduler = jRequire.DelayedFunctionScheduler();
@@ -89,6 +90,8 @@ getJasmineRequireObj().requireMatchers = function(jRequire, j$) {
       'toBeDefined',
       'toBeFalsy',
       'toBeGreaterThan',
+      'toBeGreaterThanOrEqual',
+      'toBeLessThanOrEqual',
       'toBeLessThan',
       'toBeNaN',
       'toBeNull',
@@ -153,7 +156,12 @@ getJasmineRequireObj().base = function(j$, jasmineGlobal) {
   };
 
   j$.fnNameFor = function(func) {
-    return func.name || func.toString().match(/^\s*function\s*(\w*)\s*\(/)[1];
+    if (func.name) {
+      return func.name;
+    }
+
+    var matches = func.toString().match(/^\s*function\s*(\w*)\s*\(/);
+    return matches ? matches[1] : '<anonymous>';
   };
 
   j$.any = function(clazz) {
@@ -515,7 +523,6 @@ getJasmineRequireObj().Env = function(j$) {
     var realClearTimeout = j$.getGlobal().clearTimeout;
     this.clock = new j$.Clock(global, function () { return new j$.DelayedFunctionScheduler(); }, new j$.MockDate(global));
 
-    var runnableLookupTable = {};
     var runnableResources = {};
 
     var currentSpec = null;
@@ -625,7 +632,13 @@ getJasmineRequireObj().Env = function(j$) {
     };
 
     var getSpecName = function(spec, suite) {
-      return suite.getFullName() + ' ' + spec.description;
+      var fullName = [spec.description],
+          suiteFullName = suite.getFullName();
+
+      if (suiteFullName !== '') {
+        fullName.unshift(suiteFullName);
+      }
+      return fullName.join(' ');
     };
 
     // TODO: we may just be able to pass in the fn instead of wrapping here
@@ -701,9 +714,9 @@ getJasmineRequireObj().Env = function(j$) {
       env: this,
       id: getNextSuiteId(),
       description: 'Jasmine__TopLevel__Suite',
-      queueRunner: queueRunnerFactory
+      expectationFactory: expectationFactory,
+      expectationResultFactory: expectationResultFactory
     });
-    runnableLookupTable[topSuite.id] = topSuite;
     defaultResourcesForRunnable(topSuite.id);
     currentDeclarationSuite = topSuite;
 
@@ -754,9 +767,15 @@ getJasmineRequireObj().Env = function(j$) {
         totalSpecsDefined: totalSpecsDefined
       });
 
+      currentlyExecutingSuites.push(topSuite);
+
       processor.execute(function() {
+        clearResourcesForRunnable(topSuite.id);
+        currentlyExecutingSuites.pop();
+
         reporter.jasmineDone({
-          order: order
+          order: order,
+          failedExpectations: topSuite.result.failedExpectations
         });
       });
     };
@@ -765,6 +784,10 @@ getJasmineRequireObj().Env = function(j$) {
       reporter.addReporter(reporterToAdd);
     };
 
+    this.provideFallbackReporter = function(reporterToAdd) {
+      reporter.provideFallbackReporter(reporterToAdd);
+    };
+
     var spyRegistry = new j$.SpyRegistry({currentSpies: function() {
       if(!currentRunnable()) {
         throw new Error('Spies must be created in a before function or a spec');
@@ -772,6 +795,10 @@ getJasmineRequireObj().Env = function(j$) {
       return runnableResources[currentRunnable().id].spies;
     }});
 
+    this.allowRespy = function(allow){
+      spyRegistry.allowRespy(allow);
+    };
+
     this.spyOn = function() {
       return spyRegistry.spyOn.apply(spyRegistry, arguments);
     };
@@ -787,14 +814,13 @@ getJasmineRequireObj().Env = function(j$) {
         throwOnExpectationFailure: throwOnExpectationFailure
       });
 
-      runnableLookupTable[suite.id] = suite;
       return suite;
     };
 
     this.describe = function(description, specDefinitions) {
       var suite = suiteFactory(description);
       if (specDefinitions.length > 0) {
-        throw new Error('describe does not expect a done parameter');
+        throw new Error('describe does not expect any arguments');
       }
       if (currentDeclarationSuite.markedPending) {
         suite.pend();
@@ -889,8 +915,6 @@ getJasmineRequireObj().Env = function(j$) {
         throwOnExpectationFailure: throwOnExpectationFailure
       });
 
-      runnableLookupTable[spec.id] = spec;
-
       if (!self.specFilter(spec)) {
         spec.disable();
       }
@@ -1079,12 +1103,29 @@ getJasmineRequireObj().JsApiReporter = function() {
   return JsApiReporter;
 };
 
-getJasmineRequireObj().CallTracker = function() {
+getJasmineRequireObj().CallTracker = function(j$) {
 
   function CallTracker() {
     var calls = [];
+    var opts = {};
+
+    function argCloner(context) {
+      var clonedArgs = [];
+      var argsAsArray = j$.util.argsToArray(context.args);
+      for(var i = 0; i < argsAsArray.length; i++) {
+        if(Object.prototype.toString.apply(argsAsArray[i]).match(/^\[object/)) {
+          clonedArgs.push(j$.util.clone(argsAsArray[i]));
+        } else {
+          clonedArgs.push(argsAsArray[i]);
+        }
+      }
+      context.args = clonedArgs;
+    }
 
     this.track = function(context) {
+      if(opts.cloneArgs) {
+        argCloner(context);
+      }
       calls.push(context);
     };
 
@@ -1125,6 +1166,11 @@ getJasmineRequireObj().CallTracker = function() {
     this.reset = function() {
       calls = [];
     };
+
+    this.saveArgumentsByValue = function() {
+      opts.cloneArgs = true;
+    };
+
   }
 
   return CallTracker;
@@ -1214,8 +1260,7 @@ getJasmineRequireObj().Clock = function() {
 
     self.tick = function(millis) {
       if (installed) {
-        mockDate.tick(millis);
-        delayedFunctionScheduler.tick(millis);
+        delayedFunctionScheduler.tick(millis, function(millis) { mockDate.tick(millis); });
       } else {
         throw new Error('Mock clock is not installed, use jasmine.clock().install()');
       }
@@ -1273,11 +1318,11 @@ getJasmineRequireObj().DelayedFunctionScheduler = function() {
     var currentTime = 0;
     var delayedFnCount = 0;
 
-    self.tick = function(millis) {
+    self.tick = function(millis, tickDate) {
       millis = millis || 0;
       var endTime = currentTime + millis;
 
-      runScheduledFunctions(endTime);
+      runScheduledFunctions(endTime, tickDate);
       currentTime = endTime;
     };
 
@@ -1380,13 +1425,18 @@ getJasmineRequireObj().DelayedFunctionScheduler = function() {
       }
     }
 
-    function runScheduledFunctions(endTime) {
+    function runScheduledFunctions(endTime, tickDate) {
+      tickDate = tickDate || function() {};
       if (scheduledLookup.length === 0 || scheduledLookup[0] > endTime) {
+        tickDate(endTime - currentTime);
         return;
       }
 
       do {
-        currentTime = scheduledLookup.shift();
+        var newCurrentTime = scheduledLookup.shift();
+        tickDate(newCurrentTime - currentTime);
+
+        currentTime = newCurrentTime;
 
         var funcsToRun = scheduledFunctions[currentTime];
         delete scheduledFunctions[currentTime];
@@ -1405,6 +1455,11 @@ getJasmineRequireObj().DelayedFunctionScheduler = function() {
               // scheduled in a funcToRun from forcing an extra iteration
                  currentTime !== endTime  &&
                  scheduledLookup[0] <= endTime);
+
+      // ran out of functions to call, but still time left on the clock
+      if (currentTime !== endTime) {
+        tickDate(endTime - currentTime);
+      }
     }
   }
 
@@ -1841,6 +1896,7 @@ getJasmineRequireObj().QueueRunner = function(j$) {
         called = true;
         fn();
       }
+      return null;
     };
   }
 
@@ -1952,14 +2008,23 @@ getJasmineRequireObj().ReportDispatcher = function() {
     }
 
     var reporters = [];
+    var fallbackReporter = null;
 
     this.addReporter = function(reporter) {
       reporters.push(reporter);
     };
+    
+    this.provideFallbackReporter = function(reporter) {
+      fallbackReporter = reporter;
+    };
+
 
     return this;
 
     function dispatch(method, args) {
+      if (reporters.length === 0 && fallbackReporter !== null) {
+          reporters.push(fallbackReporter);
+      }
       for (var i = 0; i < reporters.length; i++) {
         var reporter = reporters[i];
         if (reporter[method]) {
@@ -1975,26 +2040,36 @@ getJasmineRequireObj().ReportDispatcher = function() {
 
 getJasmineRequireObj().SpyRegistry = function(j$) {
 
+  var getErrorMsg = j$.formatErrorMsg('<spyOn>', 'spyOn(<object>, <methodName>)');
+
   function SpyRegistry(options) {
     options = options || {};
     var currentSpies = options.currentSpies || function() { return []; };
 
+    this.allowRespy = function(allow){
+      this.respy = allow;
+    };
+
     this.spyOn = function(obj, methodName) {
+
       if (j$.util.isUndefined(obj)) {
-        throw new Error('spyOn could not find an object to spy upon for ' + methodName + '()');
+        throw new Error(getErrorMsg('could not find an object to spy upon for ' + methodName + '()'));
       }
 
       if (j$.util.isUndefined(methodName)) {
-        throw new Error('No method name supplied');
+        throw new Error(getErrorMsg('No method name supplied'));
       }
 
       if (j$.util.isUndefined(obj[methodName])) {
-        throw new Error(methodName + '() method does not exist');
+        throw new Error(getErrorMsg(methodName + '() method does not exist'));
       }
 
-      if (obj[methodName] && j$.isSpy(obj[methodName])) {
-        //TODO?: should this return the current spy? Downside: may cause user confusion about spy state
-        throw new Error(methodName + ' has already been spied upon');
+      if (obj[methodName] && j$.isSpy(obj[methodName])  ) {
+        if ( !!this.respy ){
+          return obj[methodName];
+        }else {
+          throw new Error(getErrorMsg(methodName + ' has already been spied upon'));
+        }
       }
 
       var descriptor;
@@ -2005,28 +2080,39 @@ getJasmineRequireObj().SpyRegistry = function(j$) {
       }
 
       if (descriptor && !(descriptor.writable || descriptor.set)) {
-        throw new Error(methodName + ' is not declared writable or has no setter');
+        throw new Error(getErrorMsg(methodName + ' is not declared writable or has no setter'));
       }
 
-      var spy = j$.createSpy(methodName, obj[methodName]);
+      var originalMethod = obj[methodName],
+        spiedMethod = j$.createSpy(methodName, originalMethod),
+        restoreStrategy;
+
+      if (Object.prototype.hasOwnProperty.call(obj, methodName)) {
+        restoreStrategy = function() {
+          obj[methodName] = originalMethod;
+        };
+      } else {
+        restoreStrategy = function() {
+          if (!delete obj[methodName]) {
+            obj[methodName] = originalMethod;
+          }
+        };
+      }
 
       currentSpies().push({
-        spy: spy,
-        baseObj: obj,
-        methodName: methodName,
-        originalValue: obj[methodName]
+        restoreObjectToOriginalState: restoreStrategy
       });
 
-      obj[methodName] = spy;
+      obj[methodName] = spiedMethod;
 
-      return spy;
+      return spiedMethod;
     };
 
     this.clearSpies = function() {
       var spies = currentSpies();
-      for (var i = 0; i < spies.length; i++) {
+      for (var i = spies.length - 1; i >= 0; i--) {
         var spyEntry = spies[i];
-        spyEntry.baseObj[spyEntry.methodName] = spyEntry.originalValue;
+        spyEntry.restoreObjectToOriginalState();
       }
     };
   }
@@ -2081,6 +2167,9 @@ getJasmineRequireObj().SpyStrategy = function() {
     };
 
     this.callFake = function(fn) {
+      if(!(fn instanceof Function)) {
+        throw new Error('Argument passed to callFake should be a function, got ' + fn);
+      }
       plan = fn;
       return getSpy();
     };
@@ -2125,13 +2214,13 @@ getJasmineRequireObj().Suite = function(j$) {
   };
 
   Suite.prototype.getFullName = function() {
-    var fullName = this.description;
-    for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
+    var fullName = [];
+    for (var parentSuite = this; parentSuite; parentSuite = parentSuite.parentSuite) {
       if (parentSuite.parentSuite) {
-        fullName = parentSuite.description + ' ' + fullName;
+        fullName.unshift(parentSuite.description);
       }
     }
-    return fullName;
+    return fullName.join(' ');
   };
 
   Suite.prototype.disable = function() {
@@ -2665,6 +2754,18 @@ getJasmineRequireObj().errors = function() {
     ExpectationFailed: ExpectationFailed
   };
 };
+getJasmineRequireObj().formatErrorMsg = function() {
+  function generateErrorMsg(domain, usage) {
+    var usageDefinition = usage ? '\nUsage: ' + usage : '';
+
+    return function errorMsg(msg) {
+      return domain + ' : ' + msg + usageDefinition;
+    };
+  }
+
+  return generateErrorMsg;
+};
+
 getJasmineRequireObj().matchersUtil = function(j$) {
   // TODO: what to do about jasmine.pp not being inject? move to JSON.stringify? gut PrettyPrinter?
 
@@ -2828,35 +2929,43 @@ getJasmineRequireObj().matchersUtil = function(j$) {
     var size = 0;
     // Recursively compare objects and arrays.
     // Compare array lengths to determine if a deep comparison is necessary.
-    if (className == '[object Array]' && a.length !== b.length) {
-      result = false;
-    }
+    if (className == '[object Array]') {
+      size = a.length;
+      if (size !== b.length) {
+        return false;
+      }
 
-    if (result) {
-      // Objects with different constructors are not equivalent, but `Object`s
-      // or `Array`s from different frames are.
-      if (className !== '[object Array]') {
-        var aCtor = a.constructor, bCtor = b.constructor;
-        if (aCtor !== bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor &&
-               isFunction(bCtor) && bCtor instanceof bCtor)) {
+      while (size--) {
+        result = eq(a[size], b[size], aStack, bStack, customTesters);
+        if (!result) {
           return false;
         }
       }
-      // Deep compare objects.
-      for (var key in a) {
-        if (has(a, key)) {
-          // Count the expected number of properties.
-          size++;
-          // Deep compare each member.
-          if (!(result = has(b, key) && eq(a[key], b[key], aStack, bStack, customTesters))) { break; }
-        }
+    } else {
+
+      // Objects with different constructors are not equivalent, but `Object`s
+      // or `Array`s from different frames are.
+      var aCtor = a.constructor, bCtor = b.constructor;
+      if (aCtor !== bCtor && !(isObjectConstructor(aCtor) &&
+                               isObjectConstructor(bCtor))) {
+        return false;
       }
-      // Ensure that both objects contain the same number of properties.
-      if (result) {
-        for (key in b) {
-          if (has(b, key) && !(size--)) { break; }
-        }
-        result = !size;
+    }
+
+    // Deep compare objects.
+    var aKeys = keys(a, className == '[object Array]'), key;
+    size = aKeys.length;
+
+    // Ensure that both objects contain the same number of properties before comparing deep equality.
+    if (keys(b, className == '[object Array]').length !== size) { return false; }
+
+    while (size--) {
+      key = aKeys[size];
+      // Deep compare each member
+      result = has(b, key) && eq(a[key], b[key], aStack, bStack, customTesters);
+
+      if (!result) {
+        return false;
       }
     }
     // Remove the first object from the stack of traversed objects.
@@ -2865,14 +2974,52 @@ getJasmineRequireObj().matchersUtil = function(j$) {
 
     return result;
 
-    function has(obj, key) {
-      return Object.prototype.hasOwnProperty.call(obj, key);
-    }
+    function keys(obj, isArray) {
+      var allKeys = Object.keys ? Object.keys(obj) :
+        (function(o) {
+            var keys = [];
+            for (var key in o) {
+                if (has(o, key)) {
+                    keys.push(key);
+                }
+            }
+            return keys;
+        })(obj);
 
-    function isFunction(obj) {
-      return typeof obj === 'function';
+      if (!isArray) {
+        return allKeys;
+      }
+
+      var extraKeys = [];
+      if (allKeys.length === 0) {
+          return allKeys;
+      }
+
+      for (var x = 0; x < allKeys.length; x++) {
+          if (!allKeys[x].match(/^[0-9]+$/)) {
+              extraKeys.push(allKeys[x]);
+          }
+      }
+
+      return extraKeys;
     }
   }
+
+  function has(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+  }
+
+  function isFunction(obj) {
+    return typeof obj === 'function';
+  }
+
+  function isObjectConstructor(ctor) {
+    // aCtor instanceof aCtor is true for the Object and Function
+    // constructors (since a constructor is-a Function and a function is-a
+    // Object). We don't just compare ctor === Object because the constructor
+    // might come from a different frame with different globals.
+    return isFunction(ctor) && ctor instanceof ctor;
+  }
 };
 
 getJasmineRequireObj().toBe = function() {
@@ -2952,6 +3099,21 @@ getJasmineRequireObj().toBeGreaterThan = function() {
 };
 
 
+getJasmineRequireObj().toBeGreaterThanOrEqual = function() {
+
+  function toBeGreaterThanOrEqual() {
+    return {
+      compare: function(actual, expected) {
+        return {
+          pass: actual >= expected
+        };
+      }
+    };
+  }
+
+  return toBeGreaterThanOrEqual;
+};
+
 getJasmineRequireObj().toBeLessThan = function() {
   function toBeLessThan() {
     return {
@@ -2966,6 +3128,21 @@ getJasmineRequireObj().toBeLessThan = function() {
 
   return toBeLessThan;
 };
+getJasmineRequireObj().toBeLessThanOrEqual = function() {
+  function toBeLessThanOrEqual() {
+    return {
+
+      compare: function(actual, expected) {
+        return {
+          pass: actual <= expected
+        };
+      }
+    };
+  }
+
+  return toBeLessThanOrEqual;
+};
+
 getJasmineRequireObj().toBeNaN = function(j$) {
 
   function toBeNaN() {
@@ -3074,17 +3251,19 @@ getJasmineRequireObj().toEqual = function() {
 
 getJasmineRequireObj().toHaveBeenCalled = function(j$) {
 
+  var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalled>', 'expect(<spyObj>).toHaveBeenCalled()');
+
   function toHaveBeenCalled() {
     return {
       compare: function(actual) {
         var result = {};
 
         if (!j$.isSpy(actual)) {
-          throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
+          throw new Error(getErrorMsg('Expected a spy, but got ' + j$.pp(actual) + '.'));
         }
 
         if (arguments.length > 1) {
-          throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
+          throw new Error(getErrorMsg('Does not take arguments, use toHaveBeenCalledWith'));
         }
 
         result.pass = actual.calls.any();
@@ -3103,18 +3282,20 @@ getJasmineRequireObj().toHaveBeenCalled = function(j$) {
 
 getJasmineRequireObj().toHaveBeenCalledTimes = function(j$) {
 
+  var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalledTimes>', 'expect(<spyObj>).toHaveBeenCalledTimes(<Number>)');
+
   function toHaveBeenCalledTimes() {
     return {
       compare: function(actual, expected) {
         if (!j$.isSpy(actual)) {
-          throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
+          throw new Error(getErrorMsg('Expected a spy, but got ' + j$.pp(actual) + '.'));
         }
 
         var args = Array.prototype.slice.call(arguments, 0),
           result = { pass: false };
 
-        if(!expected){
-          throw new Error('Expected times failed is required as an argument.');
+        if (!j$.isNumber_(expected)){
+          throw new Error(getErrorMsg('The expected times failed is a required argument and must be a number.'));
         }
 
         actual = args[0];
@@ -3134,6 +3315,8 @@ getJasmineRequireObj().toHaveBeenCalledTimes = function(j$) {
 
 getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
 
+  var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalledWith>', 'expect(<spyObj>).toHaveBeenCalledWith(...arguments)');
+
   function toHaveBeenCalledWith(util, customEqualityTesters) {
     return {
       compare: function() {
@@ -3143,7 +3326,7 @@ getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
           result = { pass: false };
 
         if (!j$.isSpy(actual)) {
-          throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
+          throw new Error(getErrorMsg('Expected a spy, but got ' + j$.pp(actual) + '.'));
         }
 
         if (!actual.calls.any()) {
@@ -3168,11 +3351,13 @@ getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
 
 getJasmineRequireObj().toMatch = function(j$) {
 
+  var getErrorMsg = j$.formatErrorMsg('<toMatch>', 'expect(<expectation>).toMatch(<string> || <regexp>)');
+
   function toMatch() {
     return {
       compare: function(actual, expected) {
         if (!j$.isString_(expected) && !j$.isA_('RegExp', expected)) {
-          throw new Error('Expected is not a String or a RegExp');
+          throw new Error(getErrorMsg('Expected is not a String or a RegExp'));
         }
 
         var regexp = new RegExp(expected);
@@ -3189,6 +3374,8 @@ getJasmineRequireObj().toMatch = function(j$) {
 
 getJasmineRequireObj().toThrow = function(j$) {
 
+  var getErrorMsg = j$.formatErrorMsg('<toThrow>', 'expect(function() {<expectation>}).toThrow()');
+
   function toThrow(util) {
     return {
       compare: function(actual, expected) {
@@ -3197,7 +3384,7 @@ getJasmineRequireObj().toThrow = function(j$) {
           thrown;
 
         if (typeof actual != 'function') {
-          throw new Error('Actual is not a Function');
+          throw new Error(getErrorMsg('Actual is not a Function'));
         }
 
         try {
@@ -3235,6 +3422,9 @@ getJasmineRequireObj().toThrow = function(j$) {
 };
 
 getJasmineRequireObj().toThrowError = function(j$) {
+
+  var getErrorMsg =  j$.formatErrorMsg('<toThrowError>', 'expect(function() {<expectation>}).toThrowError(<ErrorConstructor>, <message>)');
+
   function toThrowError () {
     return {
       compare: function(actual) {
@@ -3244,7 +3434,7 @@ getJasmineRequireObj().toThrowError = function(j$) {
           thrown;
 
         if (typeof actual != 'function') {
-          throw new Error('Actual is not a Function');
+          throw new Error(getErrorMsg('Actual is not a Function'));
         }
 
         var errorMatcher = getMatcher.apply(null, arguments);
@@ -3300,15 +3490,15 @@ getJasmineRequireObj().toThrowError = function(j$) {
         errorType = arguments[1];
         expected = arguments[2];
         if (!isAnErrorType(errorType)) {
-          throw new Error('Expected error type is not an Error.');
+          throw new Error(getErrorMsg('Expected error type is not an Error.'));
         }
       }
 
       if (expected && !isStringOrRegExp(expected)) {
         if (errorType) {
-          throw new Error('Expected error message is not a string or RegExp.');
+          throw new Error(getErrorMsg('Expected error message is not a string or RegExp.'));
         } else {
-          throw new Error('Expected is not an Error, string, or RegExp.');
+          throw new Error(getErrorMsg('Expected is not an Error, string, or RegExp.'));
         }
       }
 
@@ -3450,5 +3640,5 @@ getJasmineRequireObj().interface = function(jasmine, env) {
 };
 
 getJasmineRequireObj().version = function() {
-  return '2.4.1';
+  return '2.5.1';
 };

lib/jasmine-core/node_boot.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2008-2015 Pivotal Labs
+Copyright (c) 2008-2016 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

lib/jasmine-core/version.rb

@@ -4,6 +4,6 @@
 #
 module Jasmine
   module Core
-    VERSION = "2.4.1"
+    VERSION = "2.5.1"
   end
 end

package.json

@@ -1,7 +1,7 @@
 {
   "name": "jasmine-core",
   "license": "MIT",
-  "version": "2.4.1",
+  "version": "2.5.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/jasmine/jasmine.git"
@@ -13,22 +13,22 @@
     "bdd"
   ],
   "scripts": {
-    "test": "./node_modules/.bin/grunt jshint execSpecsInNode"
+    "test": "grunt jshint execSpecsInNode"
   },
   "description": "Official packaging of Jasmine's core files for use by Node.js projects.",
   "homepage": "http://jasmine.github.io",
   "main": "./lib/jasmine-core.js",
   "devDependencies": {
-    "glob": "~5.0.13",
-    "grunt": "~0.4.1",
-    "grunt-cli": "^0.1.13",
-    "grunt-contrib-compass": "~0.6.0",
-    "grunt-contrib-compress": "~0.5.2",
-    "grunt-contrib-concat": "~0.3.0",
-    "grunt-contrib-jshint": "~0.7.0",
-    "jasmine": "git://github.com/jasmine/jasmine-npm.git",
+    "glob": "~7.0.5",
+    "grunt": "^1.0.1",
+    "grunt-cli": "^1.2.0",
+    "grunt-contrib-compass": "^1.1.1",
+    "grunt-contrib-compress": "^1.3.0",
+    "grunt-contrib-concat": "^1.0.1",
+    "grunt-contrib-jshint": "^1.0.0",
+    "jasmine": "^2.4.0",
     "load-grunt-tasks": "^0.4.0",
-    "shelljs": "~0.1.4",
+    "shelljs": "^0.7.0",
     "temp": "~0.8.1"
   }
 }

release_notes/2.5.0.md

@@ -0,0 +1,116 @@
+# Jasmine 2.5.0 Release Notes 
+
+## Summary
+
+This release contains a number of fixes and pull requests.
+
+## Changes
+
+* Rename `j$` to `jasmineUnderTest` for specs
+    - Please update any pull requests to simplify merging, thanks.
+
+## Pull Requests & Issues
+
+* Prettyprint objects whose constructors have custom toString method
+  - Fixes [#1019](https://github.com/jasmine/jasmine/issues/1019)
+  - Merges [#1099](https://github.com/jasmine/jasmine/issues/1099) from @mbildner
+
+* Add gulp-jasmine-browser link to readme
+  - Fixes [#1089](https://github.com/jasmine/jasmine/issues/1089)
+
+* Exclude lib directory from codeclimate
+  - Fixes [#1171](https://github.com/jasmine/jasmine/issues/1171)
+
+* Add instructions for testing in IE
+  - Merges [#1170](https://github.com/jasmine/jasmine/issues/1170) from @benchristel
+
+* Update devDependencies and fix issues from this
+  - Merges [#1162](https://github.com/jasmine/jasmine/issues/1162) from @amavisca
+
+* Remove runnableLookupTable which is no longer used
+  - Merges [#1129](https://github.com/jasmine/jasmine/issues/1129) from @gregeninfrank
+
+* Make `toEqual` pass for arrays with equivalent properties
+  - Merges [#1155](https://github.com/jasmine/jasmine/issues/1155) from @benchristel
+
+* Update ruby version on travis to let rack install
+  - Merges [#1152](https://github.com/jasmine/jasmine/issues/1152) from @amavisca
+
+* Fix jasmine setup in Electron environment
+  - Merges [#1079](https://github.com/jasmine/jasmine/issues/1079) from @skupr
+  - Fixes [#964](https://github.com/jasmine/jasmine/issues/964)
+
+* Improve errors with the domain and how to use the API
+  - Merges [#1026](https://github.com/jasmine/jasmine/issues/1026) from @dhoko
+  - Fixes [#1025](https://github.com/jasmine/jasmine/issues/1025)
+
+* The done function now returns null
+  - Merges [#1062](https://github.com/jasmine/jasmine/issues/1062) from @marneborn
+  - Fixes [#992](https://github.com/jasmine/jasmine/issues/992)
+
+* Add .editorconfig file
+  - Merges [#1058](https://github.com/jasmine/jasmine/issues/1058) from @kapke
+  - Fixes [#1057](https://github.com/jasmine/jasmine/issues/1057)
+
+* Improve error message when passing a non-function to callFake
+  - Merges [#1059](https://github.com/jasmine/jasmine/issues/1059) from @kapke
+  - Fixes [#1016](https://github.com/jasmine/jasmine/issues/1016)
+
+* Allow expectations in a global beforeAll or afterAll
+  - Fixes [#811](https://github.com/jasmine/jasmine/issues/811)
+
+* Correctly tear down spies on inherited methods
+  - Merges [#1036](https://github.com/jasmine/jasmine/issues/1036) from @benchristel
+  - Fixes [#737](https://github.com/jasmine/jasmine/issues/737)
+
+* Array equality treats undefined elements as equal however they got in there
+  - Fixes [#786](https://github.com/jasmine/jasmine/issues/786)
+
+* Add support for a fallback reporter
+  - Merges [#1009](https://github.com/jasmine/jasmine/issues/1009) from @mauricioborges
+
+* Grunt task for compass should prefix command with 'bundle exec'
+  - Merges [#1047](https://github.com/jasmine/jasmine/issues/1047) from @d-reinhold
+
+* Fix `toEqual` for Microsoft Edge
+  - Merges [#1041](https://github.com/jasmine/jasmine/issues/1041) from @everedifice
+
+* Update describe error message to no longer assume errant args are `done`
+  - Fixes [#896](https://github.com/jasmine/jasmine/issues/896)
+
+* Add toBeGreatThanOrEqual and toBeLessThanOrEqual matchers
+  - Merges [#1049](https://github.com/jasmine/jasmine/issues/1049) from @rullopat
+  - Fixes [#1013](https://github.com/jasmine/jasmine/issues/1013)
+
+* Support call count of 0 with toHaveBeenCalledTimes matcher
+  - Merges [#1048](https://github.com/jasmine/jasmine/issues/1048) from @logankd
+  - Fixes [#994](https://github.com/jasmine/jasmine/issues/994)
+
+* Correctly clean up spies after a spy is replaced and re-spied upon
+  - Merges [#1011](https://github.com/jasmine/jasmine/issues/1011) from @bodawei
+  - Fixes [#1010](https://github.com/jasmine/jasmine/issues/1010)
+
+* remove extra topSuite `queueRunner` construction parameter
+  - Merges [#1006](https://github.com/jasmine/jasmine/issues/1006) from @jurko-gospodnetic
+
+* add option to shallow clone args in call tracker
+  - Merges [#1000](https://github.com/jasmine/jasmine/issues/1000) from @a-r-d
+  - Fixes [#872](https://github.com/jasmine/jasmine/issues/872)
+
+* Update license year range to 2016
+    - Merges [#1021](https://github.com/jasmine/jasmine/issues/1021) from pra85
+
+* Persist randomize param in 'run all' links
+    - Merges [#990](https://github.com/jasmine/jasmine/issues/990) from @basawyer
+
+* make DelayedFunctionScheduler update the mockDate
+    - Fixes [#915](https://github.com/jasmine/jasmine/issues/915)
+    - Merges [#980](https://github.com/jasmine/jasmine/issues/980) from @andrewiggings
+
+* Allow `spyOn` to allow a respy for functions that have already been spied upon
+  - Merges [#953](https://github.com/jasmine/jasmine/issues/953) from @guy-mograbi-at-gigaspaces
+  - Fixes [#931](https://github.com/jasmine/jasmine/issues/931)
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/2.5.1.md

@@ -0,0 +1,19 @@
+# Jasmine 2.5.1 Release Notes
+
+## Pull Requests & Issues
+
+* fallback on assignment when a spy cannot be deleted
+  - Merges [#1193](https://github.com/jasmine/jasmine/issues/1193) from @seanparmlee
+  - Fixes [#1189](https://github.com/jasmine/jasmine/issues/1189)
+
+* Fix issue with equality of Arrays in PhantomJS
+  - Merges [#1192](https://github.com/jasmine/jasmine/issues/1192) from @logankd
+  - Fixes [#1188](https://github.com/jasmine/jasmine/issues/1188)
+
+* Properly tick date along with clock
+  - Fixes [#1190](https://github.com/jasmine/jasmine/issues/1190)
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

spec/console/ConsoleReporterSpec.js

@@ -19,7 +19,7 @@ describe("ConsoleReporter", function() {
   });
 
   it("reports that the suite has started to the console", function() {
-    var reporter = new j$.ConsoleReporter({
+    var reporter = new jasmineUnderTest.ConsoleReporter({
       print: out.print
     });
 
@@ -30,7 +30,7 @@ describe("ConsoleReporter", function() {
 
   it("starts the provided timer when jasmine starts", function() {
     var timerSpy = jasmine.createSpyObj('timer', ['start']),
-        reporter = new j$.ConsoleReporter({
+        reporter = new jasmineUnderTest.ConsoleReporter({
           print: out.print,
           timer: timerSpy
         });
@@ -41,7 +41,7 @@ describe("ConsoleReporter", function() {
   });
 
   it("reports a passing spec as a dot", function() {
-    var reporter = new j$.ConsoleReporter({
+    var reporter = new jasmineUnderTest.ConsoleReporter({
       print: out.print
     });
 
@@ -51,7 +51,7 @@ describe("ConsoleReporter", function() {
   });
 
   it("does not report a disabled spec", function() {
-    var reporter = new j$.ConsoleReporter({
+    var reporter = new jasmineUnderTest.ConsoleReporter({
       print: out.print
     });
 
@@ -61,7 +61,7 @@ describe("ConsoleReporter", function() {
   });
 
   it("reports a failing spec as an 'F'", function() {
-    var reporter = new j$.ConsoleReporter({
+    var reporter = new jasmineUnderTest.ConsoleReporter({
       print: out.print
     });
 
@@ -71,7 +71,7 @@ describe("ConsoleReporter", function() {
   });
 
   it("reports a pending spec as a '*'", function() {
-    var reporter = new j$.ConsoleReporter({
+    var reporter = new jasmineUnderTest.ConsoleReporter({
       print: out.print
     });
 
@@ -81,7 +81,7 @@ describe("ConsoleReporter", function() {
   });
 
   it("alerts user if there are no specs", function(){
-    var reporter = new j$.ConsoleReporter({
+    var reporter = new jasmineUnderTest.ConsoleReporter({
           print: out.print
         });
 
@@ -94,7 +94,7 @@ describe("ConsoleReporter", function() {
 
   it("reports a summary when done (singular spec and time)", function() {
     var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
-        reporter = new j$.ConsoleReporter({
+        reporter = new jasmineUnderTest.ConsoleReporter({
           print: out.print,
           timer: timerSpy
         });
@@ -114,7 +114,7 @@ describe("ConsoleReporter", function() {
 
   it("reports a summary when done (pluralized specs and seconds)", function() {
     var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
-        reporter = new j$.ConsoleReporter({
+        reporter = new jasmineUnderTest.ConsoleReporter({
           print: out.print,
           timer: timerSpy
         });
@@ -148,7 +148,7 @@ describe("ConsoleReporter", function() {
   });
 
   it("reports a summary when done that includes stack traces for a failing suite", function() {
-    var reporter = new j$.ConsoleReporter({
+    var reporter = new jasmineUnderTest.ConsoleReporter({
       print: out.print
     });
 
@@ -182,7 +182,7 @@ describe("ConsoleReporter", function() {
 
     beforeEach(function() {
       onComplete = jasmine.createSpy('onComplete');
-      reporter = new j$.ConsoleReporter({
+      reporter = new jasmineUnderTest.ConsoleReporter({
         print: out.print,
         onComplete: onComplete
       });
@@ -210,7 +210,7 @@ describe("ConsoleReporter", function() {
 
   describe("with color", function() {
     it("reports that the suite has started to the console", function() {
-      var reporter = new j$.ConsoleReporter({
+      var reporter = new jasmineUnderTest.ConsoleReporter({
         print: out.print,
         showColors: true
       });
@@ -221,7 +221,7 @@ describe("ConsoleReporter", function() {
     });
 
     it("reports a passing spec as a dot", function() {
-      var reporter = new j$.ConsoleReporter({
+      var reporter = new jasmineUnderTest.ConsoleReporter({
         print: out.print,
         showColors: true
       });
@@ -232,7 +232,7 @@ describe("ConsoleReporter", function() {
     });
 
     it("does not report a disabled spec", function() {
-      var reporter = new j$.ConsoleReporter({
+      var reporter = new jasmineUnderTest.ConsoleReporter({
         print: out.print,
         showColors: true
       });
@@ -243,7 +243,7 @@ describe("ConsoleReporter", function() {
     });
 
     it("reports a failing spec as an 'F'", function() {
-      var reporter = new j$.ConsoleReporter({
+      var reporter = new jasmineUnderTest.ConsoleReporter({
         print: out.print,
         showColors: true
       });
@@ -254,7 +254,7 @@ describe("ConsoleReporter", function() {
     });
 
     it("displays all afterAll exceptions", function() {
-        var reporter = new j$.ConsoleReporter({
+        var reporter = new jasmineUnderTest.ConsoleReporter({
           print: out.print,
           showColors: true
         });

spec/core/CallTrackerSpec.js

@@ -1,6 +1,6 @@
 describe("CallTracker", function() {
   it("tracks that it was called when executed", function() {
-    var callTracker = new j$.CallTracker();
+    var callTracker = new jasmineUnderTest.CallTracker();
 
     expect(callTracker.any()).toBe(false);
 
@@ -10,7 +10,7 @@ describe("CallTracker", function() {
   });
 
   it("tracks that number of times that it is executed", function() {
-    var callTracker = new j$.CallTracker();
+    var callTracker = new jasmineUnderTest.CallTracker();
 
     expect(callTracker.count()).toEqual(0);
 
@@ -20,7 +20,7 @@ describe("CallTracker", function() {
   });
 
   it("tracks the params from each execution", function() {
-    var callTracker = new j$.CallTracker();
+    var callTracker = new jasmineUnderTest.CallTracker();
 
     callTracker.track({object: void 0, args: []});
     callTracker.track({object: {}, args: [0, "foo"]});
@@ -31,13 +31,13 @@ describe("CallTracker", function() {
   });
 
   it("returns any empty array when there was no call", function() {
-    var callTracker = new j$.CallTracker();
+    var callTracker = new jasmineUnderTest.CallTracker();
 
     expect(callTracker.argsFor(0)).toEqual([]);
   });
 
   it("allows access for the arguments for all calls", function() {
-    var callTracker = new j$.CallTracker();
+    var callTracker = new jasmineUnderTest.CallTracker();
 
     callTracker.track({object: {}, args: []});
     callTracker.track({object: {}, args: [0, "foo"]});
@@ -46,7 +46,7 @@ describe("CallTracker", function() {
   });
 
   it("tracks the context and arguments for each call", function() {
-    var callTracker = new j$.CallTracker();
+    var callTracker = new jasmineUnderTest.CallTracker();
 
     callTracker.track({object: {}, args: []});
     callTracker.track({object: {}, args: [0, "foo"]});
@@ -57,7 +57,7 @@ describe("CallTracker", function() {
   });
 
   it("simplifies access to the arguments for the last (most recent) call", function() {
-    var callTracker = new j$.CallTracker();
+    var callTracker = new jasmineUnderTest.CallTracker();
 
     callTracker.track();
     callTracker.track({object: {}, args: [0, "foo"]});
@@ -69,13 +69,13 @@ describe("CallTracker", function() {
   });
 
   it("returns a useful falsy value when there isn't a last (most recent) call", function() {
-    var callTracker = new j$.CallTracker();
+    var callTracker = new jasmineUnderTest.CallTracker();
 
     expect(callTracker.mostRecent()).toBeFalsy();
   });
 
   it("simplifies access to the arguments for the first (oldest) call", function() {
-    var callTracker = new j$.CallTracker();
+    var callTracker = new jasmineUnderTest.CallTracker();
 
     callTracker.track({object: {}, args: [0, "foo"]});
 
@@ -83,14 +83,14 @@ describe("CallTracker", function() {
   });
 
   it("returns a useful falsy value when there isn't a first (oldest) call", function() {
-    var callTracker = new j$.CallTracker();
+    var callTracker = new jasmineUnderTest.CallTracker();
 
     expect(callTracker.first()).toBeFalsy();
   });
 
 
   it("allows the tracking to be reset", function() {
-    var callTracker = new j$.CallTracker();
+    var callTracker = new jasmineUnderTest.CallTracker();
 
     callTracker.track();
     callTracker.track({object: {}, args: [0, "foo"]});
@@ -102,4 +102,19 @@ describe("CallTracker", function() {
     expect(callTracker.all()).toEqual([]);
     expect(callTracker.mostRecent()).toBeFalsy();
   });
+
+  it("allows object arguments to be shallow cloned", function() {
+    var callTracker = new jasmineUnderTest.CallTracker();
+    callTracker.saveArgumentsByValue();
+
+    var objectArg = {"foo": "bar"},
+        arrayArg = ["foo", "bar"];
+
+    callTracker.track({object: {}, args: [objectArg, arrayArg, false, undefined, null, NaN, "", 0, 1.0]});
+
+    expect(callTracker.mostRecent().args[0]).not.toBe(objectArg);
+    expect(callTracker.mostRecent().args[0]).toEqual(objectArg);
+    expect(callTracker.mostRecent().args[1]).not.toBe(arrayArg);
+    expect(callTracker.mostRecent().args[1]).toEqual(arrayArg);
+  });
 });

spec/core/ClockSpec.js

@@ -6,7 +6,7 @@ describe("Clock", function() {
       delayedFunctionScheduler = jasmine.createSpyObj("delayedFunctionScheduler", ["scheduleFunction"]),
       delayedFn = jasmine.createSpy("delayedFn"),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
 
     fakeGlobal.setTimeout(delayedFn, 0);
 
@@ -28,7 +28,7 @@ describe("Clock", function() {
       delayedFunctionScheduler = jasmine.createSpyObj("delayedFunctionScheduler", ["removeFunctionWithId"]),
       delayedFn = jasmine.createSpy("delayedFn"),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
 
     fakeGlobal.clearTimeout("foo");
 
@@ -50,7 +50,7 @@ describe("Clock", function() {
       delayedFunctionScheduler = jasmine.createSpyObj("delayedFunctionScheduler", ["scheduleFunction"]),
       delayedFn = jasmine.createSpy("delayedFn"),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
 
     fakeGlobal.setInterval(delayedFn, 0);
 
@@ -72,7 +72,7 @@ describe("Clock", function() {
       delayedFunctionScheduler = jasmine.createSpyObj("delayedFunctionScheduler", ["removeFunctionWithId"]),
       delayedFn = jasmine.createSpy("delayedFn"),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
 
     fakeGlobal.clearInterval("foo");
 
@@ -94,7 +94,7 @@ describe("Clock", function() {
       fakeGlobal = { setTimeout: originalFakeSetTimeout },
       delayedFunctionSchedulerFactory = jasmine.createSpy('delayedFunctionSchedulerFactory'),
       mockDate = {},
-      clock = new j$.Clock(fakeGlobal, delayedFunctionSchedulerFactory, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, delayedFunctionSchedulerFactory, mockDate);
 
     fakeGlobal.setTimeout = replacedSetTimeout;
 
@@ -112,7 +112,7 @@ describe("Clock", function() {
       fakeGlobal = { clearTimeout: originalFakeClearTimeout },
       delayedFunctionSchedulerFactory = jasmine.createSpy('delayedFunctionSchedulerFactory'),
       mockDate = {},
-      clock = new j$.Clock(fakeGlobal, delayedFunctionSchedulerFactory, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, delayedFunctionSchedulerFactory, mockDate);
 
     fakeGlobal.clearTimeout = replacedClearTimeout;
 
@@ -130,7 +130,7 @@ describe("Clock", function() {
       fakeGlobal = { setInterval: originalFakeSetInterval },
       delayedFunctionSchedulerFactory = jasmine.createSpy('delayedFunctionSchedulerFactory'),
       mockDate = {},
-      clock = new j$.Clock(fakeGlobal, delayedFunctionSchedulerFactory, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, delayedFunctionSchedulerFactory, mockDate);
 
     fakeGlobal.setInterval = replacedSetInterval;
 
@@ -148,7 +148,7 @@ describe("Clock", function() {
       fakeGlobal = { clearInterval: originalFakeClearInterval },
       delayedFunctionSchedulerFactory = jasmine.createSpy('delayedFunctionSchedulerFactory'),
       mockDate = {},
-      clock = new j$.Clock(fakeGlobal, delayedFunctionSchedulerFactory, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, delayedFunctionSchedulerFactory, mockDate);
 
     fakeGlobal.clearInterval = replacedClearInterval;
 
@@ -174,7 +174,7 @@ describe("Clock", function() {
       delayedFunctionScheduler = jasmine.createSpyObj("delayedFunctionScheduler", ["scheduleFunction", "reset"]),
       delayedFn = jasmine.createSpy("delayedFn"),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
 
     clock.install();
     clock.uninstall();
@@ -204,7 +204,7 @@ describe("Clock", function() {
       delayedFunctionScheduler = jasmine.createSpyObj("delayedFunctionScheduler", ["scheduleFunction", "reset", "removeFunctionWithId"]),
       delayedFn = jasmine.createSpy("delayedFn"),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
       passedFunctionCalled = false;
 
     clock.withMock(function() {
@@ -251,7 +251,7 @@ describe("Clock", function() {
       delayedFunctionScheduler = jasmine.createSpyObj("delayedFunctionScheduler", ["scheduleFunction", "reset", "removeFunctionWithId"]),
       delayedFn = jasmine.createSpy("delayedFn"),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
       passedFunctionCalled = false;
 
     expect(function() {
@@ -294,7 +294,7 @@ describe("Clock", function() {
       fakeGlobal = { setTimeout: fakeSetTimeout },
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
 
     clock.install();
     clock.setTimeout(delayedFn, 0, 'a', 'b');
@@ -311,7 +311,7 @@ describe("Clock", function() {
       fakeGlobal = { setTimeout: fakeSetTimeout },
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
       timeoutId;
 
     clock.install();
@@ -326,7 +326,7 @@ describe("Clock", function() {
       fakeGlobal = { setTimeout: fakeClearTimeout },
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
 
     clock.install();
     clock.clearTimeout(123);
@@ -342,7 +342,7 @@ describe("Clock", function() {
       fakeGlobal = { setInterval: fakeSetInterval },
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
 
     clock.install();
     clock.setInterval(delayedFn, 0, 'a', 'b');
@@ -359,7 +359,7 @@ describe("Clock", function() {
       fakeGlobal = { setInterval: fakeSetInterval },
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
       intervalId;
 
     clock.install();
@@ -374,7 +374,7 @@ describe("Clock", function() {
       fakeGlobal = { setInterval: clearInterval },
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
 
     clock.install();
     clock.clearInterval(123);
@@ -384,7 +384,7 @@ describe("Clock", function() {
   });
 
   it("gives you a friendly reminder if the Clock is not installed and you tick", function() {
-    var clock = new j$.Clock({}, jasmine.createSpyObj('delayedFunctionScheduler', ['tick']));
+    var clock = new jasmineUnderTest.Clock({}, jasmine.createSpyObj('delayedFunctionScheduler', ['tick']));
     expect(function() {
       clock.tick(50);
     }).toThrow();
@@ -401,7 +401,7 @@ describe("Clock", function() {
         setInterval: fakeSetInterval
       },
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
 
     fakeSetTimeout.apply = null;
     fakeSetInterval.apply = null;
@@ -428,9 +428,9 @@ describe("Clock (acceptance)", function() {
       delayedFn2 = jasmine.createSpy('delayedFn2'),
       delayedFn3 = jasmine.createSpy('delayedFn3'),
       recurring1 = jasmine.createSpy('recurring1'),
-      delayedFunctionScheduler = new j$.DelayedFunctionScheduler(),
+      delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock({setTimeout: setTimeout}, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock({setTimeout: setTimeout}, function () { return delayedFunctionScheduler; }, mockDate);
 
     clock.install();
 
@@ -475,9 +475,9 @@ describe("Clock (acceptance)", function() {
 
   it("can clear a previously set timeout", function() {
     var clearedFn = jasmine.createSpy('clearedFn'),
-      delayedFunctionScheduler = new j$.DelayedFunctionScheduler(),
+      delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock({setTimeout: function() {}}, function () { return delayedFunctionScheduler; }, mockDate),
+      clock = new jasmineUnderTest.Clock({setTimeout: function() {}}, function () { return delayedFunctionScheduler; }, mockDate),
       timeoutId;
 
     clock.install();
@@ -493,9 +493,9 @@ describe("Clock (acceptance)", function() {
 
   it("can clear a previously set interval using that interval's handler", function() {
     var spy = jasmine.createSpy('spy'),
-      delayedFunctionScheduler = new j$.DelayedFunctionScheduler(),
+      delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock({setInterval: function() {}}, function () { return delayedFunctionScheduler; }, mockDate),
+      clock = new jasmineUnderTest.Clock({setInterval: function() {}}, function () { return delayedFunctionScheduler; }, mockDate),
       intervalId;
 
     clock.install();
@@ -511,9 +511,9 @@ describe("Clock (acceptance)", function() {
 
   it("correctly schedules functions after the Clock has advanced", function() {
     var delayedFn1 = jasmine.createSpy('delayedFn1'),
-      delayedFunctionScheduler = new j$.DelayedFunctionScheduler(),
+      delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new j$.Clock({setTimeout: function() {}}, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock({setTimeout: function() {}}, function () { return delayedFunctionScheduler; }, mockDate);
 
     clock.install();
 
@@ -528,9 +528,9 @@ describe("Clock (acceptance)", function() {
   it("correctly schedules functions while the Clock is advancing", function() {
     var delayedFn1 = jasmine.createSpy('delayedFn1'),
         delayedFn2 = jasmine.createSpy('delayedFn2'),
-        delayedFunctionScheduler = new j$.DelayedFunctionScheduler(),
+        delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
         mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-        clock = new j$.Clock({setTimeout: function() {}}, function () { return delayedFunctionScheduler; }, mockDate);
+        clock = new jasmineUnderTest.Clock({setTimeout: function() {}}, function () { return delayedFunctionScheduler; }, mockDate);
 
     delayedFn1.and.callFake(function() { clock.setTimeout(delayedFn2, 0); });
     clock.install();
@@ -547,9 +547,9 @@ describe("Clock (acceptance)", function() {
   it("correctly calls functions scheduled while the Clock is advancing", function() {
     var delayedFn1 = jasmine.createSpy('delayedFn1'),
         delayedFn2 = jasmine.createSpy('delayedFn2'),
-        delayedFunctionScheduler = new j$.DelayedFunctionScheduler(),
+        delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
         mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-        clock = new j$.Clock({setTimeout: function() {}}, function () { return delayedFunctionScheduler; }, mockDate);
+        clock = new jasmineUnderTest.Clock({setTimeout: function() {}}, function () { return delayedFunctionScheduler; }, mockDate);
 
     delayedFn1.and.callFake(function() { clock.setTimeout(delayedFn2, 1); });
     clock.install();
@@ -563,9 +563,9 @@ describe("Clock (acceptance)", function() {
   it("correctly schedules functions scheduled while the Clock is advancing but after the Clock is uninstalled", function() {
     var delayedFn1 = jasmine.createSpy('delayedFn1'),
         delayedFn2 = jasmine.createSpy('delayedFn2'),
-        delayedFunctionScheduler = new j$.DelayedFunctionScheduler(),
+        delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
         mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-        clock = new j$.Clock({setTimeout: function() {}}, function () { return delayedFunctionScheduler; }, mockDate);
+        clock = new jasmineUnderTest.Clock({setTimeout: function() {}}, function () { return delayedFunctionScheduler; }, mockDate);
 
     delayedFn1.and.callFake(function() {
       clock.uninstall();
@@ -585,10 +585,10 @@ describe("Clock (acceptance)", function() {
   });
 
   it("does not mock the Date object by default", function() {
-     var delayedFunctionScheduler = new j$.DelayedFunctionScheduler(),
+     var delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       global = {Date: Date},
-      mockDate = new j$.MockDate(global),
-      clock = new j$.Clock({setTimeout: setTimeout}, function () { return delayedFunctionScheduler; }, mockDate);
+      mockDate = new jasmineUnderTest.MockDate(global),
+      clock = new jasmineUnderTest.Clock({setTimeout: setTimeout}, function () { return delayedFunctionScheduler; }, mockDate);
 
     clock.install();
 
@@ -602,10 +602,10 @@ describe("Clock (acceptance)", function() {
   });
 
   it("mocks the Date object and sets it to current time", function() {
-    var delayedFunctionScheduler = new j$.DelayedFunctionScheduler(),
+    var delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       global = {Date: Date},
-      mockDate = new j$.MockDate(global),
-      clock = new j$.Clock({setTimeout: setTimeout}, function () { return delayedFunctionScheduler; }, mockDate);
+      mockDate = new jasmineUnderTest.MockDate(global),
+      clock = new jasmineUnderTest.Clock({setTimeout: setTimeout}, function () { return delayedFunctionScheduler; }, mockDate);
 
     clock.install().mockDate();
 
@@ -626,10 +626,10 @@ describe("Clock (acceptance)", function() {
   });
 
   it("mocks the Date object and sets it to a given time", function() {
-    var delayedFunctionScheduler = new j$.DelayedFunctionScheduler(),
+    var delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       global = {Date: Date},
-      mockDate = new j$.MockDate(global),
-      clock = new j$.Clock({setTimeout: setTimeout}, function () { return delayedFunctionScheduler; }, mockDate),
+      mockDate = new jasmineUnderTest.MockDate(global),
+      clock = new jasmineUnderTest.Clock({setTimeout: setTimeout}, function () { return delayedFunctionScheduler; }, mockDate),
       baseTime = new Date(2013, 9, 23);
 
 
@@ -652,4 +652,31 @@ describe("Clock (acceptance)", function() {
 
     expect(timeoutDate).toEqual(baseTime.getTime() + 150);
   });
+
+  it("mocks the Date object and updates the date per delayed function", function () {
+    var delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
+      global = {Date: Date},
+      mockDate = new jasmineUnderTest.MockDate(global),
+      clock = new jasmineUnderTest.Clock({setTimeout: setTimeout}, function () { return delayedFunctionScheduler; }, mockDate),
+      baseTime = new Date();
+
+    clock.install().mockDate(baseTime);
+
+    var actualTimes = [];
+    var pushCurrentTime = function() { actualTimes.push(global.Date().getTime()); };
+    delayedFunctionScheduler.scheduleFunction(pushCurrentTime);
+    delayedFunctionScheduler.scheduleFunction(pushCurrentTime, 1);
+    delayedFunctionScheduler.scheduleFunction(pushCurrentTime, 3);
+
+    clock.tick(1);
+    expect(global.Date().getTime()).toEqual(baseTime.getTime() + 1);
+
+    clock.tick(3);
+    expect(global.Date().getTime()).toEqual(baseTime.getTime() + 4);
+
+    clock.tick(1);
+    expect(global.Date().getTime()).toEqual(baseTime.getTime() + 5);
+
+    expect(actualTimes).toEqual([baseTime.getTime(), baseTime.getTime() + 1, baseTime.getTime() + 3]);
+  })
 });

spec/core/DelayedFunctionSchedulerSpec.js

@@ -1,6 +1,6 @@
 describe("DelayedFunctionScheduler", function() {
   it("schedules a function for later execution", function() {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn');
 
     scheduler.scheduleFunction(fn, 0);
@@ -13,7 +13,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("schedules a string for later execution", function() {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       strfn = "horrible = true;";
 
     scheduler.scheduleFunction(strfn, 0);
@@ -24,7 +24,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("#tick defaults to 0", function() {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn');
 
     scheduler.scheduleFunction(fn, 0);
@@ -37,7 +37,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("defaults delay to 0", function() {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn');
 
     scheduler.scheduleFunction(fn);
@@ -50,7 +50,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("optionally passes params to scheduled functions", function() {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn');
 
     scheduler.scheduleFunction(fn, 0, ['foo', 'bar']);
@@ -63,7 +63,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("scheduled fns can optionally reoccur", function() {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn');
 
     scheduler.scheduleFunction(fn, 20, [], true);
@@ -85,7 +85,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("increments scheduled fns ids unless one is passed", function() {
-    var scheduler = new j$.DelayedFunctionScheduler();
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler();
 
     expect(scheduler.scheduleFunction(function() {
     }, 0)).toBe(1);
@@ -98,7 +98,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("#removeFunctionWithId removes a previously scheduled function with a given id", function() {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       timeoutKey;
 
@@ -114,7 +114,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("executes recurring functions interleaved with regular functions in the correct order", function() {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       recurringCallCount = 0,
       recurring = jasmine.createSpy('recurring').and.callFake(function() {
@@ -135,7 +135,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("schedules a function for later execution during a tick", function () {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       fnDelay = 10;
 
@@ -151,7 +151,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("#removeFunctionWithId removes a previously scheduled function with a given id during a tick", function () {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       fnDelay = 10,
       timeoutKey;
@@ -169,7 +169,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("executes recurring functions interleaved with regular functions and functions scheduled during a tick in the correct order", function () {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       recurringCallCount = 0,
       recurring = jasmine.createSpy('recurring').and.callFake(function() {
@@ -202,7 +202,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("executes recurring functions after rescheduling them", function () {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       recurring = function() {
         expect(scheduler.scheduleFunction).toHaveBeenCalled();
       };
@@ -215,7 +215,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("removes functions during a tick that runs the function", function() {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       fnDelay = 10,
       timeoutKey;
@@ -234,7 +234,7 @@ describe("DelayedFunctionScheduler", function() {
   });
 
   it("removes functions during the first tick that runs the function", function() {
-    var scheduler = new j$.DelayedFunctionScheduler(),
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       fnDelay = 10,
       timeoutKey;
@@ -251,5 +251,18 @@ describe("DelayedFunctionScheduler", function() {
     expect(fn).toHaveBeenCalled();
     expect(fn.calls.count()).toBe(1);
   });
+
+  it("updates the mockDate per scheduled time", function () {
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
+      tickDate = jasmine.createSpy('tickDate');
+
+      scheduler.scheduleFunction(function() {});
+      scheduler.scheduleFunction(function() {}, 1);
+
+      scheduler.tick(1, tickDate);
+
+      expect(tickDate).toHaveBeenCalledWith(0);
+      expect(tickDate).toHaveBeenCalledWith(1);
+  })
 });
 

spec/core/EnvSpec.js

@@ -2,20 +2,20 @@
 describe("Env", function() {
   var env;
   beforeEach(function() {
-    env = new j$.Env();
+    env = new jasmineUnderTest.Env();
   });
 
   describe("#pending", function() {
     it("throws the Pending Spec exception", function() {
       expect(function() {
         env.pending();
-      }).toThrow(j$.Spec.pendingSpecExceptionMessage);
+      }).toThrow(jasmineUnderTest.Spec.pendingSpecExceptionMessage);
     });
 
     it("throws the Pending Spec exception with a custom message", function() {
       expect(function() {
         env.pending('custom message');
-      }).toThrow(j$.Spec.pendingSpecExceptionMessage + 'custom message');
+      }).toThrow(jasmineUnderTest.Spec.pendingSpecExceptionMessage + 'custom message');
     });
   });
 
@@ -31,16 +31,16 @@ describe("Env", function() {
     it("throws the error", function() {
       expect(function() {
         env.describe('done method', spec);
-      }).toThrow(new Error('describe does not expect a done parameter'));
+      }).toThrow(new Error('describe does not expect any arguments'));
     });
   });
 
   it('can configure specs to throw errors on expectation failures', function() {
     env.throwOnExpectationFailure(true);
 
-    spyOn(j$, 'Spec');
+    spyOn(jasmineUnderTest, 'Spec');
     env.it('foo', function() {});
-    expect(j$.Spec).toHaveBeenCalledWith(jasmine.objectContaining({
+    expect(jasmineUnderTest.Spec).toHaveBeenCalledWith(jasmine.objectContaining({
       throwOnExpectationFailure: true
     }));
   });
@@ -48,9 +48,9 @@ describe("Env", function() {
   it('can configure suites to throw errors on expectation failures', function() {
     env.throwOnExpectationFailure(true);
 
-    spyOn(j$, 'Suite');
+    spyOn(jasmineUnderTest, 'Suite');
     env.describe('foo', function() {});
-    expect(j$.Suite).toHaveBeenCalledWith(jasmine.objectContaining({
+    expect(jasmineUnderTest.Suite).toHaveBeenCalledWith(jasmine.objectContaining({
       throwOnExpectationFailure: true
     }));
   });

spec/core/ExceptionFormatterSpec.js

@@ -7,7 +7,7 @@ describe("ExceptionFormatter", function() {
           message: 'you got your foo in my bar',
           name: 'A Classic Mistake'
         },
-        exceptionFormatter = new j$.ExceptionFormatter(),
+        exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
         message = exceptionFormatter.message(sampleFirefoxException);
 
       expect(message).toEqual('A Classic Mistake: you got your foo in my bar in foo.js (line 1978)');
@@ -20,7 +20,7 @@ describe("ExceptionFormatter", function() {
           message: 'you got your foo in my bar',
           name: 'A Classic Mistake'
         },
-        exceptionFormatter = new j$.ExceptionFormatter(),
+        exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
         message = exceptionFormatter.message(sampleWebkitException);
 
       expect(message).toEqual('A Classic Mistake: you got your foo in my bar in foo.js (line 1978)');
@@ -31,7 +31,7 @@ describe("ExceptionFormatter", function() {
           message: 'you got your foo in my bar',
           name: 'A Classic Mistake'
         },
-        exceptionFormatter = new j$.ExceptionFormatter(),
+        exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
         message = exceptionFormatter.message(sampleV8);
 
       expect(message).toEqual('A Classic Mistake: you got your foo in my bar');
@@ -39,7 +39,7 @@ describe("ExceptionFormatter", function() {
 
     it("formats thrown exceptions that aren't errors", function() {
       var thrown = "crazy error",
-          exceptionFormatter = new j$.ExceptionFormatter(),
+          exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
           message = exceptionFormatter.message(thrown);
 
       expect(message).toEqual("crazy error thrown");
@@ -53,11 +53,11 @@ describe("ExceptionFormatter", function() {
       var error;
       try { throw new Error("an error") } catch(e) { error = e; }
 
-      expect(new j$.ExceptionFormatter().stack(error)).toMatch(/ExceptionFormatterSpec\.js.*\d+/)
+      expect(new jasmineUnderTest.ExceptionFormatter().stack(error)).toMatch(/ExceptionFormatterSpec\.js.*\d+/)
     });
 
     it("returns null if no Error provided", function() {
-      expect(new j$.ExceptionFormatter().stack()).toBeNull();
+      expect(new jasmineUnderTest.ExceptionFormatter().stack()).toBeNull();
     });
   });
 });

spec/core/ExceptionsSpec.js

@@ -2,7 +2,7 @@ describe('Exceptions:', function() {
   var env;
 
   beforeEach(function() {
-    env = new j$.Env();
+    env = new jasmineUnderTest.Env();
   });
 
   describe('with break on exception', function() {

spec/core/ExpectationResultSpec.js

@@ -1,16 +1,16 @@
 describe("buildExpectationResult", function() {
   it("defaults to passed", function() {
-    var result = j$.buildExpectationResult({passed: 'some-value'});
+    var result = jasmineUnderTest.buildExpectationResult({passed: 'some-value'});
     expect(result.passed).toBe('some-value');
   });
 
   it("message defaults to Passed for passing specs", function() {
-    var result = j$.buildExpectationResult({passed: true, message: 'some-value'});
+    var result = jasmineUnderTest.buildExpectationResult({passed: true, message: 'some-value'});
     expect(result.message).toBe('Passed.');
   });
 
   it("message returns the message for failing expectations", function() {
-    var result = j$.buildExpectationResult({passed: false, message: 'some-value'});
+    var result = jasmineUnderTest.buildExpectationResult({passed: false, message: 'some-value'});
     expect(result.message).toBe('some-value');
   });
 
@@ -18,7 +18,7 @@ describe("buildExpectationResult", function() {
     var fakeError = {message: 'foo'},
       messageFormatter = jasmine.createSpy("exception message formatter").and.returnValue(fakeError.message);
 
-    var result = j$.buildExpectationResult(
+    var result = jasmineUnderTest.buildExpectationResult(
       {
         passed: false,
         error: fakeError,
@@ -33,7 +33,7 @@ describe("buildExpectationResult", function() {
     var fakeError = {stack: 'foo'},
       stackFormatter = jasmine.createSpy("stack formatter").and.returnValue(fakeError.stack);
 
-    var result = j$.buildExpectationResult(
+    var result = jasmineUnderTest.buildExpectationResult(
       {
         passed: false,
         error: fakeError,
@@ -45,17 +45,17 @@ describe("buildExpectationResult", function() {
   });
 
   it("matcherName returns passed matcherName", function() {
-    var result = j$.buildExpectationResult({matcherName: 'some-value'});
+    var result = jasmineUnderTest.buildExpectationResult({matcherName: 'some-value'});
     expect(result.matcherName).toBe('some-value');
   });
 
   it("expected returns passed expected", function() {
-    var result = j$.buildExpectationResult({expected: 'some-value'});
+    var result = jasmineUnderTest.buildExpectationResult({expected: 'some-value'});
     expect(result.expected).toBe('some-value');
   });
 
   it("actual returns passed actual", function() {
-    var result = j$.buildExpectationResult({actual: 'some-value'});
+    var result = jasmineUnderTest.buildExpectationResult({actual: 'some-value'});
     expect(result.actual).toBe('some-value');
   });
 });

spec/core/ExpectationSpec.js

@@ -6,7 +6,7 @@ describe("Expectation", function() {
       },
       expectation;
 
-    expectation = new j$.Expectation({
+    expectation = new jasmineUnderTest.Expectation({
       customMatchers: matchers
     });
 
@@ -20,18 +20,18 @@ describe("Expectation", function() {
       },
       expectation;
 
-    j$.Expectation.addCoreMatchers(coreMatchers);
+    jasmineUnderTest.Expectation.addCoreMatchers(coreMatchers);
 
-    expectation = new j$.Expectation({});
+    expectation = new jasmineUnderTest.Expectation({});
 
     expect(expectation.toQuux).toBeDefined();
   });
 
   it("Factory builds an expectation/negative expectation", function() {
-    var builtExpectation = j$.Expectation.Factory();
+    var builtExpectation = jasmineUnderTest.Expectation.Factory();
 
-    expect(builtExpectation instanceof j$.Expectation).toBe(true);
-    expect(builtExpectation.not instanceof j$.Expectation).toBe(true);
+    expect(builtExpectation instanceof jasmineUnderTest.Expectation).toBe(true);
+    expect(builtExpectation.not instanceof jasmineUnderTest.Expectation).toBe(true);
     expect(builtExpectation.not.isNot).toBe(true);
   });
 
@@ -46,7 +46,7 @@ describe("Expectation", function() {
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       expectation;
 
-    expectation = new j$.Expectation({
+    expectation = new jasmineUnderTest.Expectation({
       util: util,
       customMatchers: matchers,
       customEqualityTesters: customEqualityTesters,
@@ -74,7 +74,7 @@ describe("Expectation", function() {
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       expectation;
 
-    expectation = new j$.Expectation({
+    expectation = new jasmineUnderTest.Expectation({
       util: util,
       customMatchers: matchers,
       actual: "an actual",
@@ -100,7 +100,7 @@ describe("Expectation", function() {
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       expectation;
 
-    expectation = new j$.Expectation({
+    expectation = new jasmineUnderTest.Expectation({
       customMatchers: matchers,
       util: util,
       actual: "an actual",
@@ -132,7 +132,7 @@ describe("Expectation", function() {
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       expectation;
 
-    expectation = new j$.Expectation({
+    expectation = new jasmineUnderTest.Expectation({
       customMatchers: matchers,
       util: util,
       actual: "an actual",
@@ -166,7 +166,7 @@ describe("Expectation", function() {
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       expectation;
 
-    expectation = new j$.Expectation({
+    expectation = new jasmineUnderTest.Expectation({
       actual: "an actual",
       customMatchers: matchers,
       addExpectationResult: addExpectationResult
@@ -199,7 +199,7 @@ describe("Expectation", function() {
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       expectation;
 
-    expectation = new j$.Expectation({
+    expectation = new jasmineUnderTest.Expectation({
       customMatchers: matchers,
       actual: "an actual",
       addExpectationResult: addExpectationResult
@@ -231,7 +231,7 @@ describe("Expectation", function() {
       actual = "an actual",
       expectation;
 
-    expectation = new j$.Expectation({
+    expectation = new jasmineUnderTest.Expectation({
       customMatchers: matchers,
       actual: "an actual",
       addExpectationResult: addExpectationResult,
@@ -264,7 +264,7 @@ describe("Expectation", function() {
       actual = "an actual",
       expectation;
 
-    expectation = new j$.Expectation({
+    expectation = new jasmineUnderTest.Expectation({
       customMatchers: matchers,
       actual: "an actual",
       util: util,
@@ -300,7 +300,7 @@ describe("Expectation", function() {
       actual = "an actual",
       expectation;
 
-    expectation = new j$.Expectation({
+    expectation = new jasmineUnderTest.Expectation({
       customMatchers: matchers,
       actual: "an actual",
       addExpectationResult: addExpectationResult,
@@ -331,7 +331,7 @@ describe("Expectation", function() {
       actual = "an actual",
       expectation;
 
-    expectation = new j$.Expectation({
+    expectation = new jasmineUnderTest.Expectation({
       customMatchers: matchers,
       actual: "an actual",
       addExpectationResult: addExpectationResult,
@@ -367,7 +367,7 @@ describe("Expectation", function() {
       actual = "an actual",
       expectation;
 
-    expectation = new j$.Expectation({
+    expectation = new jasmineUnderTest.Expectation({
       customMatchers: matchers,
       actual: "an actual",
       addExpectationResult: addExpectationResult,

spec/core/JsApiReporterSpec.js

@@ -5,7 +5,7 @@ xdescribe('JsApiReporter (integration specs)', function() {
     var suite, nestedSuite, nestedSpec;
 
     beforeEach(function() {
-      env = new j$.Env();
+      env = new jasmineUnderTest.Env();
 
       suite = env.describe("top-level suite", function() {
         spec1 = env.it("spec 1", function() {
@@ -25,7 +25,7 @@ xdescribe('JsApiReporter (integration specs)', function() {
 
       });
 
-      reporter = new j$.JsApiReporter({});
+      reporter = new jasmineUnderTest.JsApiReporter({});
       env.addReporter(reporter);
 
       env.execute();
@@ -82,7 +82,7 @@ xdescribe('JsApiReporter (integration specs)', function() {
 describe("JsApiReporter", function() {
 
   it("knows when a full environment is started", function() {
-    var reporter = new j$.JsApiReporter({});
+    var reporter = new jasmineUnderTest.JsApiReporter({});
 
     expect(reporter.started).toBe(false);
     expect(reporter.finished).toBe(false);
@@ -94,7 +94,7 @@ describe("JsApiReporter", function() {
   });
 
   it("knows when a full environment is done", function() {
-    var reporter = new j$.JsApiReporter({});
+    var reporter = new jasmineUnderTest.JsApiReporter({});
 
     expect(reporter.started).toBe(false);
     expect(reporter.finished).toBe(false);
@@ -106,13 +106,13 @@ describe("JsApiReporter", function() {
   });
 
   it("defaults to 'loaded' status", function() {
-    var reporter = new j$.JsApiReporter({});
+    var reporter = new jasmineUnderTest.JsApiReporter({});
 
     expect(reporter.status()).toEqual('loaded');
   });
 
   it("reports 'started' when Jasmine has started", function() {
-    var reporter = new j$.JsApiReporter({});
+    var reporter = new jasmineUnderTest.JsApiReporter({});
 
     reporter.jasmineStarted();
 
@@ -120,7 +120,7 @@ describe("JsApiReporter", function() {
   });
 
   it("reports 'done' when Jasmine is done", function() {
-    var reporter = new j$.JsApiReporter({});
+    var reporter = new jasmineUnderTest.JsApiReporter({});
 
     reporter.jasmineDone({});
 
@@ -128,7 +128,7 @@ describe("JsApiReporter", function() {
   });
 
   it("tracks a suite", function() {
-    var reporter = new j$.JsApiReporter({});
+    var reporter = new jasmineUnderTest.JsApiReporter({});
 
     reporter.suiteStarted({
       id: 123,
@@ -151,7 +151,7 @@ describe("JsApiReporter", function() {
   describe("#specResults", function() {
     var reporter, specResult1, specResult2;
     beforeEach(function() {
-      reporter = new j$.JsApiReporter({});
+      reporter = new jasmineUnderTest.JsApiReporter({});
       specResult1 = {
         id: 1,
         description: "A spec"
@@ -181,7 +181,7 @@ describe("JsApiReporter", function() {
   describe("#suiteResults", function(){
     var reporter, suiteResult1, suiteResult2;
     beforeEach(function() {
-      reporter = new j$.JsApiReporter({});
+      reporter = new jasmineUnderTest.JsApiReporter({});
       suiteStarted1 = {
         id: 1
       };
@@ -218,7 +218,7 @@ describe("JsApiReporter", function() {
   describe("#executionTime", function() {
     it("should start the timer when jasmine starts", function() {
       var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
-          reporter = new j$.JsApiReporter({
+          reporter = new jasmineUnderTest.JsApiReporter({
             timer: timerSpy
           });
 
@@ -228,7 +228,7 @@ describe("JsApiReporter", function() {
 
     it("should return the time it took the specs to run, in ms", function() {
       var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
-          reporter = new j$.JsApiReporter({
+          reporter = new jasmineUnderTest.JsApiReporter({
             timer: timerSpy
           });
 
@@ -240,7 +240,7 @@ describe("JsApiReporter", function() {
     describe("when the specs haven't finished being run", function() {
       it("should return undefined", function() {
         var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
-            reporter = new j$.JsApiReporter({
+            reporter = new jasmineUnderTest.JsApiReporter({
               timer: timerSpy
             });
 
@@ -251,7 +251,7 @@ describe("JsApiReporter", function() {
 
   describe('#runDetails', function() {
     it('should have details about the run', function() {
-      var reporter = new j$.JsApiReporter({});
+      var reporter = new jasmineUnderTest.JsApiReporter({});
       reporter.jasmineDone({some: {run: 'details'}});
       expect(reporter.runDetails).toEqual({some: {run: 'details'}});
     });

spec/core/MockDateSpec.js

@@ -1,7 +1,7 @@
 describe("FakeDate", function() {
   it("does not fail if no global date is found", function() {
     var fakeGlobal = {},
-      mockDate = new j$.MockDate(fakeGlobal);
+      mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     expect(function() {
       mockDate.install();
@@ -17,7 +17,7 @@ describe("FakeDate", function() {
         }
       }),
       fakeGlobal = { Date: globalDate },
-      mockDate = new j$.MockDate(fakeGlobal);
+      mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     expect(fakeGlobal.Date).toEqual(globalDate);
     mockDate.install();
@@ -32,7 +32,7 @@ describe("FakeDate", function() {
         }
       }),
       fakeGlobal = { Date: globalDate },
-      mockDate = new j$.MockDate(fakeGlobal);
+      mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     mockDate.install();
     mockDate.uninstall();
@@ -49,7 +49,7 @@ describe("FakeDate", function() {
         }
       }),
       fakeGlobal = { Date: globalDate },
-      mockDate = new j$.MockDate(fakeGlobal);
+      mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     mockDate.install();
 
@@ -60,7 +60,7 @@ describe("FakeDate", function() {
 
   it("can accept a date as time base when installing", function() {
     var fakeGlobal = { Date: Date },
-      mockDate = new j$.MockDate(fakeGlobal),
+      mockDate = new jasmineUnderTest.MockDate(fakeGlobal),
       baseDate = new Date();
 
     spyOn(baseDate, 'getTime').and.returnValue(123);
@@ -71,7 +71,7 @@ describe("FakeDate", function() {
 
   it("makes real dates", function() {
     var fakeGlobal = { Date: Date },
-      mockDate = new j$.MockDate(fakeGlobal);
+      mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     mockDate.install();
     expect(new fakeGlobal.Date()).toEqual(jasmine.any(Date));
@@ -89,7 +89,7 @@ describe("FakeDate", function() {
       fakeGlobal = { Date: globalDate };
 
     globalDate.now = function() {};
-    var mockDate = new j$.MockDate(fakeGlobal);
+    var mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     mockDate.install();
 
@@ -105,7 +105,7 @@ describe("FakeDate", function() {
         }
       }),
       fakeGlobal = { Date: globalDate },
-      mockDate = new j$.MockDate(fakeGlobal);
+      mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     mockDate.install();
 
@@ -123,7 +123,7 @@ describe("FakeDate", function() {
       fakeGlobal = { Date: globalDate };
 
     globalDate.now = function() {};
-    var mockDate = new j$.MockDate(fakeGlobal);
+    var mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     mockDate.install();
 
@@ -147,7 +147,7 @@ describe("FakeDate", function() {
       fakeGlobal = { Date: globalDate };
 
     globalDate.now = function() {};
-    var mockDate = new j$.MockDate(fakeGlobal);
+    var mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     mockDate.install();
 
@@ -160,7 +160,7 @@ describe("FakeDate", function() {
 
   it("allows creation of a Date in a different time than the mocked time", function() {
     var fakeGlobal = { Date: Date },
-      mockDate = new j$.MockDate(fakeGlobal);
+      mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     mockDate.install();
 
@@ -170,7 +170,7 @@ describe("FakeDate", function() {
 
   it("allows creation of a Date that isn't fully specified", function() {
     var fakeGlobal = { Date: Date },
-      mockDate = new j$.MockDate(fakeGlobal);
+      mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     mockDate.install();
 
@@ -180,7 +180,7 @@ describe("FakeDate", function() {
 
   it('allows creation of a Date with millis', function() {
     var fakeGlobal = { Date: Date },
-      mockDate = new j$.MockDate(fakeGlobal),
+      mockDate = new jasmineUnderTest.MockDate(fakeGlobal),
       now = new Date(2014, 3, 15).getTime();
 
     mockDate.install();
@@ -191,7 +191,7 @@ describe("FakeDate", function() {
 
   it("copies all Date properties to the mocked date", function() {
     var fakeGlobal = { Date: Date },
-      mockDate = new j$.MockDate(fakeGlobal);
+      mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     mockDate.install();
 

spec/core/PrettyPrintSpec.js

@@ -1,34 +1,34 @@
-describe("j$.pp", function () {
+describe("jasmineUnderTest.pp", function () {
   it("should wrap strings in single quotes", function() {
-    expect(j$.pp("some string")).toEqual("'some string'");
-    expect(j$.pp("som' string")).toEqual("'som' string'");
+    expect(jasmineUnderTest.pp("some string")).toEqual("'some string'");
+    expect(jasmineUnderTest.pp("som' string")).toEqual("'som' string'");
   });
 
   it("should stringify primitives properly", function() {
-    expect(j$.pp(true)).toEqual("true");
-    expect(j$.pp(false)).toEqual("false");
-    expect(j$.pp(null)).toEqual("null");
-    expect(j$.pp(jasmine.undefined)).toEqual("undefined");
-    expect(j$.pp(3)).toEqual("3");
-    expect(j$.pp(-3.14)).toEqual("-3.14");
-    expect(j$.pp(-0)).toEqual("-0");
+    expect(jasmineUnderTest.pp(true)).toEqual("true");
+    expect(jasmineUnderTest.pp(false)).toEqual("false");
+    expect(jasmineUnderTest.pp(null)).toEqual("null");
+    expect(jasmineUnderTest.pp(jasmine.undefined)).toEqual("undefined");
+    expect(jasmineUnderTest.pp(3)).toEqual("3");
+    expect(jasmineUnderTest.pp(-3.14)).toEqual("-3.14");
+    expect(jasmineUnderTest.pp(-0)).toEqual("-0");
   });
 
   describe('stringify arrays', function() {
     it("should stringify arrays properly", function() {
-      expect(j$.pp([1, 2])).toEqual("[ 1, 2 ]");
-      expect(j$.pp([1, 'foo', {}, jasmine.undefined, null])).toEqual("[ 1, 'foo', Object({  }), undefined, null ]");
+      expect(jasmineUnderTest.pp([1, 2])).toEqual("[ 1, 2 ]");
+      expect(jasmineUnderTest.pp([1, 'foo', {}, jasmine.undefined, null])).toEqual("[ 1, 'foo', Object({  }), undefined, null ]");
     });
 
-    it("should truncate arrays that are longer than j$.MAX_PRETTY_PRINT_ARRAY_LENGTH", function() {
-      var originalMaxLength = j$.MAX_PRETTY_PRINT_ARRAY_LENGTH;
+    it("should truncate arrays that are longer than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH", function() {
+      var originalMaxLength = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
       var array = [1, 2, 3];
 
       try {
-        j$.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
-        expect(j$.pp(array)).toEqual("[ 1, 2, ... ]");
+        jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
+        expect(jasmineUnderTest.pp(array)).toEqual("[ 1, 2, ... ]");
       } finally {
-        j$.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxLength;
+        jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxLength;
       }
     });
 
@@ -36,27 +36,27 @@ describe("j$.pp", function () {
       var arr = [1, 2];
       arr.foo = 'bar';
       arr.baz = {};
-      expect(j$.pp(arr)).toEqual("[ 1, 2, foo: 'bar', baz: Object({  }) ]");
+      expect(jasmineUnderTest.pp(arr)).toEqual("[ 1, 2, foo: 'bar', baz: Object({  }) ]");
     });
 
     it("should stringify empty arrays with properties properly", function() {
       var empty = [];
       empty.foo = 'bar';
       empty.baz = {};
-      expect(j$.pp(empty)).toEqual("[ foo: 'bar', baz: Object({  }) ]");
+      expect(jasmineUnderTest.pp(empty)).toEqual("[ foo: 'bar', baz: Object({  }) ]");
     });
 
     it("should stringify long arrays with properties properly", function() {
-      var originalMaxLength = j$.MAX_PRETTY_PRINT_ARRAY_LENGTH;
+      var originalMaxLength = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
       var long = [1,2,3];
       long.foo = 'bar';
       long.baz = {};
 
       try {
-        j$.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
-        expect(j$.pp(long)).toEqual("[ 1, 2, ..., foo: 'bar', baz: Object({  }) ]");
+        jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
+        expect(jasmineUnderTest.pp(long)).toEqual("[ 1, 2, ..., foo: 'bar', baz: Object({  }) ]");
       } finally {
-        j$.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxLength;
+        jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxLength;
       }
     });
 
@@ -64,19 +64,19 @@ describe("j$.pp", function () {
       var array1 = [1, 2];
       var array2 = [array1];
       array1.push(array2);
-      expect(j$.pp(array1)).toEqual("[ 1, 2, [ <circular reference: Array> ] ]");
+      expect(jasmineUnderTest.pp(array1)).toEqual("[ 1, 2, [ <circular reference: Array> ] ]");
     });
 
     it("should not indicate circular references incorrectly", function() {
       var array = [ [1] ];
-      expect(j$.pp(array)).toEqual("[ [ 1 ] ]");
+      expect(jasmineUnderTest.pp(array)).toEqual("[ [ 1 ] ]");
     });
   });
 
   it("should stringify objects properly", function() {
-    expect(j$.pp({foo: 'bar'})).toEqual("Object({ foo: 'bar' })");
-    expect(j$.pp({foo:'bar', baz:3, nullValue: null, undefinedValue: jasmine.undefined})).toEqual("Object({ foo: 'bar', baz: 3, nullValue: null, undefinedValue: undefined })");
-    expect(j$.pp({foo: function () {
+    expect(jasmineUnderTest.pp({foo: 'bar'})).toEqual("Object({ foo: 'bar' })");
+    expect(jasmineUnderTest.pp({foo:'bar', baz:3, nullValue: null, undefinedValue: jasmine.undefined})).toEqual("Object({ foo: 'bar', baz: 3, nullValue: null, undefinedValue: undefined })");
+    expect(jasmineUnderTest.pp({foo: function () {
     }, bar: [1, 2, 3]})).toEqual("Object({ foo: Function, bar: [ 1, 2, 3 ] })");
   });
 
@@ -85,28 +85,28 @@ describe("j$.pp", function () {
     SomeClass.prototype.foo = "inherited foo";
     var instance = new SomeClass();
     instance.bar = "my own bar";
-    expect(j$.pp(instance)).toEqual("SomeClass({ bar: 'my own bar' })");
+    expect(jasmineUnderTest.pp(instance)).toEqual("SomeClass({ bar: 'my own bar' })");
   });
 
-  it("should not recurse objects and arrays more deeply than j$.MAX_PRETTY_PRINT_DEPTH", function() {
-    var originalMaxDepth = j$.MAX_PRETTY_PRINT_DEPTH;
+  it("should not recurse objects and arrays more deeply than jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH", function() {
+    var originalMaxDepth = jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH;
     var nestedObject = { level1: { level2: { level3: { level4: "leaf" } } } };
     var nestedArray  = [1, [2, [3, [4, "leaf"]]]];
 
     try {
-      j$.MAX_PRETTY_PRINT_DEPTH = 2;
-      expect(j$.pp(nestedObject)).toEqual("Object({ level1: Object({ level2: Object }) })");
-      expect(j$.pp(nestedArray)).toEqual("[ 1, [ 2, Array ] ]");
+      jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH = 2;
+      expect(jasmineUnderTest.pp(nestedObject)).toEqual("Object({ level1: Object({ level2: Object }) })");
+      expect(jasmineUnderTest.pp(nestedArray)).toEqual("[ 1, [ 2, Array ] ]");
 
-      j$.MAX_PRETTY_PRINT_DEPTH = 3;
-      expect(j$.pp(nestedObject)).toEqual("Object({ level1: Object({ level2: Object({ level3: Object }) }) })");
-      expect(j$.pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, Array ] ] ]");
+      jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH = 3;
+      expect(jasmineUnderTest.pp(nestedObject)).toEqual("Object({ level1: Object({ level2: Object({ level3: Object }) }) })");
+      expect(jasmineUnderTest.pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, Array ] ] ]");
 
-      j$.MAX_PRETTY_PRINT_DEPTH = 4;
-      expect(j$.pp(nestedObject)).toEqual("Object({ level1: Object({ level2: Object({ level3: Object({ level4: 'leaf' }) }) }) })");
-      expect(j$.pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, [ 4, 'leaf' ] ] ] ]");
+      jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH = 4;
+      expect(jasmineUnderTest.pp(nestedObject)).toEqual("Object({ level1: Object({ level2: Object({ level3: Object({ level4: 'leaf' }) }) }) })");
+      expect(jasmineUnderTest.pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, [ 4, 'leaf' ] ] ] ]");
     } finally {
-      j$.MAX_PRETTY_PRINT_DEPTH = originalMaxDepth;
+      jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH = originalMaxDepth;
     }
   });
 
@@ -115,18 +115,18 @@ describe("j$.pp", function () {
       var frozenObject = {foo: {bar: 'baz'}};
       frozenObject.circular = frozenObject;
       frozenObject = Object.freeze(frozenObject);
-      expect(j$.pp(frozenObject)).toEqual("Object({ foo: Object({ bar: 'baz' }), circular: <circular reference: Object> })");
+      expect(jasmineUnderTest.pp(frozenObject)).toEqual("Object({ foo: Object({ bar: 'baz' }), circular: <circular reference: Object> })");
     }
   });
 
   it("should stringify RegExp objects properly", function() {
-    expect(j$.pp(/x|y|z/)).toEqual("/x|y|z/");
+    expect(jasmineUnderTest.pp(/x|y|z/)).toEqual("/x|y|z/");
   });
 
   it("should indicate circular object references", function() {
     var sampleValue = {foo: 'hello'};
     sampleValue.nested = sampleValue;
-    expect(j$.pp(sampleValue)).toEqual("Object({ foo: 'hello', nested: <circular reference: Object> })");
+    expect(jasmineUnderTest.pp(sampleValue)).toEqual("Object({ foo: 'hello', nested: <circular reference: Object> })");
   });
 
   it("should indicate getters on objects as such", function() {
@@ -138,39 +138,39 @@ describe("j$.pp", function () {
       });
     }
     if (sampleValue.__defineGetter__) {
-      expect(j$.pp(sampleValue)).toEqual("Object({ id: 1, calculatedValue: <getter> })");
+      expect(jasmineUnderTest.pp(sampleValue)).toEqual("Object({ id: 1, calculatedValue: <getter> })");
     }
     else {
-      expect(j$.pp(sampleValue)).toEqual("Object({ id: 1 })");
+      expect(jasmineUnderTest.pp(sampleValue)).toEqual("Object({ id: 1 })");
     }
   });
 
 
   it('should not do HTML escaping of strings', function() {
-    expect(j$.pp('some <b>html string</b> &', false)).toEqual('\'some <b>html string</b> &\'');
+    expect(jasmineUnderTest.pp('some <b>html string</b> &', false)).toEqual('\'some <b>html string</b> &\'');
   });
 
   it("should abbreviate the global (usually window) object", function() {
-    expect(j$.pp(jasmine.getGlobal())).toEqual("<global>");
+    expect(jasmineUnderTest.pp(jasmine.getGlobal())).toEqual("<global>");
   });
 
   it("should stringify Date objects properly", function() {
     var now = new Date();
-    expect(j$.pp(now)).toEqual("Date(" + now.toString() + ")");
+    expect(jasmineUnderTest.pp(now)).toEqual("Date(" + now.toString() + ")");
   });
 
   it("should stringify spy objects properly", function() {
     var TestObject = {
           someFunction: function() {}
         },
-        env = new j$.Env();
+        env = new jasmineUnderTest.Env();
 
-    var spyRegistry = new j$.SpyRegistry({currentSpies: function() {return [];}});
+    var spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() {return [];}});
 
     spyRegistry.spyOn(TestObject, 'someFunction');
-    expect(j$.pp(TestObject.someFunction)).toEqual("spy on someFunction");
+    expect(jasmineUnderTest.pp(TestObject.someFunction)).toEqual("spy on someFunction");
 
-    expect(j$.pp(j$.createSpy("something"))).toEqual("spy on something");
+    expect(jasmineUnderTest.pp(jasmineUnderTest.createSpy("something"))).toEqual("spy on something");
   });
 
   it("should stringify objects that implement jasmineToString", function () {
@@ -178,7 +178,7 @@ describe("j$.pp", function () {
       jasmineToString: function () { return "strung"; }
     };
 
-    expect(j$.pp(obj)).toEqual("strung");
+    expect(jasmineUnderTest.pp(obj)).toEqual("strung");
   });
 
   it("should stringify objects that implement custom toString", function () {
@@ -186,7 +186,16 @@ describe("j$.pp", function () {
       toString: function () { return "my toString"; }
     };
 
-    expect(j$.pp(obj)).toEqual("my toString");
+    expect(jasmineUnderTest.pp(obj)).toEqual("my toString");
+  });
+
+  it("should stringify objects from anonymous constructors with custom toString", function () {
+    var MyAnonymousConstructor = (function() { return function () {}; })();
+    MyAnonymousConstructor.toString = function () { return ''; };
+
+    var a = new MyAnonymousConstructor();
+
+    expect(jasmineUnderTest.pp(a)).toEqual("<anonymous>({  })");
   });
 
   it("should handle objects with null prototype", function() {
@@ -195,6 +204,6 @@ describe("j$.pp", function () {
     var obj = Object.create(null);
     obj.foo = 'bar';
 
-    expect(j$.pp(obj)).toEqual("null({ foo: 'bar' })");
+    expect(jasmineUnderTest.pp(obj)).toEqual("null({ foo: 'bar' })");
   });
 });

spec/core/QueueRunnerSpec.js

@@ -4,7 +4,7 @@ describe("QueueRunner", function() {
     var calls = [],
       queueableFn1 = { fn: jasmine.createSpy('fn1') },
       queueableFn2 = { fn: jasmine.createSpy('fn2') },
-      queueRunner = new j$.QueueRunner({
+      queueRunner = new jasmineUnderTest.QueueRunner({
         queueableFns: [queueableFn1, queueableFn2]
       });
     queueableFn1.fn.and.callFake(function() {
@@ -23,7 +23,7 @@ describe("QueueRunner", function() {
     var queueableFn1 = { fn: jasmine.createSpy('fn1') },
         queueableFn2 = { fn: jasmine.createSpy('fn2') },
         queueableFn3 = { fn: function(done) { asyncContext = this; done(); } },
-        queueRunner = new j$.QueueRunner({
+        queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn1, queueableFn2, queueableFn3]
         }),
         asyncContext;
@@ -65,7 +65,7 @@ describe("QueueRunner", function() {
           afterCallback();
           setTimeout(done, 100);
         } },
-        queueRunner = new j$.QueueRunner({
+        queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn1, queueableFn2, queueableFn3],
           onComplete: onComplete
         });
@@ -99,7 +99,7 @@ describe("QueueRunner", function() {
         } },
         queueableFn2 = { fn: jasmine.createSpy('fn2') },
         failFn = jasmine.createSpy('fail'),
-        queueRunner = new j$.QueueRunner({
+        queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn1, queueableFn2],
           fail: failFn
         });
@@ -121,7 +121,7 @@ describe("QueueRunner", function() {
         queueableFn = { fn: jasmine.createSpy('fn'), type: 'queueable' },
         onComplete = jasmine.createSpy('onComplete'),
         onException = jasmine.createSpy('onException'),
-        queueRunner = new j$.QueueRunner({
+        queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [beforeFn, queueableFn],
           onComplete: onComplete,
           onException: onException
@@ -142,7 +142,7 @@ describe("QueueRunner", function() {
         queueableFn = { fn: jasmine.createSpy('fn') },
         onComplete = jasmine.createSpy('onComplete'),
         onException = jasmine.createSpy('onException'),
-        queueRunner = new j$.QueueRunner({
+        queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [beforeFn, queueableFn],
           onComplete: onComplete,
           onException: onException,
@@ -151,7 +151,7 @@ describe("QueueRunner", function() {
       queueRunner.execute();
       expect(queueableFn.fn).not.toHaveBeenCalled();
 
-      jasmine.clock().tick(j$.DEFAULT_TIMEOUT_INTERVAL);
+      jasmine.clock().tick(jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL);
 
       expect(onException).not.toHaveBeenCalled();
       expect(queueableFn.fn).not.toHaveBeenCalled();
@@ -162,7 +162,7 @@ describe("QueueRunner", function() {
        var queueableFn = { fn: function(done) { throw new Error("error!"); } },
         onComplete = jasmine.createSpy('onComplete'),
         onException = jasmine.createSpy('onException'),
-        queueRunner = new j$.QueueRunner({
+        queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn],
           onComplete: onComplete,
           onException: onException
@@ -173,7 +173,7 @@ describe("QueueRunner", function() {
       expect(onComplete).toHaveBeenCalled();
       expect(onException).toHaveBeenCalled();
 
-      jasmine.clock().tick(j$.DEFAULT_TIMEOUT_INTERVAL);
+      jasmine.clock().tick(jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL);
       expect(onException.calls.count()).toEqual(1);
     });
 
@@ -181,7 +181,7 @@ describe("QueueRunner", function() {
       var queueableFn = { fn: function(done) { done(); } },
         onComplete = jasmine.createSpy('onComplete'),
         onException = jasmine.createSpy('onException'),
-        queueRunner = new j$.QueueRunner({
+        queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn],
           onComplete: onComplete,
           onException: onException
@@ -191,14 +191,14 @@ describe("QueueRunner", function() {
 
       expect(onComplete).toHaveBeenCalled();
 
-      jasmine.clock().tick(j$.DEFAULT_TIMEOUT_INTERVAL);
+      jasmine.clock().tick(jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL);
       expect(onException).not.toHaveBeenCalled();
     });
 
     it("only moves to the next spec the first time you call done", function() {
       var queueableFn = { fn: function(done) {done(); done();} },
         nextQueueableFn = { fn: jasmine.createSpy('nextFn') };
-      queueRunner = new j$.QueueRunner({
+      queueRunner = new jasmineUnderTest.QueueRunner({
         queueableFns: [queueableFn, nextQueueableFn]
       });
 
@@ -212,7 +212,7 @@ describe("QueueRunner", function() {
          throw new Error('error!');
        } },
         nextQueueableFn = { fn: jasmine.createSpy('nextFn') };
-      queueRunner = new j$.QueueRunner({
+      queueRunner = new jasmineUnderTest.QueueRunner({
         queueableFns: [queueableFn, nextQueueableFn]
       });
 
@@ -220,6 +220,20 @@ describe("QueueRunner", function() {
       jasmine.clock().tick(1);
       expect(nextQueueableFn.fn.calls.count()).toEqual(1);
     });
+
+    it("should return a null when you call done", function () {
+      // Some promises want handlers to return anything but undefined to help catch "forgotten returns".
+      var doneReturn,
+        queueableFn = { fn: function(done) {
+          doneReturn = done();
+        } },
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [queueableFn]
+        });
+
+      queueRunner.execute();
+      expect(doneReturn).toBe(null);
+    });
   });
 
   it("calls exception handlers when an exception is thrown in a fn", function() {
@@ -228,7 +242,7 @@ describe("QueueRunner", function() {
         throw new Error('fake error');
       } },
       onExceptionCallback = jasmine.createSpy('on exception callback'),
-      queueRunner = new j$.QueueRunner({
+      queueRunner = new jasmineUnderTest.QueueRunner({
         queueableFns: [queueableFn],
         onException: onExceptionCallback
       });
@@ -242,7 +256,7 @@ describe("QueueRunner", function() {
     var queueableFn = { fn: function() {
         throw new Error('fake error');
       } },
-      queueRunner = new j$.QueueRunner({
+      queueRunner = new jasmineUnderTest.QueueRunner({
         queueableFns: [queueableFn],
         catchException: function(e) { return false; }
       });
@@ -255,7 +269,7 @@ describe("QueueRunner", function() {
   it("continues running the functions even after an exception is thrown in an async spec", function() {
     var queueableFn = { fn: function(done) { throw new Error("error"); } },
       nextQueueableFn = { fn: jasmine.createSpy("nextFunction") },
-      queueRunner = new j$.QueueRunner({
+      queueRunner = new jasmineUnderTest.QueueRunner({
         queueableFns: [queueableFn, nextQueueableFn]
       });
 
@@ -266,7 +280,7 @@ describe("QueueRunner", function() {
   it("calls a provided complete callback when done", function() {
     var queueableFn = { fn: jasmine.createSpy('fn') },
       completeCallback = jasmine.createSpy('completeCallback'),
-      queueRunner = new j$.QueueRunner({
+      queueRunner = new jasmineUnderTest.QueueRunner({
         queueableFns: [queueableFn],
         onComplete: completeCallback
       });
@@ -281,7 +295,7 @@ describe("QueueRunner", function() {
         afterFn = { fn: jasmine.createSpy('afterFn') },
         completeCallback = jasmine.createSpy('completeCallback'),
         clearStack = jasmine.createSpy('clearStack'),
-        queueRunner = new j$.QueueRunner({
+        queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [asyncFn, afterFn],
           clearStack: clearStack,
           onComplete: completeCallback

spec/core/ReportDispatcherSpec.js

@@ -1,7 +1,7 @@
 describe("ReportDispatcher", function() {
 
   it("builds an interface of requested methods", function() {
-    var dispatcher = new j$.ReportDispatcher(['foo', 'bar', 'baz']);
+    var dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar', 'baz']);
 
     expect(dispatcher.foo).toBeDefined();
     expect(dispatcher.bar).toBeDefined();
@@ -9,7 +9,7 @@ describe("ReportDispatcher", function() {
   });
 
   it("dispatches requested methods to added reporters", function() {
-    var dispatcher = new j$.ReportDispatcher(['foo', 'bar']),
+    var dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar']),
       reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
       anotherReporter = jasmine.createSpyObj('reporter', ['foo', 'bar']);
 
@@ -28,7 +28,7 @@ describe("ReportDispatcher", function() {
   });
 
   it("does not dispatch to a reporter if the reporter doesn't accept the method", function() {
-    var dispatcher = new j$.ReportDispatcher(['foo']),
+    var dispatcher = new jasmineUnderTest.ReportDispatcher(['foo']),
       reporter = jasmine.createSpyObj('reporter', ['baz']);
 
     dispatcher.addReporter(reporter);
@@ -37,4 +37,28 @@ describe("ReportDispatcher", function() {
       dispatcher.foo(123, 456);
     }).not.toThrow();
   });
+
+  it("allows providing a fallback reporter in case there's no other report", function() {
+    var dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar']),
+      reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']);
+
+    dispatcher.provideFallbackReporter(reporter);
+    dispatcher.foo(123, 456);
+    expect(reporter.foo).toHaveBeenCalledWith(123, 456);
+
+  });
+
+  it("does not call fallback reporting methods when another report is provided", function() {
+    var dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar']),
+      reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
+      fallbackReporter = jasmine.createSpyObj('otherReporter', ['foo', 'bar']);
+
+    dispatcher.provideFallbackReporter(fallbackReporter);
+    dispatcher.addReporter(reporter);
+    dispatcher.foo(123, 456);
+
+    expect(reporter.foo).toHaveBeenCalledWith(123, 456);
+    expect(fallbackReporter.foo).not.toHaveBeenCalledWith(123, 456);
+
+  });
 });

spec/core/SpecSpec.js

@@ -1,36 +1,36 @@
 describe("Spec", function() {
 
   it("#isPendingSpecException returns true for a pending spec exception", function() {
-    var e = new Error(j$.Spec.pendingSpecExceptionMessage);
+    var e = new Error(jasmineUnderTest.Spec.pendingSpecExceptionMessage);
 
-    expect(j$.Spec.isPendingSpecException(e)).toBe(true);
+    expect(jasmineUnderTest.Spec.isPendingSpecException(e)).toBe(true);
   });
 
   it("#isPendingSpecException returns true for a pending spec exception (even when FF bug is present)", function() {
     var fakeError = {
-      toString: function() { return "Error: " + j$.Spec.pendingSpecExceptionMessage; }
+      toString: function() { return "Error: " + jasmineUnderTest.Spec.pendingSpecExceptionMessage; }
     };
 
-    expect(j$.Spec.isPendingSpecException(fakeError)).toBe(true);
+    expect(jasmineUnderTest.Spec.isPendingSpecException(fakeError)).toBe(true);
   });
 
   it("#isPendingSpecException returns true for a pending spec exception with a custom message", function() {
-    expect(j$.Spec.isPendingSpecException(j$.Spec.pendingSpecExceptionMessage + 'foo')).toBe(true);
+    expect(jasmineUnderTest.Spec.isPendingSpecException(jasmineUnderTest.Spec.pendingSpecExceptionMessage + 'foo')).toBe(true);
   });
 
   it("#isPendingSpecException returns false for not a pending spec exception", function() {
     var e = new Error("foo");
 
-    expect(j$.Spec.isPendingSpecException(e)).toBe(false);
+    expect(jasmineUnderTest.Spec.isPendingSpecException(e)).toBe(false);
   });
 
   it("#isPendingSpecException returns false for thrown values that don't have toString", function() {
-    expect(j$.Spec.isPendingSpecException(void 0)).toBe(false);
+    expect(jasmineUnderTest.Spec.isPendingSpecException(void 0)).toBe(false);
   });
 
   it("delegates execution to a QueueRunner", function() {
     var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         description: 'my test',
         id: 'some-id',
         queueableFn: { fn: function() {} },
@@ -45,7 +45,7 @@ describe("Spec", function() {
   it("should call the start callback on execution", function() {
     var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
       startCallback = jasmine.createSpy('startCallback'),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         id: 123,
         description: 'foo bar',
         queueableFn: { fn: function() {} },
@@ -69,7 +69,7 @@ describe("Spec", function() {
       startCallback = jasmine.createSpy('start-callback').and.callFake(function() {
         expect(beforesWereCalled).toBe(false);
       }),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
         beforeFns: function() {
           return [function() {
@@ -93,7 +93,7 @@ describe("Spec", function() {
         expect(before).toHaveBeenCalled();
         expect(after).not.toHaveBeenCalled();
       }) },
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         queueableFn: queueableFn,
         beforeAndAfterFns: function() {
           return {befores: [before], afters: [after]}
@@ -112,7 +112,7 @@ describe("Spec", function() {
 
       startCallback = jasmine.createSpy('startCallback'),
       resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         onStart: startCallback,
         queueableFn: { fn: null },
         resultCallback: resultCallback,
@@ -127,7 +127,7 @@ describe("Spec", function() {
       startCallback = jasmine.createSpy('startCallback'),
       specBody = jasmine.createSpy('specBody'),
       resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         onStart:startCallback,
         queueableFn: { fn: specBody },
         resultCallback: resultCallback,
@@ -152,7 +152,7 @@ describe("Spec", function() {
       startCallback = jasmine.createSpy('startCallback'),
       specBody = jasmine.createSpy('specBody'),
       resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         onStart:startCallback,
         queueableFn: { fn: specBody },
         resultCallback: resultCallback,
@@ -174,7 +174,7 @@ describe("Spec", function() {
     var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
       startCallback = jasmine.createSpy('startCallback'),
       resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         onStart: startCallback,
         resultCallback: resultCallback,
         description: "with a spec",
@@ -207,7 +207,7 @@ describe("Spec", function() {
 
   it("should call the done callback on execution complete", function() {
     var done = jasmine.createSpy('done callback'),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
         catchExceptions: function() { return false; },
         resultCallback: function() {},
@@ -220,18 +220,18 @@ describe("Spec", function() {
   });
 
   it("#status returns passing by default", function() {
-    var spec = new j$.Spec({queueableFn: { fn: jasmine.createSpy("spec body")} });
+    var spec = new jasmineUnderTest.Spec({queueableFn: { fn: jasmine.createSpy("spec body")} });
     expect(spec.status()).toBe('passed');
   });
 
   it("#status returns passed if all expectations in the spec have passed", function() {
-    var spec = new j$.Spec({queueableFn: { fn: jasmine.createSpy("spec body")} });
+    var spec = new jasmineUnderTest.Spec({queueableFn: { fn: jasmine.createSpy("spec body")} });
     spec.addExpectationResult(true);
     expect(spec.status()).toBe('passed');
   });
 
   it("#status returns failed if any expectations in the spec have failed", function() {
-    var spec = new j$.Spec({queueableFn: { fn: jasmine.createSpy("spec body") } });
+    var spec = new jasmineUnderTest.Spec({queueableFn: { fn: jasmine.createSpy("spec body") } });
     spec.addExpectationResult(true);
     spec.addExpectationResult(false);
     expect(spec.status()).toBe('failed');
@@ -239,7 +239,7 @@ describe("Spec", function() {
 
   it("keeps track of passed and failed expectations", function() {
     var resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: jasmine.createSpy("spec body") },
         expectationResultFactory: function (data) { return data; },
         queueRunnerFactory: function(attrs) { attrs.onComplete(); },
@@ -256,7 +256,7 @@ describe("Spec", function() {
 
   it("throws an ExpectationFailed error upon receiving a failed expectation when 'throwOnExpectationFailure' is set", function() {
     var resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
       queueableFn: { fn: function() {} },
       expectationResultFactory: function(data) { return data; },
       queueRunnerFactory: function(attrs) { attrs.onComplete(); },
@@ -267,7 +267,7 @@ describe("Spec", function() {
     spec.addExpectationResult(true, 'passed');
     expect(function() {
       spec.addExpectationResult(false, 'failed')
-    }).toThrowError(j$.errors.ExpectationFailed);
+    }).toThrowError(jasmineUnderTest.errors.ExpectationFailed);
 
     spec.execute();
 
@@ -277,7 +277,7 @@ describe("Spec", function() {
 
   it("does not throw an ExpectationFailed error when handling an error", function() {
     var resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
         expectationResultFactory: function(data) { return data; },
         queueRunnerFactory: function(attrs) { attrs.onComplete(); },
@@ -291,7 +291,7 @@ describe("Spec", function() {
   it("can return its full name", function() {
     var specNameSpy = jasmine.createSpy('specNameSpy').and.returnValue('expected val');
 
-    var spec = new j$.Spec({
+    var spec = new jasmineUnderTest.Spec({
       getSpecName: specNameSpy,
       queueableFn: { fn: null }
     });
@@ -303,9 +303,9 @@ describe("Spec", function() {
   describe("when a spec is marked pending during execution", function() {
     it("should mark the spec as pending", function() {
       var fakeQueueRunner = function(opts) {
-          opts.onException(new Error(j$.Spec.pendingSpecExceptionMessage));
+          opts.onException(new Error(jasmineUnderTest.Spec.pendingSpecExceptionMessage));
         },
-        spec = new j$.Spec({
+        spec = new jasmineUnderTest.Spec({
           description: 'my test',
           id: 'some-id',
           queueableFn: { fn: function() { } },
@@ -320,9 +320,9 @@ describe("Spec", function() {
 
     it("should set the pendingReason", function() {
       var fakeQueueRunner = function(opts) {
-          opts.onException(new Error(j$.Spec.pendingSpecExceptionMessage + 'custom message'));
+          opts.onException(new Error(jasmineUnderTest.Spec.pendingSpecExceptionMessage + 'custom message'));
         },
-        spec = new j$.Spec({
+        spec = new jasmineUnderTest.Spec({
           description: 'my test',
           id: 'some-id',
           queueableFn: { fn: function() { } },
@@ -338,7 +338,7 @@ describe("Spec", function() {
 
   it("should log a failure when handling an exception", function() {
     var resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
         expectationResultFactory: function(data) { return data; },
         queueRunnerFactory: function(attrs) { attrs.onComplete(); },
@@ -359,41 +359,41 @@ describe("Spec", function() {
 
   it("should not log an additional failure when handling an ExpectationFailed error", function() {
     var resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new j$.Spec({
+      spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
         expectationResultFactory: function(data) { return data; },
         queueRunnerFactory: function(attrs) { attrs.onComplete(); },
         resultCallback: resultCallback
       });
 
-    spec.onException(new j$.errors.ExpectationFailed());
+    spec.onException(new jasmineUnderTest.errors.ExpectationFailed());
     spec.execute();
 
     expect(resultCallback.calls.first().args[0].failedExpectations).toEqual([]);
   });
 
   it("retrieves a result with updated status", function() {
-    var spec = new j$.Spec({ queueableFn: { fn: function() {} } });
+    var spec = new jasmineUnderTest.Spec({ queueableFn: { fn: function() {} } });
 
     expect(spec.getResult().status).toBe('passed');
   });
 
   it("retrives a result with disabled status", function() {
-    var spec = new j$.Spec({ queueableFn: { fn: function() {} } });
+    var spec = new jasmineUnderTest.Spec({ queueableFn: { fn: function() {} } });
     spec.disable();
 
     expect(spec.getResult().status).toBe('disabled');
   });
 
   it("retrives a result with pending status", function() {
-    var spec = new j$.Spec({ queueableFn: { fn: function() {} } });
+    var spec = new jasmineUnderTest.Spec({ queueableFn: { fn: function() {} } });
     spec.pend();
 
     expect(spec.getResult().status).toBe('pending');
   });
 
   it("should not be executable when disabled", function() {
-    var spec = new j$.Spec({
+    var spec = new jasmineUnderTest.Spec({
       queueableFn: { fn: function() {} }
     });
     spec.disable();
@@ -402,7 +402,7 @@ describe("Spec", function() {
   });
 
   it("should be executable when pending", function() {
-    var spec = new j$.Spec({
+    var spec = new jasmineUnderTest.Spec({
       queueableFn: { fn: function() {} }
     });
     spec.pend();
@@ -411,7 +411,7 @@ describe("Spec", function() {
   });
 
   it("should be executable when not disabled or pending", function() {
-    var spec = new j$.Spec({
+    var spec = new jasmineUnderTest.Spec({
       queueableFn: { fn: function() {} }
     });
 

spec/core/SpyRegistrySpec.js

@@ -1,14 +1,14 @@
 describe("SpyRegistry", function() {
   describe("#spyOn", function() {
     it("checks for the existence of the object", function() {
-      var spyRegistry = new j$.SpyRegistry();
+      var spyRegistry = new jasmineUnderTest.SpyRegistry();
       expect(function() {
         spyRegistry.spyOn(void 0, 'pants');
       }).toThrowError(/could not find an object/);
     });
 
     it("checks that a method name was passed", function() {
-      var spyRegistry = new j$.SpyRegistry(),
+      var spyRegistry = new jasmineUnderTest.SpyRegistry(),
         subject = {};
 
         expect(function() {
@@ -17,7 +17,7 @@ describe("SpyRegistry", function() {
     });
 
     it("checks for the existence of the method", function() {
-      var spyRegistry = new j$.SpyRegistry(),
+      var spyRegistry = new jasmineUnderTest.SpyRegistry(),
         subject = {};
 
       expect(function() {
@@ -27,7 +27,7 @@ describe("SpyRegistry", function() {
 
     it("checks if it has already been spied upon", function() {
       var spies = [],
-        spyRegistry = new j$.SpyRegistry({currentSpies: function() { return spies; }}),
+        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
         subject = { spiedFunc: function() {} };
 
       spyRegistry.spyOn(subject, 'spiedFunc');
@@ -54,7 +54,7 @@ describe("SpyRegistry", function() {
       });
 
       var spies = [],
-        spyRegistry = new j$.SpyRegistry({currentSpies: function() { return spies; }}),
+        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
         subject = { spiedFunc: scope.myFunc };
 
       expect(function() {
@@ -68,7 +68,7 @@ describe("SpyRegistry", function() {
 
     it("overrides the method on the object and returns the spy", function() {
       var originalFunctionWasCalled = false,
-        spyRegistry = new j$.SpyRegistry(),
+        spyRegistry = new jasmineUnderTest.SpyRegistry(),
         subject = { spiedFunc: function() { originalFunctionWasCalled = true; } };
 
       var spy = spyRegistry.spyOn(subject, 'spiedFunc');
@@ -80,7 +80,7 @@ describe("SpyRegistry", function() {
   describe("#clearSpies", function() {
     it("restores the original functions on the spied-upon objects", function() {
       var spies = [],
-        spyRegistry = new j$.SpyRegistry({currentSpies: function() { return spies; }}),
+        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
         originalFunction = function() {},
         subject = { spiedFunc: originalFunction };
 
@@ -89,5 +89,67 @@ describe("SpyRegistry", function() {
 
       expect(subject.spiedFunc).toBe(originalFunction);
     });
+
+    it("restores the original functions, even when that spy has been replace and re-spied upon", function() {
+      var spies = [],
+        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
+        originalFunction = function() {},
+        subject = { spiedFunc: originalFunction };
+
+      spyRegistry.spyOn(subject, 'spiedFunc');
+
+      // replace the original spy with some other function
+      subject.spiedFunc = function() {};
+
+      // spy on the function in that location again
+      spyRegistry.spyOn(subject, 'spiedFunc');
+
+      spyRegistry.clearSpies();
+
+      expect(subject.spiedFunc).toBe(originalFunction);
+    });
+
+    it("does not add a property that the spied-upon object didn't originally have", function() {
+      // IE 8 doesn't support `Object.create`
+      if (jasmine.getEnv().ieVersion < 9) { return; }
+
+      var spies = [],
+        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
+        originalFunction = function() {},
+        subjectParent = {spiedFunc: originalFunction};
+
+      var subject = Object.create(subjectParent);
+
+      expect(subject.hasOwnProperty('spiedFunc')).toBe(false);
+
+      spyRegistry.spyOn(subject, 'spiedFunc');
+      spyRegistry.clearSpies();
+
+      expect(subject.hasOwnProperty('spiedFunc')).toBe(false);
+      expect(subject.spiedFunc).toBe(originalFunction);
+    });
+
+    it("restores the original function when it\'s inherited and cannot be deleted", function() {
+      // IE 8 doesn't support `Object.create` or `Object.defineProperty`
+      if (jasmine.getEnv().ieVersion < 9) { return; }
+
+      var spies = [],
+        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
+        originalFunction = function() {},
+        subjectParent = {spiedFunc: originalFunction};
+
+      var subject = Object.create(subjectParent);
+
+      spyRegistry.spyOn(subject, 'spiedFunc');
+
+      // simulate a spy that cannot be deleted
+      Object.defineProperty(subject, 'spiedFunc', {
+        configurable: false
+      });
+
+      spyRegistry.clearSpies();
+
+      expect(jasmineUnderTest.isSpy(subject.spiedFunc)).toBe(false);
+    });
   });
 });

spec/core/SpySpec.js

@@ -9,7 +9,7 @@ describe('Spies', function () {
     });
 
     it("preserves the properties of the spied function", function() {
-      var spy = j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      var spy = jasmineUnderTest.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
 
       expect(spy.bob).toEqual("test");
     });
@@ -18,19 +18,19 @@ describe('Spies', function () {
       TestClass.prototype.someFunction.and = "turkey";
 
       expect(function() {
-        j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+        jasmineUnderTest.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
       }).toThrowError("Jasmine spies would overwrite the 'and' and 'calls' properties on the object being spied upon");
     });
 
     it("adds a spyStrategy and callTracker to the spy", function() {
-      var spy = j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      var spy = jasmineUnderTest.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
 
-      expect(spy.and).toEqual(jasmine.any(j$.SpyStrategy));
-      expect(spy.calls).toEqual(jasmine.any(j$.CallTracker));
+      expect(spy.and).toEqual(jasmine.any(jasmineUnderTest.SpyStrategy));
+      expect(spy.calls).toEqual(jasmine.any(jasmineUnderTest.CallTracker));
     });
 
     it("tracks the argument of calls", function () {
-      var spy = j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      var spy = jasmineUnderTest.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
       var trackSpy = spyOn(spy.calls, "track");
 
       spy("arg");
@@ -39,7 +39,7 @@ describe('Spies', function () {
     });
 
     it("tracks the context of calls", function () {
-      var spy = j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      var spy = jasmineUnderTest.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
       var trackSpy = spyOn(spy.calls, "track");
 
       var contextObject = { spyMethod: spy };
@@ -49,7 +49,7 @@ describe('Spies', function () {
     });
 
     it("tracks the return value of calls", function () {
-      var spy = j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      var spy = jasmineUnderTest.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
       var trackSpy = spyOn(spy.calls, "track");
 
       spy.and.returnValue("return value");
@@ -61,7 +61,7 @@ describe('Spies', function () {
 
   describe("createSpyObj", function() {
     it("should create an object with a bunch of spy methods when you call jasmine.createSpyObj()", function() {
-      var spyObj = j$.createSpyObj('BaseName', ['method1', 'method2']);
+      var spyObj = jasmineUnderTest.createSpyObj('BaseName', ['method1', 'method2']);
 
       expect(spyObj).toEqual({ method1: jasmine.any(Function), method2: jasmine.any(Function)});
       expect(spyObj.method1.and.identity()).toEqual('BaseName.method1');
@@ -69,7 +69,7 @@ describe('Spies', function () {
     });
 
     it("should allow you to omit the baseName", function() {
-      var spyObj = j$.createSpyObj(['method1', 'method2']);
+      var spyObj = jasmineUnderTest.createSpyObj(['method1', 'method2']);
 
       expect(spyObj).toEqual({ method1: jasmine.any(Function), method2: jasmine.any(Function)});
       expect(spyObj.method1.and.identity()).toEqual('unknown.method1');
@@ -78,7 +78,7 @@ describe('Spies', function () {
 
     it("should throw if you do not pass an array argument", function() {
       expect(function() {
-        j$.createSpyObj('BaseName');
+        jasmineUnderTest.createSpyObj('BaseName');
       }).toThrow("createSpyObj requires a non-empty array of method names to create spies for");
     });
   });

spec/core/SpyStrategySpec.js

@@ -1,20 +1,20 @@
 describe("SpyStrategy", function() {
 
   it("defaults its name to unknown", function() {
-    var spyStrategy = new j$.SpyStrategy();
+    var spyStrategy = new jasmineUnderTest.SpyStrategy();
 
     expect(spyStrategy.identity()).toEqual("unknown");
   });
 
   it("takes a name", function() {
-    var spyStrategy = new j$.SpyStrategy({name: "foo"});
+    var spyStrategy = new jasmineUnderTest.SpyStrategy({name: "foo"});
 
     expect(spyStrategy.identity()).toEqual("foo");
   });
 
   it("stubs an original function, if provided", function() {
     var originalFn = jasmine.createSpy("original"),
-        spyStrategy = new j$.SpyStrategy({fn: originalFn});
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
 
     spyStrategy.exec();
 
@@ -23,7 +23,7 @@ describe("SpyStrategy", function() {
 
   it("allows an original function to be called, passed through the params and returns it's value", function() {
     var originalFn = jasmine.createSpy("original").and.returnValue(42),
-        spyStrategy = new j$.SpyStrategy({fn: originalFn}),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
         returnValue;
 
     spyStrategy.callThrough();
@@ -36,7 +36,7 @@ describe("SpyStrategy", function() {
 
   it("can return a specified value when executed", function() {
     var originalFn = jasmine.createSpy("original"),
-        spyStrategy = new j$.SpyStrategy({fn: originalFn}),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
         returnValue;
 
     spyStrategy.returnValue(17);
@@ -48,7 +48,7 @@ describe("SpyStrategy", function() {
 
   it("can return specified values in order specified when executed", function() {
     var originalFn = jasmine.createSpy("original"),
-        spyStrategy = new j$.SpyStrategy({fn: originalFn});
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
 
     spyStrategy.returnValues('value1', 'value2', 'value3');
 
@@ -61,7 +61,7 @@ describe("SpyStrategy", function() {
 
   it("allows an exception to be thrown when executed", function() {
     var originalFn = jasmine.createSpy("original"),
-        spyStrategy = new j$.SpyStrategy({fn: originalFn});
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
 
     spyStrategy.throwError(new TypeError("bar"));
 
@@ -71,7 +71,7 @@ describe("SpyStrategy", function() {
 
   it("allows a non-Error to be thrown, wrapping it into an exception when executed", function() {
     var originalFn = jasmine.createSpy("original"),
-        spyStrategy = new j$.SpyStrategy({fn: originalFn});
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
 
     spyStrategy.throwError("bar");
 
@@ -82,7 +82,7 @@ describe("SpyStrategy", function() {
   it("allows a fake function to be called instead", function() {
     var originalFn = jasmine.createSpy("original"),
         fakeFn = jasmine.createSpy("fake").and.returnValue(67),
-        spyStrategy = new j$.SpyStrategy({fn: originalFn}),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
         returnValue;
 
     spyStrategy.callFake(fakeFn);
@@ -92,10 +92,22 @@ describe("SpyStrategy", function() {
     expect(returnValue).toEqual(67);
   });
 
+  it('throws an error when a non-function is passed to callFake strategy', function() {
+    var originalFn = jasmine.createSpy('original'),
+        invalidFakes = [5, 'foo', {}, true, false, null, void 0, new Date(), /.*/];
+
+    for (var i=0; i<invalidFakes.length; i++) {
+      var invalidFake = invalidFakes[i],
+          spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
+
+      expect(function() {spyStrategy.callFake(invalidFake);}).toThrowError('Argument passed to callFake should be a function, got ' + invalidFake);
+    }
+  });
+
   it("allows a return to plan stubbing after another strategy", function() {
     var originalFn = jasmine.createSpy("original"),
         fakeFn = jasmine.createSpy("fake").and.returnValue(67),
-        spyStrategy = new j$.SpyStrategy({fn: originalFn}),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
         returnValue;
 
     spyStrategy.callFake(fakeFn);
@@ -103,7 +115,7 @@ describe("SpyStrategy", function() {
 
     expect(originalFn).not.toHaveBeenCalled();
     expect(returnValue).toEqual(67);
-    
+
     spyStrategy.stub();
     returnValue = spyStrategy.exec();
 
@@ -113,12 +125,12 @@ describe("SpyStrategy", function() {
   it("returns the spy after changing the strategy", function(){
     var spy = {},
         spyFn = jasmine.createSpy('spyFn').and.returnValue(spy),
-        spyStrategy = new j$.SpyStrategy({getSpy: spyFn});
+        spyStrategy = new jasmineUnderTest.SpyStrategy({getSpy: spyFn});
 
     expect(spyStrategy.callThrough()).toBe(spy);
     expect(spyStrategy.returnValue()).toBe(spy);
     expect(spyStrategy.throwError()).toBe(spy);
-    expect(spyStrategy.callFake()).toBe(spy);
+    expect(spyStrategy.callFake(function() {})).toBe(spy);
     expect(spyStrategy.stub()).toBe(spy);
   });
 });

spec/core/SuiteSpec.js

@@ -1,8 +1,8 @@
 describe("Suite", function() {
 
   it("keeps its id", function() {
-    var env = new j$.Env(),
-      suite = new j$.Suite({
+    var env = new jasmineUnderTest.Env(),
+      suite = new jasmineUnderTest.Suite({
         env: env,
         id: 456,
         description: "I am a suite"
@@ -11,24 +11,24 @@ describe("Suite", function() {
     expect(suite.id).toEqual(456);
   });
 
-  it("returns its full name", function() {
-    var env = new j$.Env(),
-      suite = new j$.Suite({
+  it("returns blank full name for top level suite", function() {
+    var env = new jasmineUnderTest.Env(),
+      suite = new jasmineUnderTest.Suite({
         env: env,
         description: "I am a suite"
       });
 
-    expect(suite.getFullName()).toEqual("I am a suite");
+    expect(suite.getFullName()).toEqual("");
   });
 
   it("returns its full name when it has parent suites", function() {
-    var env = new j$.Env(),
-      parentSuite = new j$.Suite({
+    var env = new jasmineUnderTest.Env(),
+      parentSuite = new jasmineUnderTest.Suite({
         env: env,
         description: "I am a parent suite",
         parentSuite: jasmine.createSpy('pretend top level suite')
       }),
-      suite = new j$.Suite({
+      suite = new jasmineUnderTest.Suite({
         env: env,
         description: "I am a suite",
         parentSuite: parentSuite
@@ -38,8 +38,8 @@ describe("Suite", function() {
   });
 
   it("adds before functions in order of needed execution", function() {
-    var env = new j$.Env(),
-      suite = new j$.Suite({
+    var env = new jasmineUnderTest.Env(),
+      suite = new jasmineUnderTest.Suite({
         env: env,
         description: "I am a suite"
       }),
@@ -53,8 +53,8 @@ describe("Suite", function() {
   });
 
   it("adds after functions in order of needed execution", function() {
-    var env = new j$.Env(),
-      suite = new j$.Suite({
+    var env = new jasmineUnderTest.Env(),
+      suite = new jasmineUnderTest.Suite({
         env: env,
         description: "I am a suite"
       }),
@@ -68,7 +68,7 @@ describe("Suite", function() {
   });
 
   it('has a status of failed if any afterAll expectations have failed', function() {
-    var suite = new j$.Suite({
+    var suite = new jasmineUnderTest.Suite({
       expectationResultFactory: function() { return 'hi'; }
     });
     suite.addChild({ result: { status: 'done' } });
@@ -78,27 +78,27 @@ describe("Suite", function() {
   });
 
   it("retrieves a result with updated status", function() {
-    var suite = new j$.Suite({});
+    var suite = new jasmineUnderTest.Suite({});
 
     expect(suite.getResult().status).toBe('finished');
   });
 
   it("retrieves a result with disabled status", function() {
-    var suite = new j$.Suite({});
+    var suite = new jasmineUnderTest.Suite({});
     suite.disable();
 
     expect(suite.getResult().status).toBe('disabled');
   });
 
   it("retrieves a result with pending status", function() {
-    var suite = new j$.Suite({});
+    var suite = new jasmineUnderTest.Suite({});
     suite.pend();
 
     expect(suite.getResult().status).toBe('pending');
   });
 
   it("priviledges a disabled status over pending status", function() {
-    var suite = new j$.Suite({});
+    var suite = new jasmineUnderTest.Suite({});
     suite.disable();
     suite.pend();
 
@@ -106,20 +106,20 @@ describe("Suite", function() {
   });
 
   it("is executable if not disabled", function() {
-    var suite = new j$.Suite({});
+    var suite = new jasmineUnderTest.Suite({});
 
     expect(suite.isExecutable()).toBe(true);
   });
 
   it("is not executable if disabled", function() {
-    var suite = new j$.Suite({});
+    var suite = new jasmineUnderTest.Suite({});
     suite.disable();
 
     expect(suite.isExecutable()).toBe(false);
   });
 
   it("tells all children about expectation failures, even if one throws", function() {
-    var suite = new j$.Suite({}),
+    var suite = new jasmineUnderTest.Suite({}),
       child1 = { addExpectationResult: jasmine.createSpy('child1#expectationResult'), result: {} },
       child2 = { addExpectationResult: jasmine.createSpy('child2#expectationResult'), result: {} };
 
@@ -135,7 +135,7 @@ describe("Suite", function() {
   });
 
   it("throws an ExpectationFailed when receiving a failed expectation in an afterAll when throwOnExpectationFailure is set", function() {
-    var suite = new j$.Suite({
+    var suite = new jasmineUnderTest.Suite({
       expectationResultFactory: function(data) { return data; },
       throwOnExpectationFailure: true
     });
@@ -143,17 +143,17 @@ describe("Suite", function() {
 
     expect(function() {
       suite.addExpectationResult(false, 'failed');
-    }).toThrowError(j$.errors.ExpectationFailed);
+    }).toThrowError(jasmineUnderTest.errors.ExpectationFailed);
 
     expect(suite.status()).toBe('failed');
     expect(suite.result.failedExpectations).toEqual(['failed']);
   });
 
   it("does not add an additional failure when an expectation fails in an afterAll", function(){
-    var suite = new j$.Suite({});
+    var suite = new jasmineUnderTest.Suite({});
     suite.addChild({ result: { status: 'done' } });
 
-    suite.onException(new j$.errors.ExpectationFailed());
+    suite.onException(new jasmineUnderTest.errors.ExpectationFailed());
 
     expect(suite.getResult().failedExpectations).toEqual([]);
   })

spec/core/TimerSpec.js

@@ -1,7 +1,7 @@
 describe("Timer", function() {
   it("reports the time elapsed", function() {
     var fakeNow = jasmine.createSpy('fake Date.now'),
-        timer = new j$.Timer({now: fakeNow});
+        timer = new jasmineUnderTest.Timer({now: fakeNow});
 
     fakeNow.and.returnValue(100);
     timer.start();
@@ -22,7 +22,7 @@ describe("Timer", function() {
     });
 
     it("does not throw even though Date was taken away", function() {
-      var timer = new j$.Timer();
+      var timer = new jasmineUnderTest.Timer();
 
       expect(timer.start).not.toThrow();
       expect(timer.elapsed()).toEqual(jasmine.any(Number));

spec/core/TreeProcessorSpec.js

@@ -30,7 +30,7 @@ describe("TreeProcessor", function() {
 
   it("processes a single executable leaf", function() {
     var leaf = new Leaf(),
-        processor = new j$.TreeProcessor({ tree: leaf, runnableIds: [leaf.id] }),
+        processor = new jasmineUnderTest.TreeProcessor({ tree: leaf, runnableIds: [leaf.id] }),
         result = processor.processTree();
 
     expect(result.valid).toBe(true);
@@ -43,7 +43,7 @@ describe("TreeProcessor", function() {
 
   it("processes a single non-executable leaf", function() {
     var leaf = new Leaf({ executable: false }),
-        processor = new j$.TreeProcessor({ tree: leaf, runnableIds: [leaf.id] }),
+        processor = new jasmineUnderTest.TreeProcessor({ tree: leaf, runnableIds: [leaf.id] }),
         result = processor.processTree();
 
     expect(result.valid).toBe(true);
@@ -56,7 +56,7 @@ describe("TreeProcessor", function() {
 
   it("processes a single non-specified leaf", function() {
     var leaf = new Leaf(),
-        processor = new j$.TreeProcessor({ tree: leaf, runnableIds: [] }),
+        processor = new jasmineUnderTest.TreeProcessor({ tree: leaf, runnableIds: [] }),
         result = processor.processTree();
 
     expect(result.valid).toBe(true);
@@ -70,7 +70,7 @@ describe("TreeProcessor", function() {
   it("processes a tree with a single leaf with the root specified", function() {
     var leaf = new Leaf(),
         parent = new Node({ children: [leaf] }),
-        processor = new j$.TreeProcessor({ tree: parent, runnableIds: [parent.id] }),
+        processor = new jasmineUnderTest.TreeProcessor({ tree: parent, runnableIds: [parent.id] }),
         result = processor.processTree();
 
     expect(result.valid).toBe(true);
@@ -89,7 +89,7 @@ describe("TreeProcessor", function() {
   it("processes a tree with a single non-executable leaf, with the root specified", function() {
     var leaf = new Leaf({ executable: false }),
         parent = new Node({ children: [leaf] }),
-        processor = new j$.TreeProcessor({ tree: parent, runnableIds: [parent.id] }),
+        processor = new jasmineUnderTest.TreeProcessor({ tree: parent, runnableIds: [parent.id] }),
         result = processor.processTree();
 
     expect(result.valid).toBe(true);
@@ -113,7 +113,7 @@ describe("TreeProcessor", function() {
         childOfDisabled = new Leaf({ executable: true }),
         disabledNode = new Node({ executable: false, children: [childOfDisabled] }),
         root = new Node({ children: [parent, childless, disabledNode] }),
-        processor = new j$.TreeProcessor({ tree: root, runnableIds: [root.id] }),
+        processor = new jasmineUnderTest.TreeProcessor({ tree: root, runnableIds: [root.id] }),
         result = processor.processTree();
 
     expect(result.valid).toBe(true);
@@ -160,7 +160,7 @@ describe("TreeProcessor", function() {
         leaf3 = new Leaf(),
         reentered = new Node({ noReenter: true, children: [leaf1, leaf2] }),
         root = new Node({ children: [reentered, leaf3] }),
-        processor = new j$.TreeProcessor({ tree: root, runnableIds: [leaf1.id, leaf3.id, leaf2.id] }),
+        processor = new jasmineUnderTest.TreeProcessor({ tree: root, runnableIds: [leaf1.id, leaf3.id, leaf2.id] }),
         result = processor.processTree();
 
     expect(result).toEqual({ valid: false });
@@ -172,7 +172,7 @@ describe("TreeProcessor", function() {
         leaf3 = new Leaf(),
         reentered = new Node({ children: [leaf1, leaf2] }),
         root = new Node({ children: [reentered, leaf3] }),
-        processor = new j$.TreeProcessor({ tree: root, runnableIds: [leaf1.id, leaf3.id, leaf2.id] }),
+        processor = new jasmineUnderTest.TreeProcessor({ tree: root, runnableIds: [leaf1.id, leaf3.id, leaf2.id] }),
         result = processor.processTree();
 
     expect(result.valid).toBe(true);
@@ -184,7 +184,7 @@ describe("TreeProcessor", function() {
         leaf3 = new Leaf(),
         noReentry = new Node({ noReenter: true }),
         root = new Node({ children: [noReentry] }),
-        processor = new j$.TreeProcessor({ tree: root, runnableIds: [leaf2.id, leaf1.id, leaf3.id] }),
+        processor = new jasmineUnderTest.TreeProcessor({ tree: root, runnableIds: [leaf2.id, leaf1.id, leaf3.id] }),
         result = processor.processTree();
 
     expect(result.valid).toBe(true);
@@ -194,7 +194,7 @@ describe("TreeProcessor", function() {
     var leaf1 = new Leaf(),
         noReentry = new Node({ noReenter: true }),
         root = new Node({ children: [noReentry] }),
-        processor = new j$.TreeProcessor({ tree: root, runnableIds: [root.id] }),
+        processor = new jasmineUnderTest.TreeProcessor({ tree: root, runnableIds: [root.id] }),
         result = processor.processTree();
 
     expect(result.valid).toBe(true);
@@ -204,7 +204,7 @@ describe("TreeProcessor", function() {
     var leaf = new Leaf(),
         node = new Node({ children: [leaf], userContext: { root: 'context' } }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({ tree: node, runnableIds: [leaf.id], queueRunnerFactory: queueRunner }),
+        processor = new jasmineUnderTest.TreeProcessor({ tree: node, runnableIds: [leaf.id], queueRunnerFactory: queueRunner }),
         treeComplete = jasmine.createSpy('treeComplete');
 
     processor.execute(treeComplete);
@@ -227,7 +227,7 @@ describe("TreeProcessor", function() {
         nodeStart = jasmine.createSpy('nodeStart'),
         nodeComplete = jasmine.createSpy('nodeComplete'),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [node.id],
           nodeStart: nodeStart,
@@ -269,7 +269,7 @@ describe("TreeProcessor", function() {
         node = new Node({ children: [leaf1, leaf2] }),
         root = new Node({ children: [node] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [node.id],
           queueRunnerFactory: queueRunner
@@ -298,7 +298,7 @@ describe("TreeProcessor", function() {
         queueRunner = jasmine.createSpy('queueRunner'),
         nodeStart = jasmine.createSpy('nodeStart'),
         nodeComplete = jasmine.createSpy('nodeComplete'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [node.id],
           queueRunnerFactory: queueRunner,
@@ -334,7 +334,7 @@ describe("TreeProcessor", function() {
         }),
         root = new Node({ children: [node] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [node.id],
           queueRunnerFactory: queueRunner
@@ -359,7 +359,7 @@ describe("TreeProcessor", function() {
         }),
         root = new Node({ children: [node] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [node.id],
           queueRunnerFactory: queueRunner
@@ -383,7 +383,7 @@ describe("TreeProcessor", function() {
         }),
         root = new Node({ children: [node] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [node.id],
           queueRunnerFactory: queueRunner
@@ -410,7 +410,7 @@ describe("TreeProcessor", function() {
         }),
         root = new Node({ children: [node] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [node.id],
           queueRunnerFactory: queueRunner
@@ -432,7 +432,7 @@ describe("TreeProcessor", function() {
         leaf2 = new Leaf(),
         root = new Node({ children: [leaf1, leaf2] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [leaf2.id, leaf1.id],
           queueRunnerFactory: queueRunner
@@ -456,7 +456,7 @@ describe("TreeProcessor", function() {
         nonSpecified = new Leaf(),
         root = new Node({ children: [nonSpecified, specified] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [specified.id],
           queueRunnerFactory: queueRunner
@@ -481,7 +481,7 @@ describe("TreeProcessor", function() {
         specifiedNode = new Node({ children: [childLeaf] }),
         root = new Node({ children: [specifiedLeaf, specifiedNode] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [specifiedNode.id, specifiedLeaf.id],
           queueRunnerFactory: queueRunner
@@ -511,7 +511,7 @@ describe("TreeProcessor", function() {
         reentered = new Node({ children: [leaf1, leaf2, leaf3] }),
         root = new Node({ children: [reentered, leaf4, leaf5] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [leaf1.id, leaf4.id, leaf2.id, leaf5.id, leaf3.id],
           queueRunnerFactory: queueRunner
@@ -555,7 +555,7 @@ describe("TreeProcessor", function() {
         grandparent = new Node({ children: [parent] }),
         root = new Node({ children: [grandparent, leaf4, leaf5] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [leaf1.id, leaf4.id, leaf2.id, leaf5.id, leaf3.id],
           queueRunnerFactory: queueRunner
@@ -609,7 +609,7 @@ describe("TreeProcessor", function() {
         parent = new Node({ children: [leaf2, leaf3] }),
         root = new Node({ children: [leaf1, parent] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [root.id],
           queueRunnerFactory: queueRunner
@@ -647,7 +647,7 @@ describe("TreeProcessor", function() {
         leaf11 = new Leaf(),
         root = new Node({ children: [leaf1, leaf2, leaf3, leaf4, leaf5, leaf6, leaf7, leaf8, leaf9, leaf10, leaf11] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [root.id],
           queueRunnerFactory: queueRunner
@@ -705,7 +705,7 @@ describe("TreeProcessor", function() {
         leaf11 = new Leaf(),
         root = new Node({ children: [leaf1, leaf2, leaf3, leaf4, leaf5, leaf6, leaf7, leaf8, leaf9, leaf10, leaf11] }),
         queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new j$.TreeProcessor({
+        processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
           runnableIds: [root.id],
           queueRunnerFactory: queueRunner,

spec/core/UtilSpec.js

@@ -1,28 +1,28 @@
-describe("j$.util", function() {
+describe("jasmineUnderTest.util", function() {
   describe("isArray_", function() {
     it("should return true if the argument is an array", function() {
-      expect(j$.isArray_([])).toBe(true);
-      expect(j$.isArray_(['a'])).toBe(true);
+      expect(jasmineUnderTest.isArray_([])).toBe(true);
+      expect(jasmineUnderTest.isArray_(['a'])).toBe(true);
     });
 
     it("should return false if the argument is not an array", function() {
-      expect(j$.isArray_(undefined)).toBe(false);
-      expect(j$.isArray_({})).toBe(false);
-      expect(j$.isArray_(function() {})).toBe(false);
-      expect(j$.isArray_('foo')).toBe(false);
-      expect(j$.isArray_(5)).toBe(false);
-      expect(j$.isArray_(null)).toBe(false);
+      expect(jasmineUnderTest.isArray_(undefined)).toBe(false);
+      expect(jasmineUnderTest.isArray_({})).toBe(false);
+      expect(jasmineUnderTest.isArray_(function() {})).toBe(false);
+      expect(jasmineUnderTest.isArray_('foo')).toBe(false);
+      expect(jasmineUnderTest.isArray_(5)).toBe(false);
+      expect(jasmineUnderTest.isArray_(null)).toBe(false);
     });
   });
 
   describe("isUndefined", function() {
     it("reports if a variable is defined", function() {
       var a;
-      expect(j$.util.isUndefined(a)).toBe(true);
-      expect(j$.util.isUndefined(undefined)).toBe(true);
+      expect(jasmineUnderTest.util.isUndefined(a)).toBe(true);
+      expect(jasmineUnderTest.util.isUndefined(undefined)).toBe(true);
 
       var undefined = "diz be undefined yo";
-      expect(j$.util.isUndefined(undefined)).toBe(false);
+      expect(jasmineUnderTest.util.isUndefined(undefined)).toBe(false);
     });
   });
 });

spec/core/asymmetric_equality/AnySpec.js

@@ -1,43 +1,43 @@
 describe("Any", function() {
   it("matches a string", function() {
-    var any = new j$.Any(String);
+    var any = new jasmineUnderTest.Any(String);
 
     expect(any.asymmetricMatch("foo")).toBe(true);
   });
 
   it("matches a number", function() {
-    var any = new j$.Any(Number);
+    var any = new jasmineUnderTest.Any(Number);
 
     expect(any.asymmetricMatch(1)).toBe(true);
   });
 
   it("matches a function", function() {
-    var any = new j$.Any(Function);
+    var any = new jasmineUnderTest.Any(Function);
 
     expect(any.asymmetricMatch(function(){})).toBe(true);
   });
 
   it("matches an Object", function() {
-    var any = new j$.Any(Object);
+    var any = new jasmineUnderTest.Any(Object);
 
     expect(any.asymmetricMatch({})).toBe(true);
   });
 
   it("matches a Boolean", function() {
-    var any = new j$.Any(Boolean);
+    var any = new jasmineUnderTest.Any(Boolean);
 
     expect(any.asymmetricMatch(true)).toBe(true);
   });
 
   it("matches another constructed object", function() {
     var Thing = function() {},
-      any = new j$.Any(Thing);
+      any = new jasmineUnderTest.Any(Thing);
 
     expect(any.asymmetricMatch(new Thing())).toBe(true);
   });
 
   it("jasmineToString's itself", function() {
-    var any = new j$.Any(Number);
+    var any = new jasmineUnderTest.Any(Number);
 
     expect(any.jasmineToString()).toEqual('<jasmine.any(Number)>');
   });
@@ -45,7 +45,7 @@ describe("Any", function() {
   describe("when called without an argument", function() {
     it("tells the user to pass a constructor or use jasmine.anything()", function() {
       expect(function() {
-        new j$.Any();
+        new jasmineUnderTest.Any();
       }).toThrowError(TypeError, /constructor.*anything/);
     });
   });

spec/core/asymmetric_equality/AnythingSpec.js

@@ -1,43 +1,43 @@
 describe("Anything", function() {
   it("matches a string", function() {
-    var anything = new j$.Anything();
+    var anything = new jasmineUnderTest.Anything();
 
     expect(anything.asymmetricMatch('foo')).toBe(true);
   });
 
   it("matches a number", function() {
-    var anything = new j$.Anything();
+    var anything = new jasmineUnderTest.Anything();
 
     expect(anything.asymmetricMatch(42)).toBe(true);
   });
 
   it("matches an object", function() {
-    var anything = new j$.Anything();
+    var anything = new jasmineUnderTest.Anything();
 
     expect(anything.asymmetricMatch({ foo: 'bar' })).toBe(true);
   });
 
   it("matches an array", function() {
-    var anything = new j$.Anything();
+    var anything = new jasmineUnderTest.Anything();
 
     expect(anything.asymmetricMatch([1,2,3])).toBe(true);
   });
 
   it("doesn't match undefined", function() {
-    var anything = new j$.Anything();
+    var anything = new jasmineUnderTest.Anything();
 
     expect(anything.asymmetricMatch()).toBe(false);
     expect(anything.asymmetricMatch(undefined)).toBe(false);
   });
 
   it("doesn't match null", function() {
-    var anything = new j$.Anything();
+    var anything = new jasmineUnderTest.Anything();
 
     expect(anything.asymmetricMatch(null)).toBe(false);
   });
 
   it("jasmineToString's itself", function() {
-    var anything = new j$.Anything();
+    var anything = new jasmineUnderTest.Anything();
 
     expect(anything.jasmineToString()).toEqual("<jasmine.anything>");
   });

spec/core/asymmetric_equality/ArrayContainingSpec.js

@@ -1,12 +1,12 @@
 describe("ArrayContaining", function() {
   it("matches any actual to an empty array", function() {
-    var containing = new j$.ArrayContaining([]);
+    var containing = new jasmineUnderTest.ArrayContaining([]);
 
     expect(containing.asymmetricMatch("foo")).toBe(true);
   });
 
   it("does not work when not passed an array", function() {
-    var containing = new j$.ArrayContaining("foo");
+    var containing = new jasmineUnderTest.ArrayContaining("foo");
 
     expect(function() {
       containing.asymmetricMatch([]);
@@ -14,25 +14,25 @@ describe("ArrayContaining", function() {
   });
 
   it("matches when the item is in the actual", function() {
-    var containing = new j$.ArrayContaining(["foo"]);
+    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
 
     expect(containing.asymmetricMatch(["foo"])).toBe(true);
   });
 
   it("matches when additional items are in the actual", function() {
-    var containing = new j$.ArrayContaining(["foo"]);
+    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
 
     expect(containing.asymmetricMatch(["foo", "bar"])).toBe(true);
   });
 
   it("does not match when the item is not in the actual", function() {
-    var containing = new j$.ArrayContaining(["foo"]);
+    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
 
     expect(containing.asymmetricMatch(["bar"])).toBe(false);
   });
 
   it("jasmineToStrings itself", function() {
-    var containing = new j$.ArrayContaining([]);
+    var containing = new jasmineUnderTest.ArrayContaining([]);
 
     expect(containing.jasmineToString()).toMatch("<jasmine.arrayContaining");
   });

spec/core/asymmetric_equality/ObjectContainingSpec.js

@@ -1,13 +1,13 @@
 describe("ObjectContaining", function() {
 
   it("matches any actual to an empty object", function() {
-    var containing = new j$.ObjectContaining({});
+    var containing = new jasmineUnderTest.ObjectContaining({});
 
     expect(containing.asymmetricMatch("foo")).toBe(true);
   });
 
   it("does not match an empty object actual", function() {
-    var containing = new j$.ObjectContaining("foo");
+    var containing = new jasmineUnderTest.ObjectContaining("foo");
 
     expect(function() {
       containing.asymmetricMatch({})
@@ -15,43 +15,43 @@ describe("ObjectContaining", function() {
   });
 
   it("matches when the key/value pair is present in the actual", function() {
-    var containing = new j$.ObjectContaining({foo: "fooVal"});
+    var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
 
     expect(containing.asymmetricMatch({foo: "fooVal", bar: "barVal"})).toBe(true);
   });
 
   it("does not match when the key/value pair is not present in the actual", function() {
-    var containing = new j$.ObjectContaining({foo: "fooVal"});
+    var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
 
     expect(containing.asymmetricMatch({bar: "barVal", quux: "quuxVal"})).toBe(false);
   });
 
   it("does not match when the key is present but the value is different in the actual", function() {
-    var containing = new j$.ObjectContaining({foo: "other"});
+    var containing = new jasmineUnderTest.ObjectContaining({foo: "other"});
 
     expect(containing.asymmetricMatch({foo: "fooVal", bar: "barVal"})).toBe(false);
   });
 
   it("jasmineToString's itself", function() {
-    var containing = new j$.ObjectContaining({});
+    var containing = new jasmineUnderTest.ObjectContaining({});
 
     expect(containing.jasmineToString()).toMatch("<jasmine.objectContaining");
   });
 
   it("matches recursively", function() {
-    var containing = new j$.ObjectContaining({one: new j$.ObjectContaining({two: {}})});
+    var containing = new jasmineUnderTest.ObjectContaining({one: new jasmineUnderTest.ObjectContaining({two: {}})});
 
     expect(containing.asymmetricMatch({one: {two: {}}})).toBe(true);
   });
 
   it("matches when key is present with undefined value", function() {
-    var containing = new j$.ObjectContaining({ one: undefined });
+    var containing = new jasmineUnderTest.ObjectContaining({ one: undefined });
 
     expect(containing.asymmetricMatch({ one: undefined })).toBe(true);
   });
 
   it("does not match when key with undefined value is not present", function() {
-    var containing = new j$.ObjectContaining({ one: undefined });
+    var containing = new jasmineUnderTest.ObjectContaining({ one: undefined });
 
     expect(containing.asymmetricMatch({})).toBe(false);
   });
@@ -60,7 +60,7 @@ describe("ObjectContaining", function() {
     // IE 8 doesn't support `definePropery` on non-DOM nodes
     if (jasmine.getEnv().ieVersion < 9) { return; }
 
-    var containing = new j$.ObjectContaining({ foo: "fooVal" });
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
 
     var definedPropertyObject = {};
     Object.defineProperty(definedPropertyObject, "foo", {
@@ -70,7 +70,7 @@ describe("ObjectContaining", function() {
   });
 
   it("matches prototype properties", function(){
-    var containing = new j$.ObjectContaining({ foo: "fooVal" });
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
 
     var prototypeObject = {foo: "fooVal"};
     var obj;

spec/core/asymmetric_equality/StringMatchingSpec.js

@@ -1,13 +1,13 @@
 describe("StringMatching", function() {
   it("matches a string against a provided regexp", function() {
-    var matcher = new j$.StringMatching(/foo/);
+    var matcher = new jasmineUnderTest.StringMatching(/foo/);
 
     expect(matcher.asymmetricMatch('barfoobaz')).toBe(true);
     expect(matcher.asymmetricMatch('barbaz')).toBe(false);
   });
 
   it("matches a string against provided string", function() {
-    var matcher = new j$.StringMatching('foo');
+    var matcher = new jasmineUnderTest.StringMatching('foo');
 
     expect(matcher.asymmetricMatch('barfoobaz')).toBe(true);
     expect(matcher.asymmetricMatch('barbaz')).toBe(false);
@@ -15,12 +15,12 @@ describe("StringMatching", function() {
 
   it("raises an Error when the expected is not a String or RegExp", function() {
     expect(function() {
-      new j$.StringMatching({});
+      new jasmineUnderTest.StringMatching({});
     }).toThrowError(/not a String or a RegExp/);
   });
 
   it("jasmineToString's itself", function() {
-    var matching = new j$.StringMatching(/^foo/);
+    var matching = new jasmineUnderTest.StringMatching(/^foo/);
 
     expect(matching.jasmineToString()).toEqual("<jasmine.stringMatching(/^foo/)>");
   });

spec/core/formatErrorMsgSpec.js

@@ -0,0 +1,13 @@
+describe('formatErrorMsg', function () {
+  it('should format an error with a domain', function() {
+    var formator = jasmineUnderTest.formatErrorMsg('api');
+    expect(formator('message')).toBe('api : message');
+    expect(formator('message2')).toBe('api : message2');
+  });
+
+  it('should format an error with a domain and usage', function() {
+    var formator = jasmineUnderTest.formatErrorMsg('api', 'with a param');
+    expect(formator('message')).toBe('api : message\nUsage: with a param');
+    expect(formator('message2')).toBe('api : message2\nUsage: with a param');
+  });
+});

spec/core/integration/CustomMatchersSpec.js

@@ -3,7 +3,7 @@ describe("Custom Matchers (Integration)", function() {
   var fakeTimer;
 
   beforeEach(function() {
-    env = new j$.Env();
+    env = new jasmineUnderTest.Env();
   });
 
   it("allows adding more matchers local to a spec", function(done) {
@@ -142,7 +142,7 @@ describe("Custom Matchers (Integration)", function() {
     });
 
     var specExpectations = function() {
-      expect(argumentSpy).toHaveBeenCalledWith(j$.matchersUtil, [customEqualityFn]);
+      expect(argumentSpy).toHaveBeenCalledWith(jasmineUnderTest.matchersUtil, [customEqualityFn]);
     };
 
     env.addReporter({ specDone: specExpectations, jasmineDone: done });

spec/core/integration/EnvSpec.js

@@ -41,7 +41,7 @@ describe("Env integration", function() {
   });
 
   it("Suites execute as expected (no nesting)", function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
         calls = [];
 
     var assertions = function() {
@@ -68,7 +68,7 @@ describe("Env integration", function() {
   });
 
   it("Nested Suites execute as expected", function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
         calls = [];
 
     var assertions = function() {
@@ -101,7 +101,7 @@ describe("Env integration", function() {
   });
 
   it("Multiple top-level Suites execute as expected", function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
         calls = [];
 
     var assertions = function() {
@@ -142,7 +142,7 @@ describe("Env integration", function() {
   });
 
   it('explicitly fails a spec', function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
         specDone = jasmine.createSpy('specDone');
 
     env.addReporter({
@@ -204,7 +204,7 @@ describe("Env integration", function() {
 
 
   it("calls associated befores/specs/afters with the same 'this'", function(done) {
-    var env = new j$.Env();
+    var env = new jasmineUnderTest.Env();
 
     env.addReporter({jasmineDone: done});
     env.describe("tests", function() {
@@ -241,7 +241,7 @@ describe("Env integration", function() {
   });
 
   it("calls associated befores/its/afters with the same 'this' for an async spec", function(done) {
-    var env = new j$.Env();
+    var env = new jasmineUnderTest.Env();
 
     env.addReporter({jasmineDone: done});
 
@@ -267,7 +267,7 @@ describe("Env integration", function() {
   });
 
   it("calls associated beforeAlls/afterAlls only once per suite", function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
         before = jasmine.createSpy('beforeAll'),
         after = jasmine.createSpy('afterAll');
 
@@ -299,7 +299,7 @@ describe("Env integration", function() {
   });
 
   it("calls associated beforeAlls/afterAlls only once per suite for async", function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
         before = jasmine.createSpy('beforeAll'),
         after = jasmine.createSpy('afterAll');
 
@@ -338,7 +338,7 @@ describe("Env integration", function() {
   });
 
   it("calls associated beforeAlls/afterAlls with the cascaded 'this'", function(done) {
-    var env = new j$.Env();
+    var env = new jasmineUnderTest.Env();
 
     env.addReporter({jasmineDone: done});
 
@@ -392,7 +392,7 @@ describe("Env integration", function() {
   });
 
   it("fails all underlying specs when the beforeAll fails", function (done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
       reporter = jasmine.createSpyObj('fakeReporter', [ "specDone", "jasmineDone" ]);
 
     reporter.jasmineDone.and.callFake(function() {
@@ -431,7 +431,7 @@ describe("Env integration", function() {
 
   describe('suiteDone reporting', function(){
     it("reports when an afterAll fails an expectation", function(done) {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
 
       reporter.jasmineDone.and.callFake(function() {
@@ -458,35 +458,35 @@ describe("Env integration", function() {
     });
 
     it("if there are no specs, it still reports correctly", function(done) {
-        var env = new j$.Env(),
-          reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
+      var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
 
-        reporter.jasmineDone.and.callFake(function() {
-          expect(reporter.suiteDone).toHaveFailedExpecationsForRunnable('outer suite', [
-            'Expected 1 to equal 2.',
-            'Expected 2 to equal 3.'
-          ]);
-          done();
-        });
-
-        env.addReporter(reporter);
-
-        env.describe('outer suite', function() {
-          env.describe('inner suite', function() {
-            env.it('spec', function(){ });
-          });
-
-          env.afterAll(function() {
-            env.expect(1).toEqual(2);
-            env.expect(2).toEqual(3);
-          });
-        });
-
-        env.execute();
+      reporter.jasmineDone.and.callFake(function() {
+        expect(reporter.suiteDone).toHaveFailedExpecationsForRunnable('outer suite', [
+          'Expected 1 to equal 2.',
+          'Expected 2 to equal 3.'
+        ]);
+        done();
       });
 
+      env.addReporter(reporter);
+
+      env.describe('outer suite', function() {
+        env.describe('inner suite', function() {
+          env.it('spec', function(){ });
+        });
+
+        env.afterAll(function() {
+          env.expect(1).toEqual(2);
+          env.expect(2).toEqual(3);
+        });
+      });
+
+      env.execute();
+    });
+
     it("reports when afterAll throws an exception", function(done) {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         error = new Error('After All Exception'),
         reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
 
@@ -512,7 +512,7 @@ describe("Env integration", function() {
     });
 
     it("reports when an async afterAll fails an expectation", function(done) {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
 
       reporter.jasmineDone.and.callFake(function() {
@@ -538,7 +538,7 @@ describe("Env integration", function() {
     });
 
     it("reports when an async afterAll throws an exception", function(done) {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         error = new Error('After All Exception'),
         reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
 
@@ -565,8 +565,55 @@ describe("Env integration", function() {
     });
   });
 
+  it('cascades expecatation failures in global beforeAll down to children', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      reporter = jasmine.createSpyObj(['specDone', 'jasmineDone']);
+
+    reporter.jasmineDone.and.callFake(function(results) {
+      expect(results.failedExpectations).toEqual([]);
+      expect(reporter.specDone).toHaveFailedExpecationsForRunnable('is a spec', [
+        'Expected 1 to be 0.'
+      ]);
+      done();
+    });
+
+    env.beforeAll(function() {
+      env.expect(1).toBe(0);
+    });
+
+    env.it('is a spec', function() {
+      env.expect(true).toBe(true);
+    });
+
+    env.addReporter(reporter);
+
+    env.execute();
+  });
+
+  it('reports expectation failures in global afterAll', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      reporter = jasmine.createSpyObj(['jasmineDone']);
+
+    reporter.jasmineDone.and.callFake(function(results) {
+      expect(results.failedExpectations).toEqual([jasmine.objectContaining({ message: 'Expected 1 to be 0.' })]);
+      done();
+    });
+
+    env.afterAll(function() {
+      env.expect(1).toBe(0);
+    });
+
+    env.it('is a spec', function() {
+      env.expect(true).toBe(true);
+    });
+
+    env.addReporter(reporter);
+
+    env.execute();
+  });
+
   it("Allows specifying which specs and suites to run", function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
         calls = [],
         suiteCallback = jasmine.createSpy('suite callback'),
         firstSpec,
@@ -602,7 +649,7 @@ describe("Env integration", function() {
   });
 
   it('runs before and after all functions for runnables provided to .execute()', function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
       calls = [],
       first_spec,
       second_spec;
@@ -638,7 +685,7 @@ describe("Env integration", function() {
   });
 
   it("Functions can be spied on and have their calls tracked", function (done) {
-    var env = new j$.Env();
+    var env = new jasmineUnderTest.Env();
 
     var originalFunctionWasCalled = false;
     var subject = {
@@ -677,8 +724,33 @@ describe("Env integration", function() {
     env.execute();
   });
 
+  it('can be configured to allow respying on functions', function () {
+    var env = new jasmineUnderTest.Env(),
+        foo = {
+          bar: function () {
+            return 1;
+          }
+        };
+
+    env.allowRespy(true);
+
+    env.describe('test suite', function(){
+      env.it('spec 0', function(){
+        env.spyOn(foo,'bar');
+
+        var error = null;
+
+        expect(function() {
+          env.spyOn(foo, 'bar');
+        }).not.toThrow();
+      });
+    });
+
+    env.execute();
+  });
+
   it('removes all spies added in a spec after the spec is complete', function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
       originalFoo = function() {},
       testObj = {
         foo: originalFoo
@@ -706,7 +778,7 @@ describe("Env integration", function() {
   });
 
   it('removes all spies added in a suite after the suite is complete', function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
       originalFoo = function() {},
       testObj = {
         foo: originalFoo
@@ -716,17 +788,17 @@ describe("Env integration", function() {
         env.beforeAll(function() { env.spyOn(testObj, 'foo');})
 
         env.it('spec 0', function() {
-          expect(j$.isSpy(testObj.foo)).toBe(true);
+          expect(jasmineUnderTest.isSpy(testObj.foo)).toBe(true);
         });
 
         env.it('spec 1', function() {
-          expect(j$.isSpy(testObj.foo)).toBe(true);
+          expect(jasmineUnderTest.isSpy(testObj.foo)).toBe(true);
         });
       });
 
       env.describe('another suite', function() {
         env.it('spec 2', function() {
-          expect(j$.isSpy(testObj.foo)).toBe(false);
+          expect(jasmineUnderTest.isSpy(testObj.foo)).toBe(false);
         });
       });
 
@@ -735,11 +807,36 @@ describe("Env integration", function() {
     env.execute();
   });
 
+  it('removes a spy from the top suite after the run is complete', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      originalFoo = function() {},
+      testObj = {
+        foo: originalFoo
+      };
+
+    env.beforeAll(function() {
+      env.spyOn(testObj, 'foo');
+    });
+
+    env.it('spec', function() {
+      expect(jasmineUnderTest.isSpy(testObj.foo)).toBe(true);
+    });
+
+    env.addReporter({
+      jasmineDone: function() {
+        expect(jasmineUnderTest.isSpy(testObj.foo)).toBe(false);
+        done();
+      }
+    });
+
+    env.execute();
+  });
+
   it("Mock clock can be installed and used in tests", function(done) {
     var globalSetTimeout = jasmine.createSpy('globalSetTimeout'),
         delayedFunctionForGlobalClock = jasmine.createSpy('delayedFunctionForGlobalClock'),
         delayedFunctionForMockClock = jasmine.createSpy('delayedFunctionForMockClock'),
-        env = new j$.Env({global: { setTimeout: globalSetTimeout }});
+        env = new jasmineUnderTest.Env({global: { setTimeout: globalSetTimeout }});
 
     var assertions = function() {
       expect(delayedFunctionForMockClock).toHaveBeenCalled();
@@ -769,7 +866,7 @@ describe("Env integration", function() {
   });
 
   it("should run async specs in order, waiting for them to complete", function(done) {
-    var env = new j$.Env(), mutatedVar;
+    var env = new jasmineUnderTest.Env(), mutatedVar;
 
     env.describe("tests", function() {
       env.beforeEach(function() {
@@ -796,17 +893,17 @@ describe("Env integration", function() {
     var originalTimeout;
 
     beforeEach(function() {
-      originalTimeout = j$.DEFAULT_TIMEOUT_INTERVAL;
+      originalTimeout = jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL;
       jasmine.clock().install();
     });
 
     afterEach(function() {
       jasmine.clock().uninstall();
-      j$.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
+      jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
     });
 
     it("should wait a specified interval before failing specs haven't called done yet", function(done) {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
           reporter = jasmine.createSpyObj('fakeReporter', [ "specDone", "jasmineDone" ]);
 
       reporter.specDone.and.callFake(function() {
@@ -819,7 +916,7 @@ describe("Env integration", function() {
       });
 
       env.addReporter(reporter);
-      j$.DEFAULT_TIMEOUT_INTERVAL = 8414;
+      jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL = 8414;
 
       env.it("async spec that doesn't call done", function(underTestCallback) {
         env.expect(true).toBeTruthy();
@@ -830,7 +927,7 @@ describe("Env integration", function() {
     });
 
     it("should wait a specified interval before failing beforeAll's and their associated specs that haven't called done", function(done) {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         reporter = jasmine.createSpyObj('fakeReporter', [ "specDone", "jasmineDone" ]);
 
       reporter.jasmineDone.and.callFake(function() {
@@ -841,7 +938,7 @@ describe("Env integration", function() {
       });
 
       env.addReporter(reporter);
-      j$.DEFAULT_TIMEOUT_INTERVAL = 1290;
+      jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL = 1290;
 
       env.beforeAll(function(done) {
         jasmine.clock().tick(1290);
@@ -859,7 +956,7 @@ describe("Env integration", function() {
     });
 
     it("should not use the mock clock for asynchronous timeouts", function(){
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         reporter = jasmine.createSpyObj('fakeReporter', [ "specDone", "jasmineDone" ]),
         clock = env.clock;
 
@@ -869,7 +966,7 @@ describe("Env integration", function() {
       });
 
       env.addReporter(reporter);
-      j$.DEFAULT_TIMEOUT_INTERVAL = 5;
+      jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL = 5;
 
       env.beforeAll(function() {
         clock.install();
@@ -889,7 +986,7 @@ describe("Env integration", function() {
     });
 
     it("should wait the specified interval before reporting an afterAll that fails to call done", function(done) {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
       reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
 
       reporter.jasmineDone.and.callFake(function() {
@@ -900,7 +997,7 @@ describe("Env integration", function() {
       });
 
       env.addReporter(reporter);
-      j$.DEFAULT_TIMEOUT_INTERVAL = 3000;
+      jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL = 3000;
 
       env.describe('my suite', function() {
         env.it('my spec', function() {
@@ -916,7 +1013,7 @@ describe("Env integration", function() {
     });
 
     it('should wait a custom interval before reporting async functions that fail to call done', function(done) {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
           reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone', 'suiteDone', 'specDone']);
 
       reporter.jasmineDone.and.callFake(function() {
@@ -944,7 +1041,7 @@ describe("Env integration", function() {
       });
 
       env.addReporter(reporter);
-      j$.DEFAULT_TIMEOUT_INTERVAL = 10000;
+      jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL = 10000;
 
       env.describe('suite', function() {
         env.describe('beforeAll', function() {
@@ -993,7 +1090,7 @@ describe("Env integration", function() {
     });
 
     it('explicitly fails an async spec', function(done) {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
       specDone = jasmine.createSpy('specDone');
 
       env.addReporter({
@@ -1066,7 +1163,7 @@ describe("Env integration", function() {
 
   describe('focused tests', function() {
     it('should only run the focused tests', function(done) {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         calls = [];
 
       var assertions = function() {
@@ -1090,7 +1187,7 @@ describe("Env integration", function() {
     });
 
     it('should only run focused suites', function(){
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         calls = [];
 
       var assertions = function() {
@@ -1116,7 +1213,7 @@ describe("Env integration", function() {
     });
 
     it('should run focused tests inside an xdescribe', function(done) {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         reporter = jasmine.createSpyObj('fakeReporter', [
           "jasmineStarted",
           "jasmineDone",
@@ -1151,7 +1248,7 @@ describe("Env integration", function() {
     });
 
     it('should run focused suites inside an xdescribe', function(done) {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         reporter = jasmine.createSpyObj('fakeReporter', [
           "jasmineStarted",
           "jasmineDone",
@@ -1189,7 +1286,7 @@ describe("Env integration", function() {
   });
 
   it("should report as expected", function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
         reporter = jasmine.createSpyObj('fakeReporter', [
           "jasmineStarted",
           "jasmineDone",
@@ -1259,7 +1356,7 @@ describe("Env integration", function() {
   });
 
   it('should report pending spec messages', function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
         reporter = jasmine.createSpyObj('fakeReporter', [
           'specDone',
           'jasmineDone'
@@ -1282,8 +1379,30 @@ describe("Env integration", function() {
     env.execute();
   });
 
+  it('should report using fallback reporter', function(done) {
+    var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          'specDone',
+          'jasmineDone'
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      expect(reporter.specDone).toHaveBeenCalled();
+
+      done();
+    });
+
+    env.provideFallbackReporter(reporter);
+
+    env.it('will be pending', function() {
+      env.pending('with a message');
+    });
+
+    env.execute();
+  });
+
   it('should report xdescribes as expected', function(done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
         reporter = jasmine.createSpyObj('fakeReporter', [
           "jasmineStarted",
           "jasmineDone",
@@ -1301,7 +1420,7 @@ describe("Env integration", function() {
       expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({ status: 'pending' }));
       expect(reporter.suiteDone).toHaveBeenCalledWith(jasmine.objectContaining({ description: 'xd out', status: 'pending' }));
       expect(reporter.suiteDone.calls.count()).toBe(4);
-      
+
       done();
     });
 
@@ -1323,7 +1442,7 @@ describe("Env integration", function() {
   });
 
   it("should be possible to get full name from a spec", function() {
-    var env = new j$.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
         topLevelSpec, nestedSpec, doublyNestedSpec;
 
     env.describe("my tests", function() {
@@ -1345,7 +1464,7 @@ describe("Env integration", function() {
   });
 
   it("Custom equality testers should be per spec", function(done) {
-    var env = new j$.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
         reporter = jasmine.createSpyObj('fakeReporter', [
           "jasmineDone",
           "specDone"
@@ -1378,7 +1497,7 @@ describe("Env integration", function() {
   });
 
   it("Custom equality testers should be per suite", function(done) {
-    var env = new j$.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
         reporter = jasmine.createSpyObj('fakeReporter', [
           "jasmineDone",
           "specDone"
@@ -1420,7 +1539,7 @@ describe("Env integration", function() {
   });
 
   it("Custom equality testers for toContain should be per spec", function(done) {
-    var env = new j$.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
         reporter = jasmine.createSpyObj('fakeReporter', [
           "jasmineDone",
           "specDone"
@@ -1453,7 +1572,7 @@ describe("Env integration", function() {
   });
 
   it("produces an understandable error message when an 'expect' is used outside of a current spec", function(done) {
-    var env = new j$.Env();
+    var env = new jasmineUnderTest.Env();
 
     env.describe("A Suite", function() {
       env.it("an async spec that is actually synchronous", function(underTestCallback) {
@@ -1467,7 +1586,7 @@ describe("Env integration", function() {
   });
 
   it("Custom equality testers for toContain should be per suite", function(done) {
-    var env = new j$.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
         reporter = jasmine.createSpyObj('fakeReporter', [
           "jasmineDone",
           "specDone"
@@ -1509,7 +1628,7 @@ describe("Env integration", function() {
   });
 
   it("Custom matchers should be per spec", function(done) {
-    var env = new j$.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
         matchers = {
           toFoo: function() {}
         };
@@ -1531,7 +1650,7 @@ describe("Env integration", function() {
   });
 
   it("Custom matchers should be per suite", function(done) {
-    var env = new j$.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
         matchers = {
           toFoo: function() {}
         };
@@ -1560,7 +1679,7 @@ describe("Env integration", function() {
   });
 
   it('throws an exception if you try to create a spy outside of a runnable', function (done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
       obj = {fn: function () {}},
       exception;
 
@@ -1583,7 +1702,7 @@ describe("Env integration", function() {
   });
 
   it('throws an exception if you try to add a matcher outside of a runnable', function (done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
       obj = {fn: function () {}},
       exception;
 
@@ -1606,7 +1725,7 @@ describe("Env integration", function() {
   });
 
   it('throws an exception if you try to add a custom equality outside of a runnable', function (done) {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
       obj = {fn: function () {}},
       exception;
 

spec/core/integration/SpecRunningSpec.js

@@ -2,7 +2,7 @@ describe("jasmine spec running", function () {
   var env;
 
   beforeEach(function() {
-    env = new j$.Env();
+    env = new jasmineUnderTest.Env();
   });
 
   it('should assign spec ids sequentially', function() {
@@ -556,15 +556,24 @@ describe("jasmine spec running", function () {
     env.execute();
   });
 
-  // TODO: is this useful? It doesn't catch syntax errors
-  xit("should recover gracefully when there are errors in describe functions", function() {
-    var specs = [];
-    var superSimpleReporter = new j$.Reporter();
-    superSimpleReporter.reportSpecResults = function(result) {
-      specs.push("Spec: " + result.fullName);
-    };
+  it("should recover gracefully when there are errors in describe functions", function(done) {
+    var specs = [],
+      reporter = jasmine.createSpyObj(['specDone', 'jasmineDone']);
 
-    try {
+    reporter.specDone.and.callFake(function(result) {
+      specs.push(result.fullName);
+    });
+
+    reporter.jasmineDone.and.callFake(function() {
+      expect(specs).toContain('outer1 inner1 should thingy');
+      expect(specs).toContain('outer1 inner1 encountered a declaration exception');
+      expect(specs).toContain('outer1 inner2 should other thingy');
+      expect(specs).toContain('outer1 encountered a declaration exception');
+      expect(specs).toContain('outer2 should xxx');
+      done();
+    });
+
+    expect(function() {
       env.describe("outer1", function() {
         env.describe("inner1", function() {
           env.it("should thingy", function() {
@@ -583,8 +592,7 @@ describe("jasmine spec running", function () {
         throw new Error("fake error");
 
       });
-    } catch(e) {
-    }
+    }).not.toThrow();
 
     env.describe("outer2", function() {
       env.it("should xxx", function() {
@@ -592,17 +600,8 @@ describe("jasmine spec running", function () {
       });
     });
 
-    env.addReporter(superSimpleReporter);
+    env.addReporter(reporter);
     env.execute();
-
-    expect(specs.join('')).toMatch(new RegExp(
-      'Spec: outer1 inner1 should thingy.' +
-      'Spec: outer1 inner1 encountered a declaration exception.' +
-      'Spec: outer1 inner2 should other thingy.' +
-      'Spec: outer1 encountered a declaration exception.' +
-      'Spec: outer2 should xxx.'
-    ));
-
   });
 
   it("re-enters suites that have no *Alls", function(done) {

spec/core/matchers/matchersUtilSpec.js

@@ -1,61 +1,68 @@
 describe("matchersUtil", function() {
   describe("equals", function() {
     it("passes for literals that are triple-equal", function() {
-      expect(j$.matchersUtil.equals(null, null)).toBe(true);
-      expect(j$.matchersUtil.equals(void 0, void 0)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(null, null)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(void 0, void 0)).toBe(true);
     });
 
     it("fails for things that are not equivalent", function() {
-      expect(j$.matchersUtil.equals({a: "foo"}, 1)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals({a: "foo"}, 1)).toBe(false);
     });
 
     it("passes for Strings that are equivalent", function() {
-      expect(j$.matchersUtil.equals("foo", "foo")).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals("foo", "foo")).toBe(true);
     });
 
     it("fails for Strings that are not equivalent", function() {
-      expect(j$.matchersUtil.equals("foo", "bar")).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals("foo", "bar")).toBe(false);
     });
 
     it("passes for Numbers that are equivalent", function() {
-      expect(j$.matchersUtil.equals(123, 123)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(123, 123)).toBe(true);
     });
 
     it("fails for Numbers that are not equivalent", function() {
-      expect(j$.matchersUtil.equals(123, 456)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(123, 456)).toBe(false);
     });
 
     it("passes for Dates that are equivalent", function() {
-      expect(j$.matchersUtil.equals(new Date("Jan 1, 1970"), new Date("Jan 1, 1970"))).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(new Date("Jan 1, 1970"), new Date("Jan 1, 1970"))).toBe(true);
     });
 
     it("fails for Dates that are not equivalent", function() {
-      expect(j$.matchersUtil.equals(new Date("Jan 1, 1970"), new Date("Feb 3, 1991"))).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(new Date("Jan 1, 1970"), new Date("Feb 3, 1991"))).toBe(false);
     });
 
     it("passes for Booleans that are equivalent", function() {
-      expect(j$.matchersUtil.equals(true, true)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(true, true)).toBe(true);
     });
 
     it("fails for Booleans that are not equivalent", function() {
-      expect(j$.matchersUtil.equals(true, false)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(true, false)).toBe(false);
     });
 
     it("passes for RegExps that are equivalent", function() {
-      expect(j$.matchersUtil.equals(/foo/, /foo/)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(/foo/, /foo/)).toBe(true);
     });
 
     it("fails for RegExps that are not equivalent", function() {
-      expect(j$.matchersUtil.equals(/foo/, /bar/)).toBe(false);
-      expect(j$.matchersUtil.equals(new RegExp("foo", "i"), new RegExp("foo"))).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(/foo/, /bar/)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(new RegExp("foo", "i"), new RegExp("foo"))).toBe(false);
     });
 
     it("passes for Arrays that are equivalent", function() {
-      expect(j$.matchersUtil.equals([1, 2], [1, 2])).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals([1, 2], [1, 2])).toBe(true);
+    });
+
+    it("passes for Arrays that are equivalent, with elements added by changing length", function() {
+      var foo = [];
+      foo.length = 1;
+
+      expect(jasmineUnderTest.matchersUtil.equals(foo, [undefined])).toBe(true);
     });
 
     it("fails for Arrays that are not equivalent", function() {
-      expect(j$.matchersUtil.equals([1, 2], [1, 2, 3])).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals([1, 2], [1, 2, 3])).toBe(false);
     });
 
     it("fails for Arrays whose contents are equivalent, but have differing properties", function() {
@@ -65,31 +72,48 @@ describe("matchersUtil", function() {
       one.foo = 'bar';
       two.foo = 'baz';
 
-      expect(j$.matchersUtil.equals(one, two)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(one, two)).toBe(false);
+    });
+
+    it("passes for Arrays with equivalent contents and properties", function() {
+      var one = [1,2,3],
+          two = [1,2,3];
+
+      one.foo = 'bar';
+      two.foo = 'bar';
+
+      expect(jasmineUnderTest.matchersUtil.equals(one, two)).toBe(true);
     });
 
     it("passes for Errors that are the same type and have the same message", function() {
-      expect(j$.matchersUtil.equals(new Error("foo"), new Error("foo"))).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(new Error("foo"), new Error("foo"))).toBe(true);
     });
 
     it("fails for Errors that are the same type and have different messages", function() {
-      expect(j$.matchersUtil.equals(new Error("foo"), new Error("bar"))).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(new Error("foo"), new Error("bar"))).toBe(false);
+    });
+
+    it("fails for objects with different constructors", function() {
+      function One() {}
+      function Two() {}
+
+      expect(jasmineUnderTest.matchersUtil.equals(new One(), new Two())).toBe(false);
     });
 
     it("passes for Objects that are equivalent (simple case)", function() {
-      expect(j$.matchersUtil.equals({a: "foo"}, {a: "foo"})).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals({a: "foo"}, {a: "foo"})).toBe(true);
     });
 
     it("fails for Objects that are not equivalent (simple case)", function() {
-      expect(j$.matchersUtil.equals({a: "foo"}, {a: "bar"})).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals({a: "foo"}, {a: "bar"})).toBe(false);
     });
 
     it("passes for Objects that are equivalent (deep case)", function() {
-      expect(j$.matchersUtil.equals({a: "foo", b: { c: "bar"}}, {a: "foo", b: { c: "bar"}})).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals({a: "foo", b: { c: "bar"}}, {a: "foo", b: { c: "bar"}})).toBe(true);
     });
 
     it("fails for Objects that are not equivalent (deep case)", function() {
-      expect(j$.matchersUtil.equals({a: "foo", b: { c: "baz"}}, {a: "foo", b: { c: "bar"}})).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals({a: "foo", b: { c: "baz"}}, {a: "foo", b: { c: "bar"}})).toBe(false);
     });
 
     it("passes for Objects that are equivalent (with cycles)", function() {
@@ -99,7 +123,7 @@ describe("matchersUtil", function() {
       actual.b = actual;
       expected.b = actual;
 
-      expect(j$.matchersUtil.equals(actual, expected)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(actual, expected)).toBe(true);
     });
 
     it("fails for Objects that are not equivalent (with cycles)", function() {
@@ -109,15 +133,15 @@ describe("matchersUtil", function() {
       actual.b = actual;
       expected.b = actual;
 
-      expect(j$.matchersUtil.equals(actual, expected)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(actual, expected)).toBe(false);
     });
 
     it("fails when comparing an empty object to an empty array (issue #114)", function() {
       var emptyObject = {},
         emptyArray = [];
 
-      expect(j$.matchersUtil.equals(emptyObject, emptyArray)).toBe(false);
-      expect(j$.matchersUtil.equals(emptyArray, emptyObject)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(emptyObject, emptyArray)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(emptyArray, emptyObject)).toBe(false);
     });
 
     it("passes for equivalent frozen objects (GitHub issue #266)", function() {
@@ -129,89 +153,115 @@ describe("matchersUtil", function() {
       Object.freeze(a);
       Object.freeze(b);
 
-      expect(j$.matchersUtil.equals(a,b)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(a,b)).toBe(true);
     });
 
-    it("passes for equivalent DOM nodes", function() {
-      if (typeof document === 'undefined') {
-        return;
+    describe("when running in a browser", function() {
+      function isNotRunningInBrowser() {
+        return typeof document === 'undefined'
       }
-      var a = document.createElement("div");
-      a.setAttribute("test-attr", "attr-value")
-      a.appendChild(document.createTextNode('test'));
 
-      var b = document.createElement("div");
-      b.setAttribute("test-attr", "attr-value")
-      b.appendChild(document.createTextNode('test'));
+      it("passes for equivalent DOM nodes", function() {
+        if (isNotRunningInBrowser()) {
+          return;
+        }
+        var a = document.createElement("div");
+        a.setAttribute("test-attr", "attr-value");
+        a.appendChild(document.createTextNode('test'));
 
-      expect(j$.matchersUtil.equals(a,b)).toBe(true);
+        var b = document.createElement("div");
+        b.setAttribute("test-attr", "attr-value");
+        b.appendChild(document.createTextNode('test'));
+
+        expect(jasmineUnderTest.matchersUtil.equals(a,b)).toBe(true);
+      });
+
+      it("passes for equivalent objects from different frames", function() {
+        if (isNotRunningInBrowser()) {
+          return;
+        }
+        // iframe.contentWindow.eval isn't supported in ie8
+        if (jasmine.getEnv().ieVersion < 9) {
+          return;
+        }
+        var iframe = document.createElement('iframe');
+        document.body.appendChild(iframe);
+        iframe.contentWindow.eval('window.testObject = {}');
+        expect(jasmineUnderTest.matchersUtil.equals({}, iframe.contentWindow.testObject)).toBe(true);
+        document.body.removeChild(iframe);
+      });
+
+      it("fails for DOM nodes with different attributes or child nodes", function() {
+        if (isNotRunningInBrowser()) {
+          return;
+        }
+        var a = document.createElement("div");
+        a.setAttribute("test-attr", "attr-value")
+        a.appendChild(document.createTextNode('test'));
+
+        var b = document.createElement("div");
+        b.setAttribute("test-attr", "attr-value2")
+        b.appendChild(document.createTextNode('test'));
+
+        expect(jasmineUnderTest.matchersUtil.equals(a,b)).toBe(false);
+
+        b.setAttribute("test-attr", "attr-value");
+        expect(jasmineUnderTest.matchersUtil.equals(a,b)).toBe(true);
+
+        b.appendChild(document.createTextNode('2'));
+        expect(jasmineUnderTest.matchersUtil.equals(a,b)).toBe(false);
+
+        a.appendChild(document.createTextNode('2'));
+        expect(jasmineUnderTest.matchersUtil.equals(a,b)).toBe(true);
+      });
     });
 
-    it("fails for DOM nodes with different attributes or child nodes", function() {
-      if (typeof document === 'undefined') {
-        return;
-      }
-      var a = document.createElement("div");
-      a.setAttribute("test-attr", "attr-value")
-      a.appendChild(document.createTextNode('test'));
-
-      var b = document.createElement("div");
-      b.setAttribute("test-attr", "attr-value2")
-      b.appendChild(document.createTextNode('test'));
-
-      expect(j$.matchersUtil.equals(a,b)).toBe(false);
-
-      b.setAttribute("test-attr", "attr-value");
-      expect(j$.matchersUtil.equals(a,b)).toBe(true);
-
-      b.appendChild(document.createTextNode('2'));
-      expect(j$.matchersUtil.equals(a,b)).toBe(false);
-
-      a.appendChild(document.createTextNode('2'));
-      expect(j$.matchersUtil.equals(a,b)).toBe(true);
-    });
-
-    it("passes for equivalent objects from different vm contexts", function() {
-      if (typeof require !== 'function') {
-        return;
-      }
-      var vm = require('vm');
-      var sandbox = {
-        obj: null
-      };
-      vm.runInNewContext('obj = {a: 1, b: 2}', sandbox);
-
-      expect(j$.matchersUtil.equals(sandbox.obj, {a: 1, b: 2})).toBe(true);
-    });
-
-    it("passes for equivalent arrays from different vm contexts", function() {
-      if (typeof require !== 'function') {
-        return;
+    describe("when running in Node", function() {
+      function isNotRunningInNode() {
+        return typeof require !== 'function'
       }
 
-      var vm = require('vm');
-      var sandbox = {
-        arr: null
-      };
-      vm.runInNewContext('arr = [1, 2]', sandbox);
+      it("passes for equivalent objects from different vm contexts", function() {
+        if (isNotRunningInNode()) {
+          return;
+        }
+        var vm = require('vm');
+        var sandbox = {
+          obj: null
+        };
+        vm.runInNewContext('obj = {a: 1, b: 2}', sandbox);
 
-      expect(j$.matchersUtil.equals(sandbox.arr, [1, 2])).toBe(true);
+        expect(jasmineUnderTest.matchersUtil.equals(sandbox.obj, {a: 1, b: 2})).toBe(true);
+      });
+
+      it("passes for equivalent arrays from different vm contexts", function() {
+        if (isNotRunningInNode()) {
+          return;
+        }
+        var vm = require('vm');
+        var sandbox = {
+          arr: null
+        };
+        vm.runInNewContext('arr = [1, 2]', sandbox);
+
+        expect(jasmineUnderTest.matchersUtil.equals(sandbox.arr, [1, 2])).toBe(true);
+      });
     });
 
     it("passes when Any is used", function() {
       var number = 3,
-        anyNumber = new j$.Any(Number);
+        anyNumber = new jasmineUnderTest.Any(Number);
 
-      expect(j$.matchersUtil.equals(number, anyNumber)).toBe(true);
-      expect(j$.matchersUtil.equals(anyNumber, number)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(number, anyNumber)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(anyNumber, number)).toBe(true);
     });
 
     it("fails when Any is compared to something unexpected", function() {
       var number = 3,
-        anyString = new j$.Any(String);
+        anyString = new jasmineUnderTest.Any(String);
 
-      expect(j$.matchersUtil.equals(number, anyString)).toBe(false);
-      expect(j$.matchersUtil.equals(anyString, number)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(number, anyString)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(anyString, number)).toBe(false);
     });
 
     it("passes when ObjectContaining is used", function() {
@@ -219,69 +269,69 @@ describe("matchersUtil", function() {
         foo: 3,
         bar: 7
       },
-      containing = new j$.ObjectContaining({foo: 3});
+      containing = new jasmineUnderTest.ObjectContaining({foo: 3});
 
-      expect(j$.matchersUtil.equals(obj, containing)).toBe(true);
-      expect(j$.matchersUtil.equals(containing, obj)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(obj, containing)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(containing, obj)).toBe(true);
     });
 
     it("passes when an asymmetric equality tester returns true", function() {
       var tester = { asymmetricMatch: function(other) { return true; } };
 
-      expect(j$.matchersUtil.equals(false, tester)).toBe(true);
-      expect(j$.matchersUtil.equals(tester, false)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(false, tester)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(tester, false)).toBe(true);
     });
 
     it("fails when an asymmetric equality tester returns false", function() {
       var tester = { asymmetricMatch: function(other) { return false; } };
 
-      expect(j$.matchersUtil.equals(true, tester)).toBe(false);
-      expect(j$.matchersUtil.equals(tester, true)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(true, tester)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(tester, true)).toBe(false);
     });
 
     it("passes when ArrayContaining is used", function() {
       var arr = ["foo", "bar"];
 
-      expect(j$.matchersUtil.equals(arr, new j$.ArrayContaining(["bar"]))).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(arr, new jasmineUnderTest.ArrayContaining(["bar"]))).toBe(true);
     });
 
     it("passes when a custom equality matcher returns true", function() {
       var tester = function(a, b) { return true; };
 
-      expect(j$.matchersUtil.equals(1, 2, [tester])).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(1, 2, [tester])).toBe(true);
     });
 
     it("passes for two empty Objects", function () {
-      expect(j$.matchersUtil.equals({}, {})).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals({}, {})).toBe(true);
     });
 
     describe("when a custom equality matcher is installed that returns 'undefined'", function () {
       var tester = function(a, b) { return jasmine.undefined; };
 
       it("passes for two empty Objects", function () {
-        expect(j$.matchersUtil.equals({}, {}, [tester])).toBe(true);
+        expect(jasmineUnderTest.matchersUtil.equals({}, {}, [tester])).toBe(true);
       });
     });
 
     it("fails for equivalents when a custom equality matcher returns false", function() {
       var tester = function(a, b) { return false; };
 
-      expect(j$.matchersUtil.equals(1, 1, [tester])).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(1, 1, [tester])).toBe(false);
     });
 
     it("passes for an asymmetric equality tester that returns true when a custom equality tester return false", function() {
       var asymmetricTester = { asymmetricMatch: function(other) { return true; } },
           symmetricTester = function(a, b) { return false; };
 
-      expect(j$.matchersUtil.equals(asymmetricTester, true, [symmetricTester])).toBe(true);
-      expect(j$.matchersUtil.equals(true, asymmetricTester, [symmetricTester])).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(asymmetricTester, true, [symmetricTester])).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(true, asymmetricTester, [symmetricTester])).toBe(true);
     });
 
     it("passes when an Any is compared to an Any that checks for the same type", function() {
-      var any1 = new j$.Any(Function),
-          any2 = new j$.Any(Function);
+      var any1 = new jasmineUnderTest.Any(Function),
+          any2 = new jasmineUnderTest.Any(Function);
 
-      expect(j$.matchersUtil.equals(any1, any2)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(any1, any2)).toBe(true);
     });
 
     it("passes for null prototype objects with same properties", function () {
@@ -293,7 +343,7 @@ describe("matchersUtil", function() {
       objA.name = 'test';
       objB.name = 'test';
 
-      expect(j$.matchersUtil.equals(objA, objB)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(objA, objB)).toBe(true);
     });
 
     it("fails for null prototype objects with different properties", function () {
@@ -305,44 +355,44 @@ describe("matchersUtil", function() {
       objA.name = 'test';
       objB.test = 'name';
 
-      expect(j$.matchersUtil.equals(objA, objB)).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.equals(objA, objB)).toBe(false);
     });
   });
 
   describe("contains", function() {
     it("passes when expected is a substring of actual", function() {
-      expect(j$.matchersUtil.contains("ABC", "BC")).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.contains("ABC", "BC")).toBe(true);
     });
 
     it("fails when expected is a not substring of actual", function() {
-      expect(j$.matchersUtil.contains("ABC", "X")).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.contains("ABC", "X")).toBe(false);
     });
 
     it("passes when expected is an element in an actual array", function() {
-      expect(j$.matchersUtil.contains(['foo', 'bar'], 'foo')).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.contains(['foo', 'bar'], 'foo')).toBe(true);
     });
 
     it("fails when expected is not an element in an actual array", function() {
-      expect(j$.matchersUtil.contains(['foo', 'bar'], 'baz')).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.contains(['foo', 'bar'], 'baz')).toBe(false);
     });
 
     it("passes with mixed-element arrays", function() {
-      expect(j$.matchersUtil.contains(["foo", {some: "bar"}], "foo")).toBe(true);
-      expect(j$.matchersUtil.contains(["foo", {some: "bar"}], {some: "bar"})).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.contains(["foo", {some: "bar"}], "foo")).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.contains(["foo", {some: "bar"}], {some: "bar"})).toBe(true);
     });
 
     it("uses custom equality testers if passed in and actual is an Array", function() {
       var customTester = function(a, b) {return true;};
 
-      expect(j$.matchersUtil.contains([1, 2], 2, [customTester])).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.contains([1, 2], 2, [customTester])).toBe(true);
     });
 
     it("fails when actual is undefined", function() {
-      expect(j$.matchersUtil.contains(undefined, 'A')).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.contains(undefined, 'A')).toBe(false);
     });
 
     it("fails when actual is null", function() {
-      expect(j$.matchersUtil.contains(null, 'A')).toBe(false);
+      expect(jasmineUnderTest.matchersUtil.contains(null, 'A')).toBe(false);
     });
 
     it("passes with array-like objects", function() {
@@ -351,7 +401,7 @@ describe("matchersUtil", function() {
         capturedArgs = arguments;
       }
       testFunction('foo', 'bar');
-      expect(j$.matchersUtil.contains(capturedArgs, 'bar')).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.contains(capturedArgs, 'bar')).toBe(true);
     });
   });
 
@@ -360,7 +410,7 @@ describe("matchersUtil", function() {
     it("builds an English sentence for a failure case", function() {
       var actual = "foo",
         name = "toBar",
-        message = j$.matchersUtil.buildFailureMessage(name, false, actual);
+        message = jasmineUnderTest.matchersUtil.buildFailureMessage(name, false, actual);
 
       expect(message).toEqual("Expected 'foo' to bar.");
     });
@@ -369,7 +419,7 @@ describe("matchersUtil", function() {
       var actual = "foo",
         name = "toBar",
         isNot = true,
-        message = message = j$.matchersUtil.buildFailureMessage(name, isNot, actual);
+        message = message = jasmineUnderTest.matchersUtil.buildFailureMessage(name, isNot, actual);
 
       expect(message).toEqual("Expected 'foo' not to bar.");
     });
@@ -377,7 +427,7 @@ describe("matchersUtil", function() {
     it("builds an English sentence for an arbitrary array of expected arguments", function() {
       var actual = "foo",
         name = "toBar",
-        message = j$.matchersUtil.buildFailureMessage(name, false, actual, "quux", "corge");
+        message = jasmineUnderTest.matchersUtil.buildFailureMessage(name, false, actual, "quux", "corge");
 
       expect(message).toEqual("Expected 'foo' to bar 'quux', 'corge'.");
     });

spec/core/matchers/toBeCloseToSpec.js

@@ -1,6 +1,6 @@
 describe("toBeCloseTo", function() {
   it("passes when within two decimal places by default", function() {
-    var matcher = j$.matchers.toBeCloseTo(),
+    var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
     result = matcher.compare(0, 0);
@@ -11,7 +11,7 @@ describe("toBeCloseTo", function() {
   });
 
   it("fails when not within two decimal places by default", function() {
-    var matcher = j$.matchers.toBeCloseTo(),
+    var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
     result = matcher.compare(0, 0.01);
@@ -19,7 +19,7 @@ describe("toBeCloseTo", function() {
   });
 
   it("accepts an optional precision argument", function() {
-    var matcher = j$.matchers.toBeCloseTo(),
+    var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
     result = matcher.compare(0, 0.1, 0);
@@ -30,7 +30,7 @@ describe("toBeCloseTo", function() {
   });
 
   it("rounds expected values", function() {
-    var matcher = j$.matchers.toBeCloseTo(),
+    var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
     result = matcher.compare(1.23, 1.229);

spec/core/matchers/toBeDefinedSpec.js

@@ -1,6 +1,6 @@
 describe("toBeDefined", function() {
   it("matches for defined values", function() {
-    var matcher = j$.matchers.toBeDefined(),
+    var matcher = jasmineUnderTest.matchers.toBeDefined(),
       result;
 
 
@@ -9,7 +9,7 @@ describe("toBeDefined", function() {
   });
 
   it("fails when matching undefined values", function() {
-    var matcher = j$.matchers.toBeDefined(),
+    var matcher = jasmineUnderTest.matchers.toBeDefined(),
       result;
 
     result = matcher.compare(void 0);

spec/core/matchers/toBeFalsySpec.js

@@ -1,6 +1,6 @@
 describe("toBeFalsy", function() {
   it("passes for 'falsy' values", function() {
-    var matcher = j$.matchers.toBeFalsy(),
+    var matcher = jasmineUnderTest.matchers.toBeFalsy(),
       result;
 
     result = matcher.compare(false);
@@ -20,7 +20,7 @@ describe("toBeFalsy", function() {
   });
 
   it("fails for 'truthy' values", function() {
-    var matcher = j$.matchers.toBeFalsy(),
+    var matcher = jasmineUnderTest.matchers.toBeFalsy(),
       result;
 
     result = matcher.compare(true);

spec/core/matchers/toBeGreaterThanOrEqualSpec.js

@@ -0,0 +1,29 @@
+describe("toBeGreaterThanOrEqual", function() {
+  it("passes when actual >= expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBeGreaterThanOrEqual(),
+      result;
+
+    result = matcher.compare(2, 1);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1, 1);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1.0000001, 1);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1.0, 1.0);
+    expect(result.pass).toBe(true);
+  })
+
+  it("fails when actual < expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBeGreaterThanOrEqual(),
+      result;
+
+    result = matcher.compare(1, 2);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(1, 1.0000001);
+    expect(result.pass).toBe(false);
+  })
+});

spec/core/matchers/toBeGreaterThanSpec.js

@@ -1,6 +1,6 @@
 describe("toBeGreaterThan", function() {
   it("passes when actual > expected", function() {
-    var matcher = j$.matchers.toBeGreaterThan(),
+    var matcher = jasmineUnderTest.matchers.toBeGreaterThan(),
       result;
 
     result = matcher.compare(2, 1);
@@ -8,7 +8,7 @@ describe("toBeGreaterThan", function() {
   });
 
   it("fails when actual <= expected", function() {
-    var matcher = j$.matchers.toBeGreaterThan(),
+    var matcher = jasmineUnderTest.matchers.toBeGreaterThan(),
       result;
 
     result = matcher.compare(1, 1);

spec/core/matchers/toBeLessThanOrEqualSpec.js

@@ -0,0 +1,29 @@
+describe("toBeLessThanOrEqual", function() {
+  it("passes when actual <= expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBeLessThanOrEqual(),
+      result;
+
+    result = matcher.compare(1, 2);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1, 1);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1, 1.0000001);
+    expect(result.pass).toBe(true);
+    
+    result = matcher.compare(1.0, 1.0);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when actual < expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBeLessThanOrEqual(),
+      result;
+
+    result = matcher.compare(2, 1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(1.0000001, 1);
+    expect(result.pass).toBe(false);
+  });
+});

spec/core/matchers/toBeLessThanSpec.js

@@ -1,6 +1,6 @@
 describe("toBeLessThan", function() {
   it("passes when actual < expected", function() {
-    var matcher = j$.matchers.toBeLessThan(),
+    var matcher = jasmineUnderTest.matchers.toBeLessThan(),
       result;
 
     result = matcher.compare(1, 2);
@@ -8,7 +8,7 @@ describe("toBeLessThan", function() {
   });
 
   it("fails when actual <= expected", function() {
-    var matcher = j$.matchers.toBeLessThan(),
+    var matcher = jasmineUnderTest.matchers.toBeLessThan(),
       result;
 
     result = matcher.compare(1, 1);

spec/core/matchers/toBeNaNSpec.js

@@ -1,6 +1,6 @@
 describe("toBeNaN", function() {
   it("passes for NaN with a custom .not fail", function() {
-    var matcher = j$.matchers.toBeNaN(),
+    var matcher = jasmineUnderTest.matchers.toBeNaN(),
       result;
 
     result = matcher.compare(Number.NaN);
@@ -9,7 +9,7 @@ describe("toBeNaN", function() {
   });
 
   it("fails for anything not a NaN", function() {
-    var matcher = j$.matchers.toBeNaN(),
+    var matcher = jasmineUnderTest.matchers.toBeNaN(),
       result;
 
     result = matcher.compare(1);
@@ -29,7 +29,7 @@ describe("toBeNaN", function() {
   });
 
   it("has a custom message on failure", function() {
-    var matcher = j$.matchers.toBeNaN(),
+    var matcher = jasmineUnderTest.matchers.toBeNaN(),
       result = matcher.compare(0);
 
     expect(result.message()).toEqual("Expected 0 to be NaN.");

spec/core/matchers/toBeNullSpec.js

@@ -1,6 +1,6 @@
 describe("toBeNull", function() {
   it("passes for null", function() {
-    var matcher = j$.matchers.toBeNull(),
+    var matcher = jasmineUnderTest.matchers.toBeNull(),
       result;
 
     result = matcher.compare(null);
@@ -8,7 +8,7 @@ describe("toBeNull", function() {
   });
 
   it("fails for non-null", function() {
-    var matcher = j$.matchers.toBeNull(),
+    var matcher = jasmineUnderTest.matchers.toBeNull(),
       result;
 
     result = matcher.compare('foo');

spec/core/matchers/toBeSpec.js

@@ -1,6 +1,6 @@
 describe("toBe", function() {
   it("passes when actual === expected", function() {
-    var matcher = j$.matchers.toBe(),
+    var matcher = jasmineUnderTest.matchers.toBe(),
       result;
 
     result = matcher.compare(1, 1);
@@ -8,7 +8,7 @@ describe("toBe", function() {
   });
 
   it("fails when actual !== expected", function() {
-    var matcher = j$.matchers.toBe(),
+    var matcher = jasmineUnderTest.matchers.toBe(),
       result;
 
     result = matcher.compare(1, 2);

spec/core/matchers/toBeTruthySpec.js

@@ -1,6 +1,6 @@
 describe("toBeTruthy", function() {
   it("passes for 'truthy' values", function() {
-    var matcher = j$.matchers.toBeTruthy(),
+    var matcher = jasmineUnderTest.matchers.toBeTruthy(),
       result;
 
     result = matcher.compare(true);
@@ -17,7 +17,7 @@ describe("toBeTruthy", function() {
   });
 
   it("fails for 'falsy' values", function() {
-    var matcher = j$.matchers.toBeTruthy(),
+    var matcher = jasmineUnderTest.matchers.toBeTruthy(),
       result;
 
     result = matcher.compare(false);

spec/core/matchers/toBeUndefinedSpec.js

@@ -1,6 +1,6 @@
 describe("toBeUndefined", function() {
   it("passes for undefined values", function() {
-    var matcher = j$.matchers.toBeUndefined(),
+    var matcher = jasmineUnderTest.matchers.toBeUndefined(),
       result;
 
     result = matcher.compare(void 0);
@@ -9,7 +9,7 @@ describe("toBeUndefined", function() {
   });
 
   it("fails when matching defined values", function() {
-    var matcher = j$.matchers.toBeUndefined(),
+    var matcher = jasmineUnderTest.matchers.toBeUndefined(),
       result;
 
     result = matcher.compare('foo');

spec/core/matchers/toContainSpec.js

@@ -1,9 +1,9 @@
 describe("toContain", function() {
-  it("delegates to j$.matchersUtil.contains", function() {
+  it("delegates to jasmineUnderTest.matchersUtil.contains", function() {
     var util = {
         contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
       },
-      matcher = j$.matchers.toContain(util),
+      matcher = jasmineUnderTest.matchers.toContain(util),
       result;
 
     result = matcher.compare("ABC", "B");
@@ -11,12 +11,12 @@ describe("toContain", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("delegates to j$.matchersUtil.contains, passing in equality testers if present", function() {
+  it("delegates to jasmineUnderTest.matchersUtil.contains, passing in equality testers if present", function() {
     var util = {
         contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
       },
       customEqualityTesters = ['a', 'b'],
-      matcher = j$.matchers.toContain(util, customEqualityTesters),
+      matcher = jasmineUnderTest.matchers.toContain(util, customEqualityTesters),
       result;
 
     result = matcher.compare("ABC", "B");

spec/core/matchers/toEqualSpec.js

@@ -3,7 +3,7 @@ describe("toEqual", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equals').and.returnValue(true)
       },
-      matcher = j$.matchers.toEqual(util),
+      matcher = jasmineUnderTest.matchers.toEqual(util),
       result;
 
     result = matcher.compare(1, 1);
@@ -17,7 +17,7 @@ describe("toEqual", function() {
         equals: jasmine.createSpy('delegated-equals').and.returnValue(true)
       },
       customEqualityTesters = ['a', 'b'],
-      matcher = j$.matchers.toEqual(util, customEqualityTesters),
+      matcher = jasmineUnderTest.matchers.toEqual(util, customEqualityTesters),
       result;
 
     result = matcher.compare(1, 1);

spec/core/matchers/toHaveBeenCalledSpec.js

@@ -1,7 +1,7 @@
 describe("toHaveBeenCalled", function() {
   it("passes when the actual was called, with a custom .not fail message", function() {
-    var matcher = j$.matchers.toHaveBeenCalled(),
-      calledSpy = j$.createSpy('called-spy'),
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
+      calledSpy = jasmineUnderTest.createSpy('called-spy'),
       result;
 
     calledSpy();
@@ -12,8 +12,8 @@ describe("toHaveBeenCalled", function() {
   });
 
   it("fails when the actual was not called", function() {
-    var matcher = j$.matchers.toHaveBeenCalled(),
-      uncalledSpy = j$.createSpy('uncalled spy'),
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
+      uncalledSpy = jasmineUnderTest.createSpy('uncalled spy'),
       result;
 
     result = matcher.compare(uncalledSpy);
@@ -21,22 +21,22 @@ describe("toHaveBeenCalled", function() {
   });
 
   it("throws an exception when the actual is not a spy", function() {
-    var matcher = j$.matchers.toHaveBeenCalled(),
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
       fn = function() {};
 
-    expect(function() { matcher.compare(fn) }).toThrow(new Error("Expected a spy, but got Function."));
+    expect(function() { matcher.compare(fn) }).toThrowError(Error, /Expected a spy, but got Function./);
   });
 
   it("throws an exception when invoked with any arguments", function() {
-    var matcher = j$.matchers.toHaveBeenCalled(),
-      spy = j$.createSpy('sample spy');
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
+      spy = jasmineUnderTest.createSpy('sample spy');
 
-    expect(function() { matcher.compare(spy, 'foo') }).toThrow(new Error("toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith"));
+    expect(function() { matcher.compare(spy, 'foo') }).toThrowError(Error, /Does not take arguments, use toHaveBeenCalledWith/);
   });
 
   it("has a custom message on failure", function() {
-    var matcher = j$.matchers.toHaveBeenCalled(),
-      spy = j$.createSpy('sample-spy'),
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
+      spy = jasmineUnderTest.createSpy('sample-spy'),
       result;
 
     result = matcher.compare(spy);

spec/core/matchers/toHaveBeenCalledTimesSpec.js

@@ -1,7 +1,14 @@
 describe("toHaveBeenCalledTimes", function() {
+  it("passes when the actual 0 matches the expected 0 ", function () {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
+        calledSpy = jasmineUnderTest.createSpy('called-spy'),
+        result;
+    result = matcher.compare(calledSpy, 0);
+    expect(result.pass).toBeTruthy();
+  });
   it("passes when the actual matches the expected", function() {
-    var matcher = j$.matchers.toHaveBeenCalledTimes(),
-      calledSpy = j$.createSpy('called-spy'),
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
+      calledSpy = jasmineUnderTest.createSpy('called-spy'),
       result;
     calledSpy();
 
@@ -10,19 +17,19 @@ describe("toHaveBeenCalledTimes", function() {
   });
 
   it("fails when expected numbers is not supplied", function(){
-     var matcher = j$.matchers.toHaveBeenCalledTimes(),
-      spy = j$.createSpy('spy'),
+     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
+      spy = jasmineUnderTest.createSpy('spy'),
       result;
 
     spy();
      expect(function() {
        matcher.compare(spy);
-     }).toThrowError('Expected times failed is required as an argument.');
+     }).toThrowError(/The expected times failed is a required argument and must be a number./);
   });
 
   it("fails when the actual was called less than the expected", function() {
-    var matcher = j$.matchers.toHaveBeenCalledTimes(),
-      uncalledSpy = j$.createSpy('uncalled spy'),
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
+      uncalledSpy = jasmineUnderTest.createSpy('uncalled spy'),
       result;
 
     result = matcher.compare(uncalledSpy, 2);
@@ -30,8 +37,8 @@ describe("toHaveBeenCalledTimes", function() {
   });
 
   it("fails when the actual was called more than expected", function() {
-    var matcher = j$.matchers.toHaveBeenCalledTimes(),
-      uncalledSpy = j$.createSpy('uncalled spy'),
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
+      uncalledSpy = jasmineUnderTest.createSpy('uncalled spy'),
       result;
 
     uncalledSpy();
@@ -42,17 +49,17 @@ describe("toHaveBeenCalledTimes", function() {
   });
 
   it("throws an exception when the actual is not a spy", function() {
-    var matcher = j$.matchers.toHaveBeenCalledTimes(),
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
       fn = function() {};
 
     expect(function() {
       matcher.compare(fn);
-    }).toThrowError("Expected a spy, but got Function.");
+    }).toThrowError(/Expected a spy, but got Function./);
   });
 
   it("has a custom message on failure that tells it was called only once", function() {
-    var matcher = j$.matchers.toHaveBeenCalledTimes(),
-      spy = j$.createSpy('sample-spy'),
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
+      spy = jasmineUnderTest.createSpy('sample-spy'),
       result;
     spy();
     spy();
@@ -60,13 +67,12 @@ describe("toHaveBeenCalledTimes", function() {
     spy();
 
     result = matcher.compare(spy, 1);
-
     expect(result.message).toEqual('Expected spy sample-spy to have been called once. It was called ' +  4 + ' times.');
   });
 
   it("has a custom message on failure that tells how many times it was called", function() {
-    var matcher = j$.matchers.toHaveBeenCalledTimes(),
-      spy = j$.createSpy('sample-spy'),
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
+      spy = jasmineUnderTest.createSpy('sample-spy'),
       result;
     spy();
     spy();
@@ -74,7 +80,6 @@ describe("toHaveBeenCalledTimes", function() {
     spy();
 
     result = matcher.compare(spy, 2);
-
     expect(result.message).toEqual('Expected spy sample-spy to have been called 2 times. It was called ' +  4 + ' times.');
   });
 });

spec/core/matchers/toHaveBeenCalledWithSpec.js

@@ -1,10 +1,11 @@
 describe("toHaveBeenCalledWith", function() {
+
   it("passes when the actual was called with matching parameters", function() {
     var util = {
           contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
         },
-        matcher = j$.matchers.toHaveBeenCalledWith(util),
-        calledSpy = j$.createSpy('called-spy'),
+        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
+        calledSpy = jasmineUnderTest.createSpy('called-spy'),
         result;
 
     calledSpy('a', 'b');
@@ -19,8 +20,8 @@ describe("toHaveBeenCalledWith", function() {
           contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
         },
         customEqualityTesters = [function() { return true; }],
-        matcher = j$.matchers.toHaveBeenCalledWith(util, customEqualityTesters),
-        calledSpy = j$.createSpy('called-spy');
+        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util, customEqualityTesters),
+        calledSpy = jasmineUnderTest.createSpy('called-spy');
 
     calledSpy('a', 'b');
     matcher.compare(calledSpy, 'a', 'b');
@@ -32,8 +33,8 @@ describe("toHaveBeenCalledWith", function() {
     var util = {
           contains: jasmine.createSpy('delegated-contains').and.returnValue(false)
         },
-        matcher = j$.matchers.toHaveBeenCalledWith(util),
-        uncalledSpy = j$.createSpy('uncalled spy'),
+        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
+        uncalledSpy = jasmineUnderTest.createSpy('uncalled spy'),
         result;
 
     result = matcher.compare(uncalledSpy);
@@ -45,8 +46,8 @@ describe("toHaveBeenCalledWith", function() {
     var util = {
           contains: jasmine.createSpy('delegated-contains').and.returnValue(false)
         },
-        matcher = j$.matchers.toHaveBeenCalledWith(util),
-        calledSpy = j$.createSpy('called spy'),
+        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
+        calledSpy = jasmineUnderTest.createSpy('called spy'),
         result;
 
     calledSpy('a');
@@ -58,9 +59,9 @@ describe("toHaveBeenCalledWith", function() {
   });
 
   it("throws an exception when the actual is not a spy", function() {
-    var matcher = j$.matchers.toHaveBeenCalledWith(),
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(),
         fn = function() {};
 
-    expect(function() { matcher.compare(fn) }).toThrow(new Error("Expected a spy, but got Function."));
+    expect(function() { matcher.compare(fn) }).toThrowError(/Expected a spy, but got Function./);
   });
 });

spec/core/matchers/toMatchSpec.js

@@ -1,6 +1,7 @@
 describe("toMatch", function() {
+
   it("passes when RegExps are equivalent", function() {
-    var matcher = j$.matchers.toMatch(),
+    var matcher = jasmineUnderTest.matchers.toMatch(),
       result;
 
     result = matcher.compare(/foo/, /foo/);
@@ -8,7 +9,7 @@ describe("toMatch", function() {
   });
 
   it("fails when RegExps are not equivalent", function() {
-    var matcher = j$.matchers.toMatch(),
+    var matcher = jasmineUnderTest.matchers.toMatch(),
       result;
 
     result = matcher.compare(/bar/, /foo/);
@@ -16,7 +17,7 @@ describe("toMatch", function() {
   });
 
   it("passes when the actual matches the expected string as a pattern", function() {
-    var matcher = j$.matchers.toMatch(),
+    var matcher = jasmineUnderTest.matchers.toMatch(),
       result;
 
     result = matcher.compare('foosball', 'foo');
@@ -24,7 +25,7 @@ describe("toMatch", function() {
   });
 
   it("fails when the actual matches the expected string as a pattern", function() {
-    var matcher = j$.matchers.toMatch(),
+    var matcher = jasmineUnderTest.matchers.toMatch(),
       result;
 
     result = matcher.compare('bar', 'foo');
@@ -32,11 +33,11 @@ describe("toMatch", function() {
   });
 
   it("throws an Error when the expected is not a String or RegExp", function() {
-    var matcher = j$.matchers.toMatch();
+    var matcher = jasmineUnderTest.matchers.toMatch();
 
     expect(function() {
       matcher.compare('foo', { bar: 'baz' });
-    }).toThrowError('Expected is not a String or a RegExp');
+    }).toThrowError(/Expected is not a String or a RegExp/);
   });
 });
 

spec/core/matchers/toThrowErrorSpec.js

@@ -1,47 +1,47 @@
 describe("toThrowError", function() {
   it("throws an error when the actual is not a function", function() {
-    var matcher = j$.matchers.toThrowError();
+    var matcher = jasmineUnderTest.matchers.toThrowError();
 
     expect(function() {
       matcher.compare({});
-    }).toThrowError("Actual is not a Function");
+    }).toThrowError(/Actual is not a Function/);
   });
 
   it("throws an error when the expected is not an Error, string, or RegExp", function() {
-    var matcher = j$.matchers.toThrowError(),
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error("foo");
       };
 
     expect(function() {
       matcher.compare(fn, 1);
-    }).toThrowError("Expected is not an Error, string, or RegExp.");
+    }).toThrowError(/Expected is not an Error, string, or RegExp./);
   });
 
   it("throws an error when the expected error type is not an Error", function() {
-    var matcher = j$.matchers.toThrowError(),
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error("foo");
       };
 
     expect(function() {
       matcher.compare(fn, void 0, "foo");
-    }).toThrowError("Expected error type is not an Error.");
+    }).toThrowError(/Expected error type is not an Error./);
   });
 
   it("throws an error when the expected error message is not a string or RegExp", function() {
-    var matcher = j$.matchers.toThrowError(),
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error("foo");
       };
 
     expect(function() {
       matcher.compare(fn, Error, 1);
-    }).toThrowError("Expected error message is not a string or RegExp.");
+    }).toThrowError(/Expected error message is not a string or RegExp./);
   });
 
   it("fails if actual does not throw at all", function() {
-    var matcher = j$.matchers.toThrowError(),
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         return true;
       },
@@ -54,7 +54,7 @@ describe("toThrowError", function() {
   });
 
   it("fails if thrown is not an instanceof Error", function() {
-    var matcher = j$.matchers.toThrowError(),
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw 4;
       },
@@ -66,7 +66,7 @@ describe("toThrowError", function() {
   });
 
   it("fails with the correct message if thrown is a falsy value", function() {
-    var matcher = j$.matchers.toThrowError(),
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw undefined;
       },
@@ -78,7 +78,7 @@ describe("toThrowError", function() {
   });
 
   it("passes if thrown is a type of Error, but there is no expected error", function() {
-    var matcher = j$.matchers.toThrowError(),
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new TypeError();
       },
@@ -91,7 +91,7 @@ describe("toThrowError", function() {
   });
 
   it("passes if thrown is an Error and the expected is the same message", function() {
-    var matcher = j$.matchers.toThrowError(),
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error("foo");
       },
@@ -104,7 +104,7 @@ describe("toThrowError", function() {
   });
 
   it("fails if thrown is an Error and the expected is not the same message", function() {
-    var matcher = j$.matchers.toThrowError(),
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error("foo");
       },
@@ -117,7 +117,7 @@ describe("toThrowError", function() {
   });
 
   it("passes if thrown is an Error and the expected is a RegExp that matches the message", function() {
-    var matcher = j$.matchers.toThrowError(),
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error("a long message");
       },
@@ -130,7 +130,7 @@ describe("toThrowError", function() {
   });
 
   it("fails if thrown is an Error and the expected is a RegExp that does not match the message", function() {
-    var matcher = j$.matchers.toThrowError(),
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error("a long message");
       },
@@ -146,7 +146,7 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcher = j$.matchers.toThrowError(),
+      matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error();
       },
@@ -162,7 +162,7 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcher = j$.matchers.toThrowError(),
+      matcher = jasmineUnderTest.matchers.toThrowError(),
       CustomError = function CustomError(arg) { arg.x },
       fn = function() {
         throw new CustomError({ x: 1 });
@@ -181,7 +181,7 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
       },
-      matcher = j$.matchers.toThrowError(),
+      matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error();
       },
@@ -197,7 +197,7 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcher = j$.matchers.toThrowError(),
+      matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new TypeError("foo");
       },
@@ -213,7 +213,7 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcher = j$.matchers.toThrowError(),
+      matcher = jasmineUnderTest.matchers.toThrowError(),
       CustomError = function CustomError(arg) { this.message = arg.message },
       fn = function() {
         throw new CustomError({message: "foo"});
@@ -232,7 +232,7 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
       },
-      matcher = j$.matchers.toThrowError(),
+      matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new TypeError("foo");
       },
@@ -248,7 +248,7 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcher = j$.matchers.toThrowError(),
+      matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new TypeError("foo");
       },
@@ -264,7 +264,7 @@ describe("toThrowError", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
       },
-      matcher = j$.matchers.toThrowError(),
+      matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new TypeError("foo");
       },

spec/core/matchers/toThrowSpec.js

@@ -1,15 +1,16 @@
 describe("toThrow", function() {
+
   it("throws an error when the actual is not a function", function() {
-    var matcher = j$.matchers.toThrow();
+    var matcher = jasmineUnderTest.matchers.toThrow();
 
     expect(function() {
       matcher.compare({});
       matcherComparator({});
-    }).toThrowError("Actual is not a Function");
+    }).toThrowError(/Actual is not a Function/);
   });
 
   it("fails if actual does not throw", function() {
-    var matcher = j$.matchers.toThrow(),
+    var matcher = jasmineUnderTest.matchers.toThrow(),
       fn = function() {
         return true;
       },
@@ -25,7 +26,7 @@ describe("toThrow", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcher = j$.matchers.toThrow(util),
+      matcher = jasmineUnderTest.matchers.toThrow(util),
       fn = function() {
         throw 5;
       },
@@ -38,7 +39,7 @@ describe("toThrow", function() {
   });
 
   it("passes even if what is thrown is falsy", function() {
-    var matcher = j$.matchers.toThrow(),
+    var matcher = jasmineUnderTest.matchers.toThrow(),
       fn = function() {
         throw undefined;
       },
@@ -53,7 +54,7 @@ describe("toThrow", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
       },
-      matcher = j$.matchers.toThrow(util),
+      matcher = jasmineUnderTest.matchers.toThrow(util),
       fn = function() {
         throw 5;
       },
@@ -69,7 +70,7 @@ describe("toThrow", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
       },
-      matcher = j$.matchers.toThrow(util),
+      matcher = jasmineUnderTest.matchers.toThrow(util),
       fn = function() {
         throw 5;
       },
@@ -85,7 +86,7 @@ describe("toThrow", function() {
     var util = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
       },
-      matcher = j$.matchers.toThrow(util),
+      matcher = jasmineUnderTest.matchers.toThrow(util),
       fn = function() {
         throw 5;
       },

spec/helpers/defineJasmineUnderTest.js

@@ -1,7 +1,7 @@
 (function() {
   // By the time onload is called, jasmineRequire will be redefined to point
   // to the Jasmine source files (and not jasmine.js). So re-require
-  window.j$ = jasmineRequire.core(jasmineRequire);
-  jasmineRequire.html(j$);
-  jasmineRequire.console(jasmineRequire, j$);
+  window.jasmineUnderTest = jasmineRequire.core(jasmineRequire);
+  jasmineRequire.html(jasmineUnderTest);
+  jasmineRequire.console(jasmineRequire, jasmineUnderTest);
 })();

spec/helpers/nodeDefineJasmineUnderTest.js

@@ -4,10 +4,10 @@
 
   var glob = require("glob");
 
-  var j$Require = require(path.join(__dirname, "../../src/core/requireCore.js"));
+  var jasmineUnderTestRequire = require(path.join(__dirname, "../../src/core/requireCore.js"));
 
   global.getJasmineRequireObj = function () {
-    return j$Require;
+    return jasmineUnderTestRequire;
   };
 
   function extend(destination, source) {
@@ -25,9 +25,9 @@
     });
   }
 
-  extend(j$Require, require(path.join(__dirname,"../../src/console/requireConsole.js")));
+  extend(jasmineUnderTestRequire, require(path.join(__dirname,"../../src/console/requireConsole.js")));
   getSourceFiles();
-  global.j$ = j$Require.core(j$Require);
+  global.jasmineUnderTest = jasmineUnderTestRequire.core(jasmineUnderTestRequire);
 
-  j$Require.console(j$Require, j$);
+  jasmineUnderTestRequire.console(jasmineUnderTestRequire, jasmineUnderTest);
 })();

spec/html/HtmlReporterSpec.js

@@ -1,10 +1,9 @@
 describe("New HtmlReporter", function() {
-  // TODO: Figure out why this isn't rendering...
   it("builds the initial DOM elements, including the title banner", function() {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
       container = document.createElement("div"),
       getContainer = function() { return container; },
-      reporter = new j$.HtmlReporter({
+      reporter = new jasmineUnderTest.HtmlReporter({
         env: env,
         getContainer: getContainer,
         createElement: function() { return document.createElement.apply(document, arguments); },
@@ -29,14 +28,14 @@ describe("New HtmlReporter", function() {
 
     var version = banner.querySelector(".jasmine-version"),
       versionText = 'textContent' in version ? version.textContent : version.innerText;
-    expect(versionText).toEqual(j$.version);
+    expect(versionText).toEqual(jasmineUnderTest.version);
   });
 
   it("builds a single reporter even if initialized multiple times", function() {
-    var env = new j$.Env(),
+    var env = new jasmineUnderTest.Env(),
       container = document.createElement("div"),
       getContainer = function() { return container; },
-      reporter = new j$.HtmlReporter({
+      reporter = new jasmineUnderTest.HtmlReporter({
         env: env,
         getContainer: getContainer,
         createElement: function() { return document.createElement.apply(document, arguments); },
@@ -52,7 +51,7 @@ describe("New HtmlReporter", function() {
   it("starts the timer when jasmine begins", function() {
     var env = new jasmine.Env(),
         startTimerSpy = jasmine.createSpy("start-timer-spy"),
-        reporter = new j$.HtmlReporter({
+        reporter = new jasmineUnderTest.HtmlReporter({
           env: env,
           createElement: function() { return document.createElement.apply(document, arguments); },
           timer: { start: startTimerSpy }
@@ -69,10 +68,10 @@ describe("New HtmlReporter", function() {
         console = { error: function(){} };
       }
 
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
       container = document.createElement('div'),
       getContainer = function() {return container;},
-      reporter = new j$.HtmlReporter({
+      reporter = new jasmineUnderTest.HtmlReporter({
         env: env,
         getContainer: getContainer,
         createElement: function() { return document.createElement.apply(document, arguments); },
@@ -95,10 +94,10 @@ describe("New HtmlReporter", function() {
     });
 
     it("reports the status symbol of a disabled spec", function() {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         container = document.createElement("div"),
         getContainer = function() { return container; },
-        reporter = new j$.HtmlReporter({
+        reporter = new jasmineUnderTest.HtmlReporter({
           env: env,
           getContainer: getContainer,
           createElement: function() { return document.createElement.apply(document, arguments); },
@@ -115,10 +114,10 @@ describe("New HtmlReporter", function() {
     });
 
     it("reports the status symbol of a pending spec", function() {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         container = document.createElement("div"),
         getContainer = function() { return container; },
-        reporter = new j$.HtmlReporter({
+        reporter = new jasmineUnderTest.HtmlReporter({
           env: env,
           getContainer: getContainer,
           createElement: function() { return document.createElement.apply(document, arguments); },
@@ -134,10 +133,10 @@ describe("New HtmlReporter", function() {
     });
 
     it("reports the status symbol of a passing spec", function() {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         container = document.createElement("div"),
         getContainer = function() { return container; },
-        reporter = new j$.HtmlReporter({
+        reporter = new jasmineUnderTest.HtmlReporter({
           env: env,
           getContainer: getContainer,
           createElement: function() { return document.createElement.apply(document, arguments); },
@@ -154,10 +153,10 @@ describe("New HtmlReporter", function() {
     });
 
     it("reports the status symbol of a failing spec", function() {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         container = document.createElement("div"),
         getContainer = function() { return container; },
-        reporter = new j$.HtmlReporter({
+        reporter = new jasmineUnderTest.HtmlReporter({
           env: env,
           getContainer: getContainer,
           createElement: function() { return document.createElement.apply(document, arguments); },
@@ -181,10 +180,10 @@ describe("New HtmlReporter", function() {
 
   describe("when there are suite failures", function () {
     it("displays the exceptions in their own alert bars", function(){
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         container = document.createElement("div"),
         getContainer = function() { return container; },
-        reporter = new j$.HtmlReporter({
+        reporter = new jasmineUnderTest.HtmlReporter({
           env: env,
           getContainer: getContainer,
           createElement: function() { return document.createElement.apply(document, arguments); },
@@ -196,14 +195,16 @@ describe("New HtmlReporter", function() {
       reporter.jasmineStarted({});
       reporter.suiteDone({ status: 'failed', failedExpectations: [{ message: 'My After All Exception' }] });
       reporter.suiteDone({ status: 'failed', failedExpectations: [{ message: 'My Other Exception' }] });
-      reporter.jasmineDone({});
+      reporter.jasmineDone({ failedExpectations: [{ message: 'Global After All Failure' }, { message: 'Other Global' }] });
 
       var alertBars = container.querySelectorAll(".jasmine-alert .jasmine-bar");
 
-      expect(alertBars.length).toEqual(3);
+      expect(alertBars.length).toEqual(5);
       expect(alertBars[1].innerHTML).toMatch(/My After All Exception/);
       expect(alertBars[1].getAttribute("class")).toEqual('jasmine-bar jasmine-errored');
       expect(alertBars[2].innerHTML).toMatch(/My Other Exception/);
+      expect(alertBars[3].innerHTML).toMatch(/Global After All Failure/);
+      expect(alertBars[4].innerHTML).toMatch(/Other Global/);
     });
   });
 
@@ -212,10 +213,10 @@ describe("New HtmlReporter", function() {
       if (!window.console) {
         window.console = { error: function(){} };
       }
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
       container = document.createElement('div'),
       getContainer = function() {return container;},
-      reporter = new j$.HtmlReporter({
+      reporter = new jasmineUnderTest.HtmlReporter({
         env: env,
         getContainer: getContainer,
         createElement: function() { return document.createElement.apply(document, arguments); },
@@ -247,11 +248,11 @@ describe("New HtmlReporter", function() {
     });
 
     it("reports the run time", function() {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         container = document.createElement("div"),
         timer = jasmine.createSpyObj('timer', ['start', 'elapsed']),
         getContainer = function() { return container; },
-        reporter = new j$.HtmlReporter({
+        reporter = new jasmineUnderTest.HtmlReporter({
           env: env,
           getContainer: getContainer,
           createElement: function() { return document.createElement.apply(document, arguments); },
@@ -271,10 +272,10 @@ describe("New HtmlReporter", function() {
     });
 
     it("reports the suite and spec names with status", function() {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         container = document.createElement("div"),
         getContainer = function() { return container; },
-        reporter = new j$.HtmlReporter({
+        reporter = new jasmineUnderTest.HtmlReporter({
           env: env,
           getContainer: getContainer,
           createElement: function() { return document.createElement.apply(document, arguments); },
@@ -365,12 +366,12 @@ describe("New HtmlReporter", function() {
     });
 
     it("has an options menu", function() {
-      var env = new j$.Env(),
+      var env = new jasmineUnderTest.Env(),
         container = document.createElement("div"),
         getContainer = function() {
           return container;
         },
-        reporter = new j$.HtmlReporter({
+        reporter = new jasmineUnderTest.HtmlReporter({
           env: env,
           getContainer: getContainer,
           createElement: function() {
@@ -400,12 +401,12 @@ describe("New HtmlReporter", function() {
 
     describe("UI for raising/catching exceptions", function() {
       it("should be unchecked if the env is catching", function() {
-        var env = new j$.Env(),
+        var env = new jasmineUnderTest.Env(),
           container = document.createElement("div"),
           getContainer = function() {
             return container;
           },
-          reporter = new j$.HtmlReporter({
+          reporter = new jasmineUnderTest.HtmlReporter({
             env: env,
             getContainer: getContainer,
             createElement: function() {
@@ -424,12 +425,12 @@ describe("New HtmlReporter", function() {
       });
 
       it("should be checked if the env is not catching", function() {
-        var env = new j$.Env(),
+        var env = new jasmineUnderTest.Env(),
           container = document.createElement("div"),
           getContainer = function() {
             return container;
           },
-          reporter = new j$.HtmlReporter({
+          reporter = new jasmineUnderTest.HtmlReporter({
             env: env,
             getContainer: getContainer,
             createElement: function() {
@@ -449,13 +450,13 @@ describe("New HtmlReporter", function() {
       });
 
       it("should affect the query param for catching exceptions", function() {
-        var env = new j$.Env(),
+        var env = new jasmineUnderTest.Env(),
           container = document.createElement("div"),
           exceptionsClickHandler = jasmine.createSpy("raise exceptions checked"),
           getContainer = function() {
             return container;
           },
-          reporter = new j$.HtmlReporter({
+          reporter = new jasmineUnderTest.HtmlReporter({
             env: env,
             getContainer: getContainer,
             onRaiseExceptionsClick: exceptionsClickHandler,
@@ -478,12 +479,12 @@ describe("New HtmlReporter", function() {
 
     describe("UI for throwing errors on expectation failures", function() {
       it("should be unchecked if not throwing", function() {
-        var env = new j$.Env(),
+        var env = new jasmineUnderTest.Env(),
           container = document.createElement("div"),
           getContainer = function() {
             return container;
           },
-          reporter = new j$.HtmlReporter({
+          reporter = new jasmineUnderTest.HtmlReporter({
             env: env,
             getContainer: getContainer,
             createElement: function() {
@@ -502,12 +503,12 @@ describe("New HtmlReporter", function() {
       });
 
       it("should be checked if throwing", function() {
-        var env = new j$.Env(),
+        var env = new jasmineUnderTest.Env(),
           container = document.createElement("div"),
           getContainer = function() {
             return container;
           },
-          reporter = new j$.HtmlReporter({
+          reporter = new jasmineUnderTest.HtmlReporter({
             env: env,
             getContainer: getContainer,
             createElement: function() {
@@ -528,13 +529,13 @@ describe("New HtmlReporter", function() {
       });
 
       it("should affect the query param for throw expectation failures", function() {
-        var env = new j$.Env(),
+        var env = new jasmineUnderTest.Env(),
           container = document.createElement("div"),
           throwingExceptionHandler = jasmine.createSpy('throwingExceptions'),
           getContainer = function() {
             return container;
           },
-          reporter = new j$.HtmlReporter({
+          reporter = new jasmineUnderTest.HtmlReporter({
             env: env,
             getContainer: getContainer,
             onThrowExpectationsClick: throwingExceptionHandler,
@@ -558,12 +559,12 @@ describe("New HtmlReporter", function() {
 
     describe("UI for running tests in random order", function() {
       it("should be unchecked if not randomizing", function() {
-        var env = new j$.Env(),
+        var env = new jasmineUnderTest.Env(),
           container = document.createElement("div"),
           getContainer = function() {
             return container;
           },
-          reporter = new j$.HtmlReporter({
+          reporter = new jasmineUnderTest.HtmlReporter({
             env: env,
             getContainer: getContainer,
             createElement: function() {
@@ -582,12 +583,12 @@ describe("New HtmlReporter", function() {
       });
 
       it("should be checked if randomizing", function() {
-        var env = new j$.Env(),
+        var env = new jasmineUnderTest.Env(),
           container = document.createElement("div"),
           getContainer = function() {
             return container;
           },
-          reporter = new j$.HtmlReporter({
+          reporter = new jasmineUnderTest.HtmlReporter({
             env: env,
             getContainer: getContainer,
             createElement: function() {
@@ -607,13 +608,13 @@ describe("New HtmlReporter", function() {
       });
 
       it("should affect the query param for random tests", function() {
-        var env = new j$.Env(),
+        var env = new jasmineUnderTest.Env(),
           container = document.createElement("div"),
           randomHandler = jasmine.createSpy('randomHandler'),
           getContainer = function() {
             return container;
           },
-          reporter = new j$.HtmlReporter({
+          reporter = new jasmineUnderTest.HtmlReporter({
             env: env,
             getContainer: getContainer,
             onRandomClick: randomHandler,
@@ -635,12 +636,12 @@ describe("New HtmlReporter", function() {
       });
 
       it("should show the seed bar if randomizing", function() {
-        var env = new j$.Env(),
+        var env = new jasmineUnderTest.Env(),
             container = document.createElement("div"),
             getContainer = function() {
               return container;
             },
-            reporter = new j$.HtmlReporter({
+            reporter = new jasmineUnderTest.HtmlReporter({
               env: env,
               getContainer: getContainer,
               createElement: function() {
@@ -667,12 +668,12 @@ describe("New HtmlReporter", function() {
       });
 
       it("should not show the current seed bar if not randomizing", function() {
-        var env = new j$.Env(),
+        var env = new jasmineUnderTest.Env(),
             container = document.createElement("div"),
             getContainer = function() {
               return container;
             },
-            reporter = new j$.HtmlReporter({
+            reporter = new jasmineUnderTest.HtmlReporter({
               env: env,
               getContainer: getContainer,
               createElement: function() {
@@ -690,14 +691,49 @@ describe("New HtmlReporter", function() {
         expect(seedBar).toBeNull();
       });
 
+      it("should include the random query param in the jasmine-skipped link when randomizing", function(){
+        var env = new jasmineUnderTest.Env(),
+          container = document.createElement("div"),
+          reporter = new jasmineUnderTest.HtmlReporter({
+            env: env,
+            getContainer: function() { return container; },
+            createElement: function() { return document.createElement.apply(document, arguments); },
+            createTextNode: function() { return document.createTextNode.apply(document, arguments); }
+          });
+
+        reporter.initialize();
+        reporter.jasmineStarted({ totalSpecsDefined: 1 });
+        reporter.jasmineDone({ order: { random: true } });
+
+        var skippedLink = container.querySelector(".jasmine-skipped a");
+        expect(skippedLink.getAttribute('href')).toEqual('?random=true');
+      });
+
+      it("should not include the random query param in the jasmine-skipped link when not randomizing", function(){
+        var env = new jasmineUnderTest.Env(),
+        container = document.createElement("div"),
+        reporter = new jasmineUnderTest.HtmlReporter({
+          env: env,
+          getContainer: function() { return container; },
+          createElement: function() { return document.createElement.apply(document, arguments); },
+          createTextNode: function() { return document.createTextNode.apply(document, arguments); }
+        });
+
+        reporter.initialize();
+        reporter.jasmineStarted({ totalSpecsDefined: 1 });
+        reporter.jasmineDone();
+
+        var skippedLink = container.querySelector(".jasmine-skipped a");
+        expect(skippedLink.getAttribute('href')).toEqual('?');
+      });
     });
 
     it("shows a message if no specs are run", function(){
       var env, container, reporter;
-      env = new j$.Env();
+      env = new jasmineUnderTest.Env();
       container = document.createElement("div");
       var getContainer = function() { return container; },
-      reporter = new j$.HtmlReporter({
+      reporter = new jasmineUnderTest.HtmlReporter({
         env: env,
         getContainer: getContainer,
         createElement: function() { return document.createElement.apply(document, arguments); },
@@ -716,10 +752,10 @@ describe("New HtmlReporter", function() {
     describe("and all specs pass", function() {
       var env, container, reporter;
       beforeEach(function() {
-        env = new j$.Env();
+        env = new jasmineUnderTest.Env();
         container = document.createElement("div");
         var getContainer = function() { return container; },
-          reporter = new j$.HtmlReporter({
+          reporter = new jasmineUnderTest.HtmlReporter({
             env: env,
             getContainer: getContainer,
             createElement: function() { return document.createElement.apply(document, arguments); },
@@ -771,10 +807,10 @@ describe("New HtmlReporter", function() {
     describe("and there are pending specs", function() {
       var env, container, reporter;
       beforeEach(function() {
-        env = new j$.Env();
+        env = new jasmineUnderTest.Env();
         container = document.createElement("div");
         var getContainer = function() { return container; };
-        reporter = new j$.HtmlReporter({
+        reporter = new jasmineUnderTest.HtmlReporter({
           env: env,
           getContainer: getContainer,
           createElement: function() { return document.createElement.apply(document, arguments); },
@@ -820,10 +856,10 @@ describe("New HtmlReporter", function() {
       var env, container, reporter;
 
       beforeEach(function() {
-        env = new j$.Env();
+        env = new jasmineUnderTest.Env();
         container = document.createElement("div");
         var getContainer = function() { return container; }
-        reporter = new j$.HtmlReporter({
+        reporter = new jasmineUnderTest.HtmlReporter({
           env: env,
           getContainer: getContainer,
           createElement: function() { return document.createElement.apply(document, arguments); },

spec/html/HtmlSpecFilterSpec.js

@@ -1,14 +1,14 @@
-describe("j$.HtmlSpecFilter", function() {
+describe("jasmineUnderTest.HtmlSpecFilter", function() {
 
   it("should match when no string is provided", function() {
-    var specFilter = new j$.HtmlSpecFilter();
+    var specFilter = new jasmineUnderTest.HtmlSpecFilter();
 
     expect(specFilter.matches("foo")).toBe(true);
     expect(specFilter.matches("*bar")).toBe(true);
   });
 
   it("should only match the provided string", function() {
-    var specFilter = new j$.HtmlSpecFilter({
+    var specFilter = new jasmineUnderTest.HtmlSpecFilter({
       filterString: function() { return "foo"; }
     });
 

spec/html/MatchersHtmlSpec.js

@@ -2,7 +2,7 @@ describe("MatchersSpec - HTML Dependent", function () {
   var env, spec;
 
   beforeEach(function() {
-    env = new j$.Env();
+    env = new jasmineUnderTest.Env();
 
     var suite = env.describe("suite", function() {
       spec = env.it("spec", function() {

spec/html/PrettyPrintHtmlSpec.js

@@ -1,15 +1,15 @@
-describe("j$.pp (HTML Dependent)", function () {
+describe("jasmineUnderTest.pp (HTML Dependent)", function () {
   it("should stringify HTML nodes properly", function() {
     var sampleNode = document.createElement('div');
     sampleNode.innerHTML = 'foo<b>bar</b>';
-    expect(j$.pp(sampleNode)).toEqual("HTMLNode");
-    expect(j$.pp({foo: sampleNode})).toEqual("Object({ foo: HTMLNode })");
+    expect(jasmineUnderTest.pp(sampleNode)).toEqual("HTMLNode");
+    expect(jasmineUnderTest.pp({foo: sampleNode})).toEqual("Object({ foo: HTMLNode })");
   });
 
   it("should print Firefox's wrapped native objects correctly", function() {
     if(jasmine.getEnv().firefoxVersion) {
       try { new CustomEvent(); } catch(e) { var err = e; };
-      expect(j$.pp(err)).toMatch(/Not enough arguments/);
+      expect(jasmineUnderTest.pp(err)).toMatch(/Not enough arguments/);
     }
   });
 });

spec/html/QueryStringSpec.js

@@ -5,7 +5,7 @@ describe("QueryString", function() {
       var windowLocation = {
           search: ""
         },
-        queryString = new j$.QueryString({
+        queryString = new jasmineUnderTest.QueryString({
           getWindowLocation: function() { return windowLocation }
         });
 
@@ -18,7 +18,7 @@ describe("QueryString", function() {
       var windowLocation = {
         search: "?foo=bar"
       },
-      queryString = new j$.QueryString({
+      queryString = new jasmineUnderTest.QueryString({
         getWindowLocation: function() { return windowLocation }
       });
 
@@ -34,7 +34,7 @@ describe("QueryString", function() {
       var windowLocation = {
         search: "?foo=bar"
       },
-      queryString = new j$.QueryString({
+      queryString = new jasmineUnderTest.QueryString({
         getWindowLocation: function() { return windowLocation }
       });
 
@@ -51,7 +51,7 @@ describe("QueryString", function() {
       var windowLocation = {
           search: "?baz=quux%20corge"
         },
-        queryString = new j$.QueryString({
+        queryString = new jasmineUnderTest.QueryString({
           getWindowLocation: function() { return windowLocation }
         });
 
@@ -62,7 +62,7 @@ describe("QueryString", function() {
       var windowLocation = {
           search: ""
         },
-        queryString = new j$.QueryString({
+        queryString = new jasmineUnderTest.QueryString({
           getWindowLocation: function() { return windowLocation }
         });
 

spec/html/ResultsNodeSpec.js

@@ -4,7 +4,7 @@ describe("ResultsNode", function() {
         id: 123,
         message: "foo"
       },
-      node = new j$.ResultsNode(fakeResult, "suite", null);
+      node = new jasmineUnderTest.ResultsNode(fakeResult, "suite", null);
 
     expect(node.result).toBe(fakeResult);
     expect(node.type).toEqual("suite");
@@ -19,7 +19,7 @@ describe("ResultsNode", function() {
         id: 456,
         message: "bar"
       },
-      node = new j$.ResultsNode(fakeResult, "suite", null);
+      node = new jasmineUnderTest.ResultsNode(fakeResult, "suite", null);
 
     node.addChild(fakeChildResult, "spec");
 
@@ -37,7 +37,7 @@ describe("ResultsNode", function() {
         id: 456,
         message: "bar"
       },
-      node = new j$.ResultsNode(fakeResult, "suite", null);
+      node = new jasmineUnderTest.ResultsNode(fakeResult, "suite", null);
 
     node.addChild(fakeChildResult, "spec");
 
@@ -53,7 +53,7 @@ describe("ResultsNode", function() {
         id: 456,
         message: "bar"
       },
-      node = new j$.ResultsNode(fakeResult, "suite", null);
+      node = new jasmineUnderTest.ResultsNode(fakeResult, "suite", null);
 
     node.addChild(fakeChildResult, "spec");
 

spec/javascripts/support/jasmine_selenium_runner.yml

@@ -2,6 +2,7 @@
 use_sauce: <%= ENV['USE_SAUCE'] %>
 browser: <%= ENV['JASMINE_BROWSER'] %>
 sauce:
+  sauce_connect_path: "/Users/gregg/Downloads/sc-4.3.11-osx/bin/sc"
   name: jasmine-core <%= Time.now.to_s %>
   username: <%= ENV['SAUCE_USERNAME'] %>
   access_key: <%= ENV['SAUCE_ACCESS_KEY'] %>
@@ -11,6 +12,6 @@ sauce:
     - CI
   tunnel_identifier: <%= ENV['TRAVIS_JOB_NUMBER'] ? %Q("#{ENV['TRAVIS_JOB_NUMBER']}") : nil %>
   os: <%= ENV['SAUCE_OS'] %>
-  browser_version: <%= ENV['SAUCE_BROWSER_VERSION'] %>
+  browser_version: "<%= ENV['SAUCE_BROWSER_VERSION'] %>"
 
 

spec/node_suite.js

@@ -1,195 +0,0 @@
-var fs = require('fs');
-var util = require('util');
-var path = require('path');
-
-// boot code for jasmine
-var jasmineRequire = require('../lib/jasmine-core/jasmine.js');
-var jasmine = jasmineRequire.core(jasmineRequire);
-
-var consoleFns = require('../lib/console/console.js');
-extend(jasmineRequire, consoleFns);
-jasmineRequire.console(jasmineRequire, jasmine);
-
-var env = jasmine.getEnv();
-
-var jasmineInterface = {
-  describe: function(description, specDefinitions) {
-    return env.describe(description, specDefinitions);
-  },
-
-  xdescribe: function(description, specDefinitions) {
-    return env.xdescribe(description, specDefinitions);
-  },
-
-  it: function(desc, func) {
-    return env.it(desc, func);
-  },
-
-  xit: function(desc, func) {
-    return env.xit(desc, func);
-  },
-
-  beforeEach: function(beforeEachFunction) {
-    return env.beforeEach(beforeEachFunction);
-  },
-
-  afterEach: function(afterEachFunction) {
-    return env.afterEach(afterEachFunction);
-  },
-
-  expect: function(actual) {
-    return env.expect(actual);
-  },
-
-  spyOn: function(obj, methodName) {
-    return env.spyOn(obj, methodName);
-  },
-
-  jsApiReporter: new jasmine.JsApiReporter({
-    timer: new jasmine.Timer()
-  }),
-
-  beforeAll: function(beforeAllFunction) {
-    return env.beforeAll(beforeAllFunction);
-  },
-
-  afterAll: function(afterAllFunction) {
-    return env.afterAll(afterAllFunction);
-  }
-};
-
-extend(global, jasmineInterface);
-
-function extend(destination, source) {
-  for (var property in source) destination[property] = source[property];
-  return destination;
-}
-
-jasmine.addCustomEqualityTester = function(tester) {
-  env.addCustomEqualityTester(tester);
-};
-
-jasmine.addMatchers = function(matchers) {
-  return env.addMatchers(matchers);
-};
-
-jasmine.clock = function() {
-  return env.clock;
-};
-
-// Jasmine "runner"
-function executeSpecs(specs, done, isVerbose, showColors) {
-  global.jasmine = jasmine;
-
-  for (var i = 0; i < specs.length; i++) {
-    var filename = specs[i];
-    require(filename.replace(/\.\w+$/, ""));
-  }
-
-  var env = jasmine.getEnv();
-  var consoleReporter = new jasmine.ConsoleReporter({
-    print: util.print,
-    onComplete: done,
-    showColors: showColors,
-    timer: new jasmine.Timer()
-  });
-
-  env.addReporter(consoleReporter);
-  env.execute();
-}
-
-function getFiles(dir, matcher) {
-  var allFiles = [];
-
-  if (fs.statSync(dir).isFile() && dir.match(matcher)) {
-    allFiles.push(dir);
-  } else {
-    var files = fs.readdirSync(dir);
-    for (var i = 0, len = files.length; i < len; ++i) {
-      var filename = dir + '/' + files[i];
-      if (fs.statSync(filename).isFile() && filename.match(matcher)) {
-        allFiles.push(filename);
-      } else if (fs.statSync(filename).isDirectory()) {
-        var subfiles = getFiles(filename);
-        subfiles.forEach(function(result) {
-          allFiles.push(result);
-        });
-      }
-    }
-  }
-  return allFiles;
-}
-
-function getSpecFiles(dir) {
-  return getFiles(dir, new RegExp("Spec.js$"));
-}
-
-var j$require = (function() {
-  var exported = {},
-      j$req;
-
-  global.getJasmineRequireObj = getJasmineRequireObj;
-
-  j$req = require(__dirname + "/../src/core/requireCore.js");
-  extend(j$req, require(__dirname + "/../src/console/requireConsole.js"));
-
-  var srcFiles = getFiles(__dirname + "/../src/core");
-  srcFiles.push(__dirname + "/../src/version.js");
-  srcFiles.push(__dirname + "/../src/console/ConsoleReporter.js");
-
-  for (var i = 0; i < srcFiles.length; i++) {
-    require(srcFiles[i]);
-  }
-  extend(j$req, exported);
-
-  delete global.getJasmineRequireObj;
-
-  return j$req;
-
-  function getJasmineRequireObj() {
-    return exported;
-  }
-}());
-
-j$ = j$require.core(j$require);
-j$require.console(j$require, j$);
-
-// options from command line
-var isVerbose = false;
-var showColors = true;
-var perfSuite = false;
-
-process.argv.forEach(function(arg) {
-  switch (arg) {
-    case '--color':
-      showColors = true;
-      break;
-    case '--noColor':
-      showColors = false;
-      break;
-    case '--verbose':
-      isVerbose = true;
-      break;
-    case '--perf':
-      perfSuite = true;
-      break;
-  }
-});
-
-specs = [];
-
-if (perfSuite) {
-  specs = getFiles(__dirname + '/performance', new RegExp("test.js$"));
-} else {
-  var consoleSpecs = getSpecFiles(__dirname + "/console"),
-      coreSpecs = getSpecFiles(__dirname + "/core"),
-      specs = consoleSpecs.concat(coreSpecs);
-}
-
-executeSpecs(specs, function(passed) {
-  if (passed) {
-    process.exit(0);
-  } else {
-    process.exit(1);
-  }
-}, isVerbose, showColors);

spec/npmPackage/npmPackageSpec.js

@@ -5,9 +5,9 @@ describe('npm package', function() {
 
   beforeAll(function() {
     var shell = require('shelljs'),
-        pack = shell.exec('npm pack', { silent: true });
+        pack = shell.exec('npm pack', { silent: true});
 
-    this.tarball = pack.output.split('\n')[0];
+    this.tarball = pack.stdout.split('\n')[0];
     this.tmpDir = temp.mkdirSync(); // automatically deleted on exit
 
     var untar = shell.exec('tar -xzf ' + this.tarball + ' -C ' + this.tmpDir, { silent: true });

spec/performance/large_object_test.js

@@ -30,7 +30,7 @@ describe('Printing a big object', function(){
 
   it('takes a resonable amount of time', function(){
     bigObject = generateObject(0);
-    expect(j$.pp(bigObject)).toMatch(/cycle/);
+    expect(jasmineUnderTest.pp(bigObject)).toMatch(/cycle/);
   });
 });
 

src/core/CallTracker.js

@@ -1,9 +1,26 @@
-getJasmineRequireObj().CallTracker = function() {
+getJasmineRequireObj().CallTracker = function(j$) {
 
   function CallTracker() {
     var calls = [];
+    var opts = {};
+
+    function argCloner(context) {
+      var clonedArgs = [];
+      var argsAsArray = j$.util.argsToArray(context.args);
+      for(var i = 0; i < argsAsArray.length; i++) {
+        if(Object.prototype.toString.apply(argsAsArray[i]).match(/^\[object/)) {
+          clonedArgs.push(j$.util.clone(argsAsArray[i]));
+        } else {
+          clonedArgs.push(argsAsArray[i]);
+        }
+      }
+      context.args = clonedArgs;
+    }
 
     this.track = function(context) {
+      if(opts.cloneArgs) {
+        argCloner(context);
+      }
       calls.push(context);
     };
 
@@ -44,6 +61,11 @@ getJasmineRequireObj().CallTracker = function() {
     this.reset = function() {
       calls = [];
     };
+
+    this.saveArgumentsByValue = function() {
+      opts.cloneArgs = true;
+    };
+
   }
 
   return CallTracker;

src/core/Clock.js

@@ -82,8 +82,7 @@ getJasmineRequireObj().Clock = function() {
 
     self.tick = function(millis) {
       if (installed) {
-        mockDate.tick(millis);
-        delayedFunctionScheduler.tick(millis);
+        delayedFunctionScheduler.tick(millis, function(millis) { mockDate.tick(millis); });
       } else {
         throw new Error('Mock clock is not installed, use jasmine.clock().install()');
       }

src/core/DelayedFunctionScheduler.js

@@ -6,11 +6,11 @@ getJasmineRequireObj().DelayedFunctionScheduler = function() {
     var currentTime = 0;
     var delayedFnCount = 0;
 
-    self.tick = function(millis) {
+    self.tick = function(millis, tickDate) {
       millis = millis || 0;
       var endTime = currentTime + millis;
 
-      runScheduledFunctions(endTime);
+      runScheduledFunctions(endTime, tickDate);
       currentTime = endTime;
     };
 
@@ -113,13 +113,18 @@ getJasmineRequireObj().DelayedFunctionScheduler = function() {
       }
     }
 
-    function runScheduledFunctions(endTime) {
+    function runScheduledFunctions(endTime, tickDate) {
+      tickDate = tickDate || function() {};
       if (scheduledLookup.length === 0 || scheduledLookup[0] > endTime) {
+        tickDate(endTime - currentTime);
         return;
       }
 
       do {
-        currentTime = scheduledLookup.shift();
+        var newCurrentTime = scheduledLookup.shift();
+        tickDate(newCurrentTime - currentTime);
+
+        currentTime = newCurrentTime;
 
         var funcsToRun = scheduledFunctions[currentTime];
         delete scheduledFunctions[currentTime];
@@ -138,6 +143,11 @@ getJasmineRequireObj().DelayedFunctionScheduler = function() {
               // scheduled in a funcToRun from forcing an extra iteration
                  currentTime !== endTime  &&
                  scheduledLookup[0] <= endTime);
+
+      // ran out of functions to call, but still time left on the clock
+      if (currentTime !== endTime) {
+        tickDate(endTime - currentTime);
+      }
     }
   }
 

src/core/Env.js

@@ -13,7 +13,6 @@ getJasmineRequireObj().Env = function(j$) {
     var realClearTimeout = j$.getGlobal().clearTimeout;
     this.clock = new j$.Clock(global, function () { return new j$.DelayedFunctionScheduler(); }, new j$.MockDate(global));
 
-    var runnableLookupTable = {};
     var runnableResources = {};
 
     var currentSpec = null;
@@ -123,7 +122,13 @@ getJasmineRequireObj().Env = function(j$) {
     };
 
     var getSpecName = function(spec, suite) {
-      return suite.getFullName() + ' ' + spec.description;
+      var fullName = [spec.description],
+          suiteFullName = suite.getFullName();
+
+      if (suiteFullName !== '') {
+        fullName.unshift(suiteFullName);
+      }
+      return fullName.join(' ');
     };
 
     // TODO: we may just be able to pass in the fn instead of wrapping here
@@ -199,9 +204,9 @@ getJasmineRequireObj().Env = function(j$) {
       env: this,
       id: getNextSuiteId(),
       description: 'Jasmine__TopLevel__Suite',
-      queueRunner: queueRunnerFactory
+      expectationFactory: expectationFactory,
+      expectationResultFactory: expectationResultFactory
     });
-    runnableLookupTable[topSuite.id] = topSuite;
     defaultResourcesForRunnable(topSuite.id);
     currentDeclarationSuite = topSuite;
 
@@ -252,9 +257,15 @@ getJasmineRequireObj().Env = function(j$) {
         totalSpecsDefined: totalSpecsDefined
       });
 
+      currentlyExecutingSuites.push(topSuite);
+
       processor.execute(function() {
+        clearResourcesForRunnable(topSuite.id);
+        currentlyExecutingSuites.pop();
+
         reporter.jasmineDone({
-          order: order
+          order: order,
+          failedExpectations: topSuite.result.failedExpectations
         });
       });
     };
@@ -263,6 +274,10 @@ getJasmineRequireObj().Env = function(j$) {
       reporter.addReporter(reporterToAdd);
     };
 
+    this.provideFallbackReporter = function(reporterToAdd) {
+      reporter.provideFallbackReporter(reporterToAdd);
+    };
+
     var spyRegistry = new j$.SpyRegistry({currentSpies: function() {
       if(!currentRunnable()) {
         throw new Error('Spies must be created in a before function or a spec');
@@ -270,6 +285,10 @@ getJasmineRequireObj().Env = function(j$) {
       return runnableResources[currentRunnable().id].spies;
     }});
 
+    this.allowRespy = function(allow){
+      spyRegistry.allowRespy(allow);
+    };
+
     this.spyOn = function() {
       return spyRegistry.spyOn.apply(spyRegistry, arguments);
     };
@@ -285,14 +304,13 @@ getJasmineRequireObj().Env = function(j$) {
         throwOnExpectationFailure: throwOnExpectationFailure
       });
 
-      runnableLookupTable[suite.id] = suite;
       return suite;
     };
 
     this.describe = function(description, specDefinitions) {
       var suite = suiteFactory(description);
       if (specDefinitions.length > 0) {
-        throw new Error('describe does not expect a done parameter');
+        throw new Error('describe does not expect any arguments');
       }
       if (currentDeclarationSuite.markedPending) {
         suite.pend();
@@ -387,8 +405,6 @@ getJasmineRequireObj().Env = function(j$) {
         throwOnExpectationFailure: throwOnExpectationFailure
       });
 
-      runnableLookupTable[spec.id] = spec;
-
       if (!self.specFilter(spec)) {
         spec.disable();
       }

src/core/QueueRunner.js

@@ -7,6 +7,7 @@ getJasmineRequireObj().QueueRunner = function(j$) {
         called = true;
         fn();
       }
+      return null;
     };
   }
 

src/core/ReportDispatcher.js

@@ -13,14 +13,23 @@ getJasmineRequireObj().ReportDispatcher = function() {
     }
 
     var reporters = [];
+    var fallbackReporter = null;
 
     this.addReporter = function(reporter) {
       reporters.push(reporter);
     };
+    
+    this.provideFallbackReporter = function(reporter) {
+      fallbackReporter = reporter;
+    };
+
 
     return this;
 
     function dispatch(method, args) {
+      if (reporters.length === 0 && fallbackReporter !== null) {
+          reporters.push(fallbackReporter);
+      }
       for (var i = 0; i < reporters.length; i++) {
         var reporter = reporters[i];
         if (reporter[method]) {

src/core/SpyRegistry.js

@@ -1,25 +1,35 @@
 getJasmineRequireObj().SpyRegistry = function(j$) {
 
+  var getErrorMsg = j$.formatErrorMsg('<spyOn>', 'spyOn(<object>, <methodName>)');
+
   function SpyRegistry(options) {
     options = options || {};
     var currentSpies = options.currentSpies || function() { return []; };
 
+    this.allowRespy = function(allow){
+      this.respy = allow;
+    };
+
     this.spyOn = function(obj, methodName) {
+
       if (j$.util.isUndefined(obj)) {
-        throw new Error('spyOn could not find an object to spy upon for ' + methodName + '()');
+        throw new Error(getErrorMsg('could not find an object to spy upon for ' + methodName + '()'));
       }
 
       if (j$.util.isUndefined(methodName)) {
-        throw new Error('No method name supplied');
+        throw new Error(getErrorMsg('No method name supplied'));
       }
 
       if (j$.util.isUndefined(obj[methodName])) {
-        throw new Error(methodName + '() method does not exist');
+        throw new Error(getErrorMsg(methodName + '() method does not exist'));
       }
 
-      if (obj[methodName] && j$.isSpy(obj[methodName])) {
-        //TODO?: should this return the current spy? Downside: may cause user confusion about spy state
-        throw new Error(methodName + ' has already been spied upon');
+      if (obj[methodName] && j$.isSpy(obj[methodName])  ) {
+        if ( !!this.respy ){
+          return obj[methodName];
+        }else {
+          throw new Error(getErrorMsg(methodName + ' has already been spied upon'));
+        }
       }
 
       var descriptor;
@@ -30,28 +40,39 @@ getJasmineRequireObj().SpyRegistry = function(j$) {
       }
 
       if (descriptor && !(descriptor.writable || descriptor.set)) {
-        throw new Error(methodName + ' is not declared writable or has no setter');
+        throw new Error(getErrorMsg(methodName + ' is not declared writable or has no setter'));
       }
 
-      var spy = j$.createSpy(methodName, obj[methodName]);
+      var originalMethod = obj[methodName],
+        spiedMethod = j$.createSpy(methodName, originalMethod),
+        restoreStrategy;
+
+      if (Object.prototype.hasOwnProperty.call(obj, methodName)) {
+        restoreStrategy = function() {
+          obj[methodName] = originalMethod;
+        };
+      } else {
+        restoreStrategy = function() {
+          if (!delete obj[methodName]) {
+            obj[methodName] = originalMethod;
+          }
+        };
+      }
 
       currentSpies().push({
-        spy: spy,
-        baseObj: obj,
-        methodName: methodName,
-        originalValue: obj[methodName]
+        restoreObjectToOriginalState: restoreStrategy
       });
 
-      obj[methodName] = spy;
+      obj[methodName] = spiedMethod;
 
-      return spy;
+      return spiedMethod;
     };
 
     this.clearSpies = function() {
       var spies = currentSpies();
-      for (var i = 0; i < spies.length; i++) {
+      for (var i = spies.length - 1; i >= 0; i--) {
         var spyEntry = spies[i];
-        spyEntry.baseObj[spyEntry.methodName] = spyEntry.originalValue;
+        spyEntry.restoreObjectToOriginalState();
       }
     };
   }

src/core/SpyStrategy.js

@@ -45,6 +45,9 @@ getJasmineRequireObj().SpyStrategy = function() {
     };
 
     this.callFake = function(fn) {
+      if(!(fn instanceof Function)) {
+        throw new Error('Argument passed to callFake should be a function, got ' + fn);
+      }
       plan = fn;
       return getSpy();
     };

src/core/Suite.js

@@ -29,13 +29,13 @@ getJasmineRequireObj().Suite = function(j$) {
   };
 
   Suite.prototype.getFullName = function() {
-    var fullName = this.description;
-    for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
+    var fullName = [];
+    for (var parentSuite = this; parentSuite; parentSuite = parentSuite.parentSuite) {
       if (parentSuite.parentSuite) {
-        fullName = parentSuite.description + ' ' + fullName;
+        fullName.unshift(parentSuite.description);
       }
     }
-    return fullName;
+    return fullName.join(' ');
   };
 
   Suite.prototype.disable = function() {

src/core/base.js

@@ -38,7 +38,12 @@ getJasmineRequireObj().base = function(j$, jasmineGlobal) {
   };
 
   j$.fnNameFor = function(func) {
-    return func.name || func.toString().match(/^\s*function\s*(\w*)\s*\(/)[1];
+    if (func.name) {
+      return func.name;
+    }
+
+    var matches = func.toString().match(/^\s*function\s*(\w*)\s*\(/);
+    return matches ? matches[1] : '<anonymous>';
   };
 
   j$.any = function(clazz) {

src/core/formatErrorMsg.js

@@ -0,0 +1,11 @@
+getJasmineRequireObj().formatErrorMsg = function() {
+  function generateErrorMsg(domain, usage) {
+    var usageDefinition = usage ? '\nUsage: ' + usage : '';
+
+    return function errorMsg(msg) {
+      return domain + ' : ' + msg + usageDefinition;
+    };
+  }
+
+  return generateErrorMsg;
+};

src/core/matchers/matchersUtil.js

@@ -161,35 +161,43 @@ getJasmineRequireObj().matchersUtil = function(j$) {
     var size = 0;
     // Recursively compare objects and arrays.
     // Compare array lengths to determine if a deep comparison is necessary.
-    if (className == '[object Array]' && a.length !== b.length) {
-      result = false;
-    }
+    if (className == '[object Array]') {
+      size = a.length;
+      if (size !== b.length) {
+        return false;
+      }
 
-    if (result) {
-      // Objects with different constructors are not equivalent, but `Object`s
-      // or `Array`s from different frames are.
-      if (className !== '[object Array]') {
-        var aCtor = a.constructor, bCtor = b.constructor;
-        if (aCtor !== bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor &&
-               isFunction(bCtor) && bCtor instanceof bCtor)) {
+      while (size--) {
+        result = eq(a[size], b[size], aStack, bStack, customTesters);
+        if (!result) {
           return false;
         }
       }
-      // Deep compare objects.
-      for (var key in a) {
-        if (has(a, key)) {
-          // Count the expected number of properties.
-          size++;
-          // Deep compare each member.
-          if (!(result = has(b, key) && eq(a[key], b[key], aStack, bStack, customTesters))) { break; }
-        }
+    } else {
+
+      // Objects with different constructors are not equivalent, but `Object`s
+      // or `Array`s from different frames are.
+      var aCtor = a.constructor, bCtor = b.constructor;
+      if (aCtor !== bCtor && !(isObjectConstructor(aCtor) &&
+                               isObjectConstructor(bCtor))) {
+        return false;
       }
-      // Ensure that both objects contain the same number of properties.
-      if (result) {
-        for (key in b) {
-          if (has(b, key) && !(size--)) { break; }
-        }
-        result = !size;
+    }
+
+    // Deep compare objects.
+    var aKeys = keys(a, className == '[object Array]'), key;
+    size = aKeys.length;
+
+    // Ensure that both objects contain the same number of properties before comparing deep equality.
+    if (keys(b, className == '[object Array]').length !== size) { return false; }
+
+    while (size--) {
+      key = aKeys[size];
+      // Deep compare each member
+      result = has(b, key) && eq(a[key], b[key], aStack, bStack, customTesters);
+
+      if (!result) {
+        return false;
       }
     }
     // Remove the first object from the stack of traversed objects.
@@ -198,12 +206,50 @@ getJasmineRequireObj().matchersUtil = function(j$) {
 
     return result;
 
-    function has(obj, key) {
-      return Object.prototype.hasOwnProperty.call(obj, key);
-    }
+    function keys(obj, isArray) {
+      var allKeys = Object.keys ? Object.keys(obj) :
+        (function(o) {
+            var keys = [];
+            for (var key in o) {
+                if (has(o, key)) {
+                    keys.push(key);
+                }
+            }
+            return keys;
+        })(obj);
 
-    function isFunction(obj) {
-      return typeof obj === 'function';
+      if (!isArray) {
+        return allKeys;
+      }
+
+      var extraKeys = [];
+      if (allKeys.length === 0) {
+          return allKeys;
+      }
+
+      for (var x = 0; x < allKeys.length; x++) {
+          if (!allKeys[x].match(/^[0-9]+$/)) {
+              extraKeys.push(allKeys[x]);
+          }
+      }
+
+      return extraKeys;
     }
   }
+
+  function has(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+  }
+
+  function isFunction(obj) {
+    return typeof obj === 'function';
+  }
+
+  function isObjectConstructor(ctor) {
+    // aCtor instanceof aCtor is true for the Object and Function
+    // constructors (since a constructor is-a Function and a function is-a
+    // Object). We don't just compare ctor === Object because the constructor
+    // might come from a different frame with different globals.
+    return isFunction(ctor) && ctor instanceof ctor;
+  }
 };

src/core/matchers/requireMatchers.js

@@ -5,6 +5,8 @@ getJasmineRequireObj().requireMatchers = function(jRequire, j$) {
       'toBeDefined',
       'toBeFalsy',
       'toBeGreaterThan',
+      'toBeGreaterThanOrEqual',
+      'toBeLessThanOrEqual',
       'toBeLessThan',
       'toBeNaN',
       'toBeNull',

src/core/matchers/toBeGreaterThanOrEqual.js

@@ -0,0 +1,14 @@
+getJasmineRequireObj().toBeGreaterThanOrEqual = function() {
+
+  function toBeGreaterThanOrEqual() {
+    return {
+      compare: function(actual, expected) {
+        return {
+          pass: actual >= expected
+        };
+      }
+    };
+  }
+
+  return toBeGreaterThanOrEqual;
+};

src/core/matchers/toBeLessThanOrEqual.js

@@ -0,0 +1,14 @@
+getJasmineRequireObj().toBeLessThanOrEqual = function() {
+  function toBeLessThanOrEqual() {
+    return {
+
+      compare: function(actual, expected) {
+        return {
+          pass: actual <= expected
+        };
+      }
+    };
+  }
+
+  return toBeLessThanOrEqual;
+};

src/core/matchers/toHaveBeenCalled.js

@@ -1,16 +1,18 @@
 getJasmineRequireObj().toHaveBeenCalled = function(j$) {
 
+  var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalled>', 'expect(<spyObj>).toHaveBeenCalled()');
+
   function toHaveBeenCalled() {
     return {
       compare: function(actual) {
         var result = {};
 
         if (!j$.isSpy(actual)) {
-          throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
+          throw new Error(getErrorMsg('Expected a spy, but got ' + j$.pp(actual) + '.'));
         }
 
         if (arguments.length > 1) {
-          throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
+          throw new Error(getErrorMsg('Does not take arguments, use toHaveBeenCalledWith'));
         }
 
         result.pass = actual.calls.any();

src/core/matchers/toHaveBeenCalledTimes.js

@@ -1,17 +1,19 @@
 getJasmineRequireObj().toHaveBeenCalledTimes = function(j$) {
 
+  var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalledTimes>', 'expect(<spyObj>).toHaveBeenCalledTimes(<Number>)');
+
   function toHaveBeenCalledTimes() {
     return {
       compare: function(actual, expected) {
         if (!j$.isSpy(actual)) {
-          throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
+          throw new Error(getErrorMsg('Expected a spy, but got ' + j$.pp(actual) + '.'));
         }
 
         var args = Array.prototype.slice.call(arguments, 0),
           result = { pass: false };
 
-        if(!expected){
-          throw new Error('Expected times failed is required as an argument.');
+        if (!j$.isNumber_(expected)){
+          throw new Error(getErrorMsg('The expected times failed is a required argument and must be a number.'));
         }
 
         actual = args[0];

src/core/matchers/toHaveBeenCalledWith.js

@@ -1,5 +1,7 @@
 getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
 
+  var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalledWith>', 'expect(<spyObj>).toHaveBeenCalledWith(...arguments)');
+
   function toHaveBeenCalledWith(util, customEqualityTesters) {
     return {
       compare: function() {
@@ -9,7 +11,7 @@ getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
           result = { pass: false };
 
         if (!j$.isSpy(actual)) {
-          throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
+          throw new Error(getErrorMsg('Expected a spy, but got ' + j$.pp(actual) + '.'));
         }
 
         if (!actual.calls.any()) {

src/core/matchers/toMatch.js

@@ -1,10 +1,12 @@
 getJasmineRequireObj().toMatch = function(j$) {
 
+  var getErrorMsg = j$.formatErrorMsg('<toMatch>', 'expect(<expectation>).toMatch(<string> || <regexp>)');
+
   function toMatch() {
     return {
       compare: function(actual, expected) {
         if (!j$.isString_(expected) && !j$.isA_('RegExp', expected)) {
-          throw new Error('Expected is not a String or a RegExp');
+          throw new Error(getErrorMsg('Expected is not a String or a RegExp'));
         }
 
         var regexp = new RegExp(expected);

src/core/matchers/toThrow.js

@@ -1,5 +1,7 @@
 getJasmineRequireObj().toThrow = function(j$) {
 
+  var getErrorMsg = j$.formatErrorMsg('<toThrow>', 'expect(function() {<expectation>}).toThrow()');
+
   function toThrow(util) {
     return {
       compare: function(actual, expected) {
@@ -8,7 +10,7 @@ getJasmineRequireObj().toThrow = function(j$) {
           thrown;
 
         if (typeof actual != 'function') {
-          throw new Error('Actual is not a Function');
+          throw new Error(getErrorMsg('Actual is not a Function'));
         }
 
         try {