jasmine-core 1.3.1 → 2.0.0.rc2

data/lib/jasmine-core/spec/support/dev_boot.js

@@ -0,0 +1,118 @@
+// Jasmine boot.js for browser runners - exposes external/global interface, builds the Jasmine environment and executes it.
+(function() {
+
+  window.jasmine = jasmineRequire.core(jasmineRequire);
+  jasmineRequire.html(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);
+    },
+
+    pending: function() {
+      return env.pending();
+    },
+
+    addMatchers: function(matchers) {
+      return env.addMatchers(matchers);
+    },
+
+    spyOn: function(obj, methodName) {
+      return env.spyOn(obj, methodName);
+    },
+
+    clock: env.clock,
+    setTimeout: env.clock.setTimeout,
+    clearTimeout: env.clock.clearTimeout,
+    setInterval: env.clock.setInterval,
+    clearInterval: env.clock.clearInterval,
+
+    jsApiReporter: new jasmine.JsApiReporter({
+      timer: new jasmine.Timer()
+    })
+  };
+
+  if (typeof window == "undefined" && typeof exports == "object") {
+    extend(exports, jasmineInterface);
+  } else {
+    extend(window, jasmineInterface);
+  }
+
+  var queryString = new jasmine.QueryString({
+    getWindowLocation: function() { return window.location; }
+  });
+
+  // TODO: move all of catching to raise so we don't break our brains
+  var catchingExceptions = queryString.getParam("catch");
+  env.catchExceptions(typeof catchingExceptions === "undefined" ? true : catchingExceptions);
+
+  var htmlReporter = new jasmine.HtmlReporter({
+    env: env,
+    queryString: queryString,
+    onRaiseExceptionsClick: function() { queryString.setParam("catch", !env.catchingExceptions()); },
+    getContainer: function() { return document.body; },
+    createElement: function() { return document.createElement.apply(document, arguments); },
+    createTextNode: function() { return document.createTextNode.apply(document, arguments); },
+    timer: new jasmine.Timer()
+  });
+
+  env.addReporter(jasmineInterface.jsApiReporter);
+  env.addReporter(htmlReporter);
+
+  var specFilter = new jasmine.HtmlSpecFilter({
+    filterString: function() { return queryString.getParam("spec"); }
+  });
+
+  env.specFilter = function(spec) {
+    return specFilter.matches(spec.getFullName());
+  };
+
+  var currentWindowOnload = window.onload;
+
+  window.onload = function() {
+    if (currentWindowOnload) {
+      currentWindowOnload();
+    }
+    htmlReporter.initialize();
+
+    // 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$);
+
+    env.execute();
+  };
+
+  function extend(destination, source) {
+    for (var property in source) destination[property] = source[property];
+    return destination;
+  }
+
+}());

data/lib/jasmine-core/version.rb

@@ -1,6 +1,9 @@
+#
+# DO NOT Edit this file. Canonical version of Jasmine lives in the repo's package.json. This file is generated
+# by a grunt task when the standalone release is built.
+#
 module Jasmine
   module Core
-    VERSION = "1.3.1"
+    VERSION = "2.0.0.rc2"
   end
 end
-

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: jasmine-core
 version: !ruby/object:Gem::Version
-  version: 1.3.1
-  prerelease: 
+  version: 2.0.0.rc2
+  prerelease: 6
 platform: ruby
 authors:
 - Rajan Agaskar
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-03 00:00:00.000000000 Z
+date: 2013-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_pure
@@ -29,22 +29,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.4.3
-- !ruby/object:Gem::Dependency
-  name: tilt
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: sass
   requirement: !ruby/object:Gem::Requirement
@@ -77,22 +61,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: ragaskar-jsdoc_helper
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -141,22 +109,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: thor
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -174,39 +126,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: redcarpet
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: '1.7'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: '1.7'
-- !ruby/object:Gem::Dependency
-  name: rocco
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rdiscount
+  name: sauce-connect
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -228,9 +148,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ./lib/jasmine-core/boot/boot.js
+- ./lib/jasmine-core/boot.js
 - ./lib/jasmine-core/example/spec/PlayerSpec.js
 - ./lib/jasmine-core/example/spec/SpecHelper.js
-- ./lib/jasmine-core/example/SpecRunner.html
 - ./lib/jasmine-core/example/src/Player.js
 - ./lib/jasmine-core/example/src/Song.js
 - ./lib/jasmine-core/jasmine-html.js
@@ -240,30 +161,56 @@ files:
 - ./lib/jasmine-core/version.rb
 - ./lib/jasmine-core.rb
 - ./lib/jasmine-core/spec/console/ConsoleReporterSpec.js
-- ./lib/jasmine-core/spec/core/BaseSpec.js
+- ./lib/jasmine-core/spec/core/AnySpec.js
+- ./lib/jasmine-core/spec/core/CallTrackerSpec.js
+- ./lib/jasmine-core/spec/core/ClockSpec.js
 - ./lib/jasmine-core/spec/core/CustomMatchersSpec.js
+- ./lib/jasmine-core/spec/core/DelayedFunctionSchedulerSpec.js
 - ./lib/jasmine-core/spec/core/EnvSpec.js
+- ./lib/jasmine-core/spec/core/ExceptionFormatterSpec.js
 - ./lib/jasmine-core/spec/core/ExceptionsSpec.js
+- ./lib/jasmine-core/spec/core/ExpectationResultSpec.js
+- ./lib/jasmine-core/spec/core/ExpectationSpec.js
 - ./lib/jasmine-core/spec/core/JsApiReporterSpec.js
-- ./lib/jasmine-core/spec/core/MatchersSpec.js
-- ./lib/jasmine-core/spec/core/MockClockSpec.js
-- ./lib/jasmine-core/spec/core/MultiReporterSpec.js
-- ./lib/jasmine-core/spec/core/NestedResultsSpec.js
+- ./lib/jasmine-core/spec/core/matchers/matchersUtilSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toBeCloseToSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toBeDefinedSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toBeFalsySpec.js
+- ./lib/jasmine-core/spec/core/matchers/toBeGreaterThanSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toBeLessThanSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toBeNaNSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toBeNullSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toBeSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toBeTruthySpec.js
+- ./lib/jasmine-core/spec/core/matchers/toBeUndefinedSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toContainSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toEqualSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toHaveBeenCalledSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toHaveBeenCalledWithSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toMatchSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toThrowErrorSpec.js
+- ./lib/jasmine-core/spec/core/matchers/toThrowSpec.js
+- ./lib/jasmine-core/spec/core/ObjectContainingSpec.js
 - ./lib/jasmine-core/spec/core/PrettyPrintSpec.js
-- ./lib/jasmine-core/spec/core/QueueSpec.js
-- ./lib/jasmine-core/spec/core/ReporterSpec.js
-- ./lib/jasmine-core/spec/core/RunnerSpec.js
+- ./lib/jasmine-core/spec/core/QueueRunnerSpec.js
+- ./lib/jasmine-core/spec/core/ReportDispatcherSpec.js
 - ./lib/jasmine-core/spec/core/SpecRunningSpec.js
 - ./lib/jasmine-core/spec/core/SpecSpec.js
 - ./lib/jasmine-core/spec/core/SpySpec.js
+- ./lib/jasmine-core/spec/core/SpyStrategySpec.js
 - ./lib/jasmine-core/spec/core/SuiteSpec.js
+- ./lib/jasmine-core/spec/core/TimerSpec.js
 - ./lib/jasmine-core/spec/core/UtilSpec.js
-- ./lib/jasmine-core/spec/core/WaitsForBlockSpec.js
-- ./lib/jasmine-core/spec/html/HTMLReporterSpec.js
+- ./lib/jasmine-core/spec/helpers/BrowserFlags.js
+- ./lib/jasmine-core/spec/html/HtmlReporterSpec.js
+- ./lib/jasmine-core/spec/html/HtmlSpecFilterSpec.js
 - ./lib/jasmine-core/spec/html/MatchersHtmlSpec.js
 - ./lib/jasmine-core/spec/html/PrettyPrintHtmlSpec.js
-- ./lib/jasmine-core/spec/html/TrivialReporterSpec.js
+- ./lib/jasmine-core/spec/html/QueryStringSpec.js
+- ./lib/jasmine-core/spec/html/ResultsNodeSpec.js
 - ./lib/jasmine-core/spec/node_suite.js
+- ./lib/jasmine-core/spec/performance/performance_test.js
+- ./lib/jasmine-core/spec/support/dev_boot.js
 homepage: http://pivotal.github.com/jasmine
 licenses:
 - MIT
@@ -279,19 +226,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2880110052648878798
+      hash: 1155836624161041639
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: -2880110052648878798
+      version: 1.3.1
 requirements: []
 rubyforge_project: jasmine-core
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: JavaScript BDD framework

data/lib/jasmine-core/example/SpecRunner.html

@@ -1,54 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
-  "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-<head>
-  <title>Jasmine Spec Runner</title>
-
-  <link rel="shortcut icon" type="image/png" href="lib/jasmine-1.1.0.rc1/jasmine_favicon.png">
-
-  <link rel="stylesheet" type="text/css" href="lib/jasmine-1.1.0.rc1/jasmine.css">
-  <script type="text/javascript" src="lib/jasmine-1.1.0.rc1/jasmine.js"></script>
-  <script type="text/javascript" src="lib/jasmine-1.1.0.rc1/jasmine-html.js"></script>
-
-  <!-- include spec files here... -->
-  <script type="text/javascript" src="spec/SpecHelper.js"></script>
-  <script type="text/javascript" src="spec/PlayerSpec.js"></script>
-
-  <!-- include source files here... -->
-  <script type="text/javascript" src="src/Player.js"></script>
-  <script type="text/javascript" src="src/Song.js"></script>
-
-  <script type="text/javascript">
-    (function() {
-      var jasmineEnv = jasmine.getEnv();
-      jasmineEnv.updateInterval = 1000;
-
-      var trivialReporter = new jasmine.TrivialReporter();
-
-      jasmineEnv.addReporter(trivialReporter);
-
-      jasmineEnv.specFilter = function(spec) {
-        return trivialReporter.specFilter(spec);
-      };
-
-      var currentWindowOnload = window.onload;
-
-      window.onload = function() {
-        if (currentWindowOnload) {
-          currentWindowOnload();
-        }
-        execJasmine();
-      };
-
-      function execJasmine() {
-        jasmineEnv.execute();
-      }
-
-    })();
-  </script>
-
-</head>
-
-<body>
-</body>
-</html>

data/lib/jasmine-core/spec/core/BaseSpec.js

@@ -1,27 +0,0 @@
-describe("base.js", function() {
-  describe("jasmine.MessageResult", function() {
-    it("#toString should pretty-print and concatenate each part of the message", function() {
-      var values = ["log", "message", 123, {key: "value"}, "FTW!"];
-      var messageResult = new jasmine.MessageResult(values);
-      expect(messageResult.toString()).toEqual("log message 123 { key : 'value' } FTW!");
-    });
-  });
-
-  describe("jasmine.log", function() {
-    it("should accept n arguments", function() {
-      spyOn(jasmine.getEnv().currentSpec, 'log');
-      jasmine.log(1, 2, 3);
-      expect(jasmine.getEnv().currentSpec.log).toHaveBeenCalledWith(1, 2, 3);
-    });
-  });
-
-  describe("jasmine.getGlobal", function() {
-    it("should return the global object", function() {
-      var globalObject = (function() {
-        return this;
-      })();
-
-      expect(jasmine.getGlobal()).toBe(globalObject);
-    });
-  });
-});

data/lib/jasmine-core/spec/core/MatchersSpec.js

@@ -1,1157 +0,0 @@
-describe("jasmine.Matchers", function() {
-  var env, spec;
-
-  beforeEach(function() {
-    env = new jasmine.Env();
-    env.updateInterval = 0;
-
-    var suite = env.describe("suite", function() {
-      spec = env.it("spec", function() {
-      });
-    });
-    spyOn(spec, 'addMatcherResult');
-
-    this.addMatchers({
-      toPass: function() {
-        return lastResult().passed();
-      },
-      toFail: function() {
-        return !lastResult().passed();
-      }
-    });
-  });
-
-  function match(value) {
-    return spec.expect(value);
-  }
-
-  function lastResult() {
-    return spec.addMatcherResult.mostRecentCall.args[0];
-  }
-
-  function catchException(fn) {
-    try {
-      fn.call();
-    } catch (e) {
-      return e;
-    }
-    throw new Error("expected function to throw an exception");
-  }
-
-  it("toEqual with primitives, objects, dates, etc.", function() {
-    expect(match(true).toEqual(true)).toPass();
-
-    expect(match({foo:'bar'}).toEqual(null)).toFail();
-
-    var functionA = function() {
-      return 'hi';
-    };
-    var functionB = function() {
-      return 'hi';
-    };
-    expect(match({foo:functionA}).toEqual({foo:functionB})).toFail();
-    expect(match({foo:functionA}).toEqual({foo:functionA})).toPass();
-
-    expect((match(false).toEqual(true))).toFail();
-
-    var circularGraph = {};
-    circularGraph.referenceToSelf = circularGraph;
-    expect((match(circularGraph).toEqual(circularGraph))).toPass();
-
-    expect((match(new Date(2008, 1, 3, 15, 17, 19, 1234)).toEqual(new Date(2009, 1, 3, 15, 17, 19, 1234)))).toFail();
-    expect((match(new Date(2008, 1, 3, 15, 17, 19, 1234)).toEqual(new Date(2008, 1, 3, 15, 17, 19, 1234)))).toPass();
-
-
-    expect(match(true).toNotEqual(false)).toPass();
-    expect((match(true).toNotEqual(true))).toFail();
-
-    expect((match(['a', 'b']).toEqual(['a', jasmine.undefined]))).toFail();
-    expect((match(['a', 'b']).toEqual(['a', 'b', jasmine.undefined]))).toFail();
-
-    expect((match("cat").toEqual("cat"))).toPass();
-    expect((match("cat").toNotEqual("cat"))).toFail();
-
-    expect((match(5).toEqual(5))).toPass();
-    expect((match(parseInt('5', 10)).toEqual(5))).toPass();
-    expect((match(5).toNotEqual(5))).toFail();
-    expect((match(parseInt('5', 10)).toNotEqual(5))).toFail();
-
-    expect((match(/1/i).toEqual(/1/i))).toPass();
-    expect((match(/1/i).toNotEqual(/1/i))).toFail();
-    expect((match(/[abc]/gm).toEqual(/1/i))).toFail();
-    expect((match(/[abc]/gm).toNotEqual(/1/i))).toPass();
-
-    // only test if the browser supports the sticky option on a regExp see pull #234
-    if (RegExp.prototype.sticky !== undefined) {
-      var sticky_regexp = new RegExp("[abc]", "y");
-      expect((match(sticky_regexp).toEqual(/1/i))).toFail();
-      expect((match(sticky_regexp).toNotEqual(/1/i))).toPass();
-    }
-  });
-
-  it("toEqual to build an Expectation Result", function() {
-    var actual = 'a';
-    var matcher = match(actual);
-    var expected = 'b';
-    matcher.toEqual(expected);
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toEqual");
-    expect(result.passed()).toFail();
-    expect(result.message).toMatch(jasmine.pp(actual));
-    expect(result.message).toMatch(jasmine.pp(expected));
-    expect(result.expected).toEqual(expected);
-    expect(result.actual).toEqual(actual);
-  });
-
-  it("toNotEqual to build an Expectation Result", function() {
-    var str = 'a';
-    var matcher = match(str);
-    matcher.toNotEqual(str);
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toNotEqual");
-    expect(result.passed()).toFail();
-    expect(result.message).toMatch(jasmine.pp(str));
-    expect(result.message).toMatch('not');
-    expect(result.expected).toEqual(str);
-    expect(result.actual).toEqual(str);
-  });
-
-  it('toBe should return true only if the expected and actual items === each other', function() {
-    var a = {};
-    var b = {};
-    //noinspection UnnecessaryLocalVariableJS
-    var c = a;
-    expect((match(a).toBe(b))).toFail();
-    expect((match(a).toBe(a))).toPass();
-    expect((match(a).toBe(c))).toPass();
-    expect((match(a).toNotBe(b))).toPass();
-    expect((match(a).toNotBe(a))).toFail();
-    expect((match(a).toNotBe(c))).toFail();
-  });
-
-  it("toBe to build an ExpectationResult", function() {
-    var expected = 'b';
-    var actual = 'a';
-    var matcher = match(actual);
-    matcher.toBe(expected);
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toBe");
-    expect(result.passed()).toFail();
-    expect(result.message).toMatch(jasmine.pp(actual));
-    expect(result.message).toMatch(jasmine.pp(expected));
-    expect(result.expected).toEqual(expected);
-    expect(result.actual).toEqual(actual);
-  });
-
-  it("toNotBe to build an ExpectationResult", function() {
-    var str = 'a';
-    var matcher = match(str);
-    matcher.toNotBe(str);
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toNotBe");
-    expect(result.passed()).toFail();
-    expect(result.message).toMatch(str);
-    expect(result.expected).toEqual(str);
-    expect(result.actual).toEqual(str);
-  });
-
-  it("toMatch and #toNotMatch should perform regular expression matching on strings", function() {
-    expect((match('foobarbel').toMatch(/bar/))).toPass();
-    expect((match('foobazbel').toMatch(/bar/))).toFail();
-
-    expect((match('foobarbel').toMatch("bar"))).toPass();
-    expect((match('foobazbel').toMatch("bar"))).toFail();
-
-    expect((match('foobarbel').toNotMatch(/bar/))).toFail();
-    expect((match('foobazbel').toNotMatch(/bar/))).toPass();
-
-    expect((match('foobarbel').toNotMatch("bar"))).toFail();
-    expect((match('foobazbel').toNotMatch("bar"))).toPass();
-  });
-
-  it("toMatch w/ RegExp to build an ExpectationResult", function() {
-    var actual = 'a';
-    var matcher = match(actual);
-    var expected = /b/;
-    matcher.toMatch(expected);
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toMatch");
-    expect(result.passed()).toFail();
-    expect(result.message).toMatch(jasmine.pp(actual));
-    expect(result.message).toMatch(expected.toString());
-    expect(result.expected).toEqual(expected);
-    expect(result.actual).toEqual(actual);
-  });
-
-  it("toMatch w/ String to build an ExpectationResult", function() {
-    var actual = 'a';
-    var matcher = match(actual);
-    var expected = 'b';
-    matcher.toMatch(expected);
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toMatch");
-    expect(result.passed()).toFail();
-    expect(result.message).toEqual("Expected 'a' to match 'b'.");
-    expect(result.expected).toEqual(expected);
-    expect(result.actual).toEqual(actual);
-  });
-
-  it("toNotMatch w/ RegExp to build an ExpectationResult", function() {
-    var actual = 'a';
-    var matcher = match(actual);
-    var expected = /a/;
-    matcher.toNotMatch(expected);
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toNotMatch");
-    expect(result.passed()).toFail();
-    expect(result.message).toEqual("Expected 'a' to not match /a/.");
-    expect(result.expected).toEqual(expected);
-    expect(result.actual).toEqual(actual);
-  });
-
-  it("toNotMatch w/ String to build an ExpectationResult", function() {
-    var str = 'a';
-    var matcher = match(str);
-    matcher.toNotMatch(str);
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toNotMatch");
-    expect(result.passed()).toFail();
-    expect(result.message).toEqual("Expected 'a' to not match 'a'.");
-    expect(result.expected).toEqual(str);
-    expect(result.actual).toEqual(str);
-  });
-
-  it("toBeDefined", function() {
-    expect(match('foo').toBeDefined()).toPass();
-    expect(match(jasmine.undefined).toBeDefined()).toFail();
-  });
-
-  it("toBeDefined to build an ExpectationResult", function() {
-    var matcher = match(jasmine.undefined);
-    matcher.toBeDefined();
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toBeDefined");
-    expect(result.passed()).toFail();
-    expect(result.message).toEqual('Expected undefined to be defined.');
-    expect(result.actual).toEqual(jasmine.undefined);
-  });
-
-  it("toBeUndefined", function() {
-    expect(match('foo').toBeUndefined()).toFail();
-    expect(match(jasmine.undefined).toBeUndefined()).toPass();
-  });
-
-  it("toBeNull", function() {
-    expect(match(null).toBeNull()).toPass();
-    expect(match(jasmine.undefined).toBeNull()).toFail();
-    expect(match("foo").toBeNull()).toFail();
-  });
-
-  it("toBeNull w/ String to build an ExpectationResult", function() {
-    var actual = 'a';
-    var matcher = match(actual);
-    matcher.toBeNull();
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toBeNull");
-    expect(result.passed()).toFail();
-    expect(result.message).toMatch(jasmine.pp(actual));
-    expect(result.message).toMatch('null');
-    expect(result.actual).toEqual(actual);
-  });
-
-  it("toBeNull w/ Object to build an ExpectationResult", function() {
-    var actual = {a: 'b'};
-    var matcher = match(actual);
-    matcher.toBeNull();
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toBeNull");
-    expect(result.passed()).toFail();
-    expect(result.message).toMatch(jasmine.pp(actual));
-    expect(result.message).toMatch('null');
-    expect(result.actual).toEqual(actual);
-  });
-
-	it("toBeNaN", function() {
-		expect(match(Number.NaN).toBeNaN()).toPass();
-		expect(match(0).toBeNaN()).toFail();
-		expect(match(1).toBeNaN()).toFail();
-		expect(match(null).toBeNaN()).toFail();
-		expect(match(Number.POSITIVE_INFINITY).toBeNaN()).toFail();
-		expect(match(Number.NEGATIVE_INFINITY).toBeNaN()).toFail();
-		expect(match('NaN').toBeNaN()).toFail();
-	});
-
-	it("toBeNaN to build an ExpectationResult", function() {
-		var actual = 'a';
-		var matcher = match(actual);
-		matcher.toBeNaN();
-
-		var result = lastResult();
-
-		expect(result.matcherName).toEqual("toBeNaN");
-		expect(result.passed()).toFail();
-		expect(result.message).toMatch("Expected 'a' to be NaN.");
-		expect(result.actual).toMatch(actual);
-	});
-
-  it("toBeFalsy", function() {
-    expect(match(false).toBeFalsy()).toPass();
-    expect(match(true).toBeFalsy()).toFail();
-    expect(match(jasmine.undefined).toBeFalsy()).toPass();
-    expect(match(0).toBeFalsy()).toPass();
-    expect(match("").toBeFalsy()).toPass();
-  });
-
-  it("toBeFalsy to build an ExpectationResult", function() {
-    var actual = 'a';
-    var matcher = match(actual);
-    matcher.toBeFalsy();
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toBeFalsy");
-    expect(result.passed()).toFail();
-    expect(result.message).toMatch(jasmine.pp(actual));
-    expect(result.message).toMatch('falsy');
-    expect(result.actual).toEqual(actual);
-  });
-
-  it("toBeTruthy", function() {
-    expect(match(false).toBeTruthy()).toFail();
-    expect(match(true).toBeTruthy()).toPass();
-    expect(match(jasmine.undefined).toBeTruthy()).toFail();
-    expect(match(0).toBeTruthy()).toFail();
-    expect(match("").toBeTruthy()).toFail();
-    expect(match("hi").toBeTruthy()).toPass();
-    expect(match(5).toBeTruthy()).toPass();
-    expect(match({foo: 1}).toBeTruthy()).toPass();
-  });
-
-  it("toBeTruthy to build an ExpectationResult", function() {
-    var matcher = match(false);
-    matcher.toBeTruthy();
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toBeTruthy");
-    expect(result.passed()).toFail();
-    expect(result.message).toEqual("Expected false to be truthy.");
-    expect(result.actual).toFail();
-  });
-
-  it("toEqual", function() {
-    expect(match(jasmine.undefined).toEqual(jasmine.undefined)).toPass();
-    expect(match({foo:'bar'}).toEqual({foo:'bar'})).toPass();
-    expect(match("foo").toEqual({bar: jasmine.undefined})).toFail();
-    expect(match({foo: jasmine.undefined}).toEqual("goo")).toFail();
-    expect(match({foo: {bar :jasmine.undefined}}).toEqual("goo")).toFail();
-  });
-
-  it("toEqual with jasmine.any()", function() {
-    expect(match("foo").toEqual(jasmine.any(String))).toPass();
-    expect(match(3).toEqual(jasmine.any(Number))).toPass();
-    expect(match("foo").toEqual(jasmine.any(Function))).toFail();
-    expect(match("foo").toEqual(jasmine.any(Object))).toFail();
-    expect(match({someObj:'foo'}).toEqual(jasmine.any(Object))).toPass();
-    expect(match({someObj:'foo'}).toEqual(jasmine.any(Function))).toFail();
-    expect(match(
-      function() {
-      }).toEqual(jasmine.any(Object))).toFail();
-    expect(match(["foo", "goo"]).toEqual(["foo", jasmine.any(String)])).toPass();
-    expect(match(
-      function() {
-      }).toEqual(jasmine.any(Function))).toPass();
-    expect(match(["a", function() {
-    }]).toEqual(["a", jasmine.any(Function)])).toPass();
-  });
-
-  describe("toEqual with an object implementing jasmineMatches", function () {
-    var matcher;
-    beforeEach(function () {
-      matcher = {
-        jasmineMatches: jasmine.createSpy("jasmineMatches")
-      };
-    });
-
-    describe("on the left side", function () {
-      it("uses the jasmineMatches function", function () {
-        matcher.jasmineMatches.andReturn(false);
-        expect(match(matcher).toEqual("foo")).toFail();
-        matcher.jasmineMatches.andReturn(true);
-        expect(match(matcher).toEqual("foo")).toPass();
-      });
-    });
-
-    describe("on the right side", function () {
-      it("uses the jasmineMatches function", function () {
-        matcher.jasmineMatches.andReturn(false);
-        expect(match("foo").toEqual(matcher)).toFail();
-        matcher.jasmineMatches.andReturn(true);
-        expect(match("foo").toEqual(matcher)).toPass();
-      });
-    });
-  });
-
-  it("toEqual handles circular objects ok", function() {
-    expect(match({foo: "bar", baz: jasmine.undefined}).toEqual({foo: "bar", baz: jasmine.undefined})).toPass();
-    expect(match({foo:['bar','baz','quux']}).toEqual({foo:['bar','baz','quux']})).toPass();
-    expect(match({foo: {bar:'baz'}, quux:'corge'}).toEqual({foo:{bar:'baz'}, quux:'corge'})).toPass();
-
-    var circularObject = {};
-    var secondCircularObject = {};
-    circularObject.field = circularObject;
-    secondCircularObject.field = secondCircularObject;
-    expect(match(circularObject).toEqual(secondCircularObject)).toPass();
-  });
-
-  it("toNotEqual as slightly surprising behavior, but is it intentional?", function() {
-    expect(match({x:"x", y:"y", z:"w"}).toNotEqual({x:"x", y:"y", z:"z"})).toPass();
-    expect(match({x:"x", y:"y", w:"z"}).toNotEqual({x:"x", y:"y", z:"z"})).toPass();
-    expect(match({x:"x", y:"y", z:"z"}).toNotEqual({w: "w", x:"x", y:"y", z:"z"})).toPass();
-    expect(match({w: "w", x:"x", y:"y", z:"z"}).toNotEqual({x:"x", y:"y", z:"z"})).toPass();
-  });
-
-  it("toEqual handles arrays", function() {
-    expect(match([1, "A"]).toEqual([1, "A"])).toPass();
-  });
-
-  it("toContain and toNotContain", function() {
-    expect(match('ABC').toContain('A')).toPass();
-    expect(match('ABC').toContain('X')).toFail();
-
-    expect(match(['A', 'B', 'C']).toContain('A')).toPass();
-    expect(match(['A', 'B', 'C']).toContain('F')).toFail();
-    expect(match(['A', 'B', 'C']).toNotContain('F')).toPass();
-    expect(match(['A', 'B', 'C']).toNotContain('A')).toFail();
-
-    expect(match(['A', {some:'object'}, 'C']).toContain({some:'object'})).toPass();
-    expect(match(['A', {some:'object'}, 'C']).toContain({some:'other object'})).toFail();
-  });
-
-  it("toContain to build an ExpectationResult", function() {
-    var actual = ['a','b','c'];
-    var matcher = match(actual);
-    var expected = 'x';
-    matcher.toContain(expected);
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toContain");
-    expect(result.passed()).toFail();
-    expect(result.message).toMatch(jasmine.pp(actual));
-    expect(result.message).toMatch('contain');
-    expect(result.message).toMatch(jasmine.pp(expected));
-    expect(result.actual).toEqual(actual);
-    expect(result.expected).toEqual(expected);
-  });
-
-  it("toNotContain to build an ExpectationResult", function() {
-    var actual = ['a','b','c'];
-    var matcher = match(actual);
-    var expected = 'b';
-    matcher.toNotContain(expected);
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toNotContain");
-    expect(result.passed()).toFail();
-    expect(result.message).toMatch(jasmine.pp(actual));
-    expect(result.message).toMatch('not contain');
-    expect(result.message).toMatch(jasmine.pp(expected));
-    expect(result.actual).toEqual(actual);
-    expect(result.expected).toEqual(expected);
-  });
-
-  it("toBeLessThan should pass if actual is less than expected", function() {
-    expect(match(37).toBeLessThan(42)).toPass();
-    expect(match(37).toBeLessThan(-42)).toFail();
-    expect(match(37).toBeLessThan(37)).toFail();
-  });
-
-  it("toBeLessThan to build an ExpectationResult", function() {
-    var actual = 3;
-    var matcher = match(actual);
-    var expected = 1;
-    matcher.toBeLessThan(expected);
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toBeLessThan");
-    expect(result.passed()).toFail();
-    expect(result.message).toMatch(jasmine.pp(actual) + ' to be less than');
-    expect(result.message).toMatch(jasmine.pp(expected));
-    expect(result.actual).toEqual(actual);
-    expect(result.expected).toEqual(expected);
-  });
-
-  it("toBeGreaterThan should pass if actual is greater than expected", function() {
-    expect(match(37).toBeGreaterThan(42)).toFail();
-    expect(match(37).toBeGreaterThan(-42)).toPass();
-    expect(match(37).toBeGreaterThan(37)).toFail();
-  });
-
-  it("toBeGreaterThan to build an ExpectationResult", function() {
-    var actual = 1;
-    var matcher = match(actual);
-    var expected = 3;
-    matcher.toBeGreaterThan(expected);
-
-    var result = lastResult();
-
-    expect(result.matcherName).toEqual("toBeGreaterThan");
-    expect(result.passed()).toFail();
-    expect(result.message).toMatch(jasmine.pp(actual) + ' to be greater than');
-    expect(result.message).toMatch(jasmine.pp(expected));
-    expect(result.actual).toEqual(actual);
-    expect(result.expected).toEqual(expected);
-  });
-
-  describe("toBeCloseTo", function() {
-    it("returns 'true' iff actual and expected are equal within 2 decimal points of precision", function() {
-      expect(0).toBeCloseTo(0);
-      expect(1).toBeCloseTo(1);
-      expect(1).not.toBeCloseTo(1.1);
-      expect(1).not.toBeCloseTo(1.01);
-      expect(1).toBeCloseTo(1.001);
-
-      expect(1.23).toBeCloseTo(1.234);
-      expect(1.23).toBeCloseTo(1.233);
-      expect(1.23).toBeCloseTo(1.232);
-      expect(1.23).not.toBeCloseTo(1.24);
-
-      expect(-1.23).toBeCloseTo(-1.234);
-      expect(-1.23).not.toBeCloseTo(-1.24);
-    });
-
-    it("expects close numbers to 'be close' and further numbers not to", function() {
-      expect(1.225).not.toBeCloseTo(1.234); // difference is 0.009
-      expect(1.225).toBeCloseTo(1.224);     // difference is 0.001
-    });
-
-    it("accepts an optional precision argument", function() {
-      expect(1).toBeCloseTo(1.1, 0);
-      expect(1.2).toBeCloseTo(1.23, 1);
-
-      expect(1.234).toBeCloseTo(1.2343, 3);
-      expect(1.234).not.toBeCloseTo(1.233, 3);
-    });
-
-    it("rounds", function() {
-      expect(1.23).toBeCloseTo(1.229);
-      expect(1.23).toBeCloseTo(1.226);
-      expect(1.23).toBeCloseTo(1.225);
-      expect(1.23).not.toBeCloseTo(1.2249999);
-
-      expect(1.23).toBeCloseTo(1.234);
-      expect(1.23).toBeCloseTo(1.2349999);
-      expect(1.23).not.toBeCloseTo(1.235);
-
-      expect(-1.23).toBeCloseTo(-1.234);
-      expect(-1.23).not.toBeCloseTo(-1.235);
-      expect(-1.23).not.toBeCloseTo(-1.236);
-    });
-  });
-
-  describe("toThrow", function() {
-    describe("when code block throws an exception", function() {
-      var throwingFn;
-
-      beforeEach(function() {
-        throwingFn = function() {
-          throw new Error("Fake Error");
-        };
-      });
-
-      it("should match any exception", function() {
-        expect(match(throwingFn).toThrow()).toPass();
-      });
-
-      it("should match exceptions specified by message", function() {
-        expect(match(throwingFn).toThrow("Fake Error")).toPass();
-        expect(match(throwingFn).toThrow("Other Error")).toFail();
-        expect(lastResult().message).toMatch("Other Error");
-      });
-
-      it("should match exceptions specified by Error", function() {
-        expect(match(throwingFn).toThrow(new Error("Fake Error"))).toPass();
-        expect(match(throwingFn).toThrow(new Error("Other Error"))).toFail();
-        expect(lastResult().message).toMatch("Other Error");
-      });
-
-      describe("and matcher is inverted with .not", function() {
-        it("should match any exception", function() {
-          expect(match(throwingFn).not.toThrow()).toFail();
-          expect(lastResult().message).toMatch(/Expected function not to throw an exception/);
-        });
-
-        it("should match exceptions specified by message", function() {
-          expect(match(throwingFn).not.toThrow("Fake Error")).toFail();
-//          expect(lastResult().message).toMatch(/Expected function not to throw Fake Error./);
-          expect(match(throwingFn).not.toThrow("Other Error")).toPass();
-        });
-
-        it("should match exceptions specified by Error", function() {
-          expect(match(throwingFn).not.toThrow(new Error("Fake Error"))).toFail();
-//          expect(lastResult().message).toMatch("Other Error");
-          expect(match(throwingFn).not.toThrow(new Error("Other Error"))).toPass();
-        });
-      });
-    });
-
-    describe("when actual is not a function", function() {
-      it("should fail with an exception", function() {
-        var exception = catchException(function() {
-          match('not-a-function').toThrow();
-        });
-        expect(exception).toBeDefined();
-        expect(exception.message).toEqual('Actual is not a function');
-      });
-
-      describe("and matcher is inverted with .not", function() {
-        it("should fail with an exception", function() {
-          var exception = catchException(function() {
-            match('not-a-function').not.toThrow();
-          });
-          expect(exception).toBeDefined();
-          expect(exception.message).toEqual('Actual is not a function');
-        });
-      });
-    });
-
-
-    describe("when code block does not throw an exception", function() {
-      it("should fail (or pass when inverted with .not)", function() {
-        expect(match(
-          function() {
-          }).toThrow()).toFail();
-        expect(lastResult().message).toEqual('Expected function to throw an exception.');
-      });
-    });
-  });
-
-  describe(".not.matcher", function() {
-    it("should invert the sense of any matcher", function() {
-      expect(match(37).not.toBeGreaterThan(42)).toPass();
-      expect(match(42).not.toBeGreaterThan(37)).toFail();
-      expect(match("abc").not.toEqual("def")).toPass();
-      expect(match("abc").not.toEqual("abc")).toFail();
-    });
-
-    it("should provide an inverted default message", function() {
-      match(37).not.toBeGreaterThan(42);
-      expect(lastResult().message).toEqual("Passed.");
-
-      match(42).not.toBeGreaterThan(37);
-      expect(lastResult().message).toEqual("Expected 42 not to be greater than 37.");
-    });
-
-    it("should use the second message when the matcher sets an array of custom messages", function() {
-      spec.addMatchers({
-        custom: function() {
-          this.message = function() {
-            return ['Expected it was called.', 'Expected it wasn\'t called.'];
-          };
-          return this.actual;
-        }
-      });
-
-      match(true).custom();
-      expect(lastResult().message).toEqual("Passed.");
-      match(false).custom();
-      expect(lastResult().message).toEqual("Expected it was called.");
-      match(true).not.custom();
-      expect(lastResult().message).toEqual("Expected it wasn't called.");
-      match(false).not.custom();
-      expect(lastResult().message).toEqual("Passed.");
-    });
-  });
-
-  describe("spy matchers >>", function() {
-    var TestClass;
-    beforeEach(function() {
-      TestClass = {
-        normalFunction: function() {
-        },
-        spyFunction: jasmine.createSpy("My spy")
-      };
-    });
-
-    function shouldThrowAnExceptionWhenInvokedOnANonSpy(methodName) {
-      return function() {
-        expect(
-          function() {
-            match(TestClass.normalFunction)[methodName]();
-          }).toThrow('Expected a spy, but got Function.');
-
-        expect(
-          function() {
-            match(jasmine.undefined)[methodName]();
-          }).toThrow('Expected a spy, but got undefined.');
-
-        expect(
-          function() {
-            match({some:'object'})[methodName]();
-          }).toThrow('Expected a spy, but got { some : \'object\' }.');
-
-        expect(
-          function() {
-            match("<b>")[methodName]();
-          }).toThrow('Expected a spy, but got \'<b>\'.');
-      };
-    }
-
-    describe("toHaveBeenCalled", function() {
-      it("should pass if the spy was called", function() {
-        expect(match(TestClass.spyFunction).toHaveBeenCalled()).toFail();
-
-        TestClass.spyFunction();
-        expect(match(TestClass.spyFunction).toHaveBeenCalled()).toPass();
-      });
-
-      it("should throw an exception when invoked with any arguments", function() {
-        expect(
-          function() {
-            match(TestClass.normalFunction).toHaveBeenCalled("unwanted argument");
-          }).toThrow('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
-      });
-
-      it('should throw an exception when invoked on a non-spy', shouldThrowAnExceptionWhenInvokedOnANonSpy('toHaveBeenCalled'));
-    });
-
-    describe("wasCalled", function() {
-      it("should alias toHaveBeenCalled", function() {
-        spyOn(TestClass, 'normalFunction');
-
-        TestClass.normalFunction();
-
-        expect(TestClass.normalFunction).wasCalled();
-      });
-    });
-
-
-    describe("wasNotCalled", function() {
-      it("should pass iff the spy was not called", function() {
-        expect(match(TestClass.spyFunction).wasNotCalled()).toPass();
-
-        TestClass.spyFunction();
-        expect(match(TestClass.spyFunction).wasNotCalled()).toFail();
-      });
-
-      it("should throw an exception when invoked with any arguments", function() {
-        expect(
-          function() {
-            match(TestClass.normalFunction).wasNotCalled("unwanted argument");
-          }).toThrow('wasNotCalled does not take arguments');
-      });
-
-      it('should throw an exception when invoked on a non-spy', shouldThrowAnExceptionWhenInvokedOnANonSpy('wasNotCalled'));
-    });
-
-    describe("toHaveBeenCalledWith", function() {
-      it('toHaveBeenCalledWith should return true if it was called with the expected args', function() {
-        TestClass.spyFunction('a', 'b', 'c');
-        expect(match(TestClass.spyFunction).toHaveBeenCalledWith('a', 'b', 'c')).toPass();
-      });
-
-      it('should return false if it was not called with the expected args', function() {
-        TestClass.spyFunction('a', 'b', 'c');
-        var expected = match(TestClass.spyFunction);
-        expect(expected.toHaveBeenCalledWith('c', 'b', 'a')).toFail();
-        var result = lastResult();
-        expect(result.passed()).toFail();
-        expect(result.expected).toEqual(['c', 'b', 'a']);
-        expect(result.actual.mostRecentCall.args).toEqual(['a', 'b', 'c']);
-        expect(result.message).toContain(jasmine.pp(result.expected));
-        expect(result.message).toContain(jasmine.pp(result.actual.mostRecentCall.args));
-      });
-
-      it('should return false if it was not called', function() {
-        var expected = match(TestClass.spyFunction);
-        expect(expected.toHaveBeenCalledWith('c', 'b', 'a')).toFail();
-        var result = lastResult();
-        expect(result.passed()).toFail();
-        expect(result.expected).toEqual(['c', 'b', 'a']);
-        expect(result.actual.argsForCall).toEqual([]);
-        expect(result.message).toContain(jasmine.pp(result.expected));
-      });
-
-      it('should allow matches across multiple calls', function() {
-        TestClass.spyFunction('a', 'b', 'c');
-        TestClass.spyFunction('d', 'e', 'f');
-        var expected = match(TestClass.spyFunction);
-        expect(expected.toHaveBeenCalledWith('a', 'b', 'c')).toPass();
-        expect(expected.toHaveBeenCalledWith('d', 'e', 'f')).toPass();
-        expect(expected.toHaveBeenCalledWith('x', 'y', 'z')).toFail();
-      });
-
-      it("should return a decent message", function() {
-        TestClass.spyFunction('a', 'b', 'c');
-        TestClass.spyFunction('d', 'e', 'f');
-        var expected = match(TestClass.spyFunction);
-        expect(expected.toHaveBeenCalledWith('a', 'b')).toFail();
-        expect(lastResult().message).toEqual("Expected spy My spy to have been called with [ 'a', 'b' ] but actual calls were [ 'a', 'b', 'c' ], [ 'd', 'e', 'f' ]");
-      });
-
-      it("should return a decent message when it hasn't been called", function() {
-        var expected = match(TestClass.spyFunction);
-        expect(expected.toHaveBeenCalledWith('a', 'b')).toFail();
-        expect(lastResult().message).toEqual("Expected spy My spy to have been called with [ 'a', 'b' ] but it was never called.");
-      });
-
-      it("should return a decent message when inverted", function() {
-        TestClass.spyFunction('a', 'b', 'c');
-        TestClass.spyFunction('d', 'e', 'f');
-        var expected = match(TestClass.spyFunction);
-        expect(expected.not.toHaveBeenCalledWith('a', 'b', 'c')).toFail();
-        expect(lastResult().message).toEqual("Expected spy My spy not to have been called with [ 'a', 'b', 'c' ] but it was.");
-      });
-
-      it('should throw an exception when invoked on a non-spy', shouldThrowAnExceptionWhenInvokedOnANonSpy('toHaveBeenCalledWith'));
-
-      describe("to build an ExpectationResult", function () {
-        beforeEach(function() {
-          var currentSuite;
-          var spec;
-          currentSuite = env.describe('default current suite', function() {
-            spec = env.it();
-          }, spec);
-          TestClass = { someFunction: function(a, b) {
-          } };
-          spec.spyOn(TestClass, 'someFunction');
-        });
-
-        it("should should handle the case of a spy", function() {
-          TestClass.someFunction('a', 'c');
-          var matcher = match(TestClass.someFunction);
-          matcher.toHaveBeenCalledWith('a', 'b');
-
-          var result = lastResult();
-          expect(result.matcherName).toEqual("toHaveBeenCalledWith");
-          expect(result.passed()).toFail();
-          expect(result.message).toContain(jasmine.pp(['a', 'b']));
-          expect(result.message).toContain(jasmine.pp(['a', 'c']));
-          expect(result.actual).toEqual(TestClass.someFunction);
-          expect(result.expected).toEqual(['a','b']);
-        });
-      });
-    });
-
-    describe("wasCalledWith", function() {
-      it("should alias toHaveBeenCalledWith", function() {
-        spyOn(TestClass, 'normalFunction');
-
-        TestClass.normalFunction(123);
-
-        expect(TestClass.normalFunction).wasCalledWith(123);
-      });
-    });
-
-    describe("wasNotCalledWith", function() {
-      it('should return true if the spy was NOT called with the expected args', function() {
-        TestClass.spyFunction('a', 'b', 'c');
-        expect(match(TestClass.spyFunction).wasNotCalledWith('c', 'b', 'a')).toPass();
-      });
-
-      it('should return false if it WAS called with the expected args', function() {
-        TestClass.spyFunction('a', 'b', 'c');
-        var expected = match(TestClass.spyFunction);
-        expect(expected.wasNotCalledWith('a', 'b', 'c')).toFail();
-        var result = lastResult();
-        expect(result.passed()).toFail();
-        expect(result.expected).toEqual(['a', 'b', 'c']);
-        expect(result.actual.mostRecentCall.args).toEqual(['a', 'b', 'c']);
-        expect(result.message).toContain(jasmine.pp(result.expected));
-      });
-
-      it('should return true if it was not called', function() {
-        var expected = match(TestClass.spyFunction);
-        expect(expected.wasNotCalledWith('c', 'b', 'a')).toPass();
-      });
-
-      it('should allow matches across multiple calls', function() {
-        var expected = match(TestClass.spyFunction);
-        TestClass.spyFunction('a', 'b', 'c');
-        TestClass.spyFunction('d', 'e', 'f');
-        expect(expected.wasNotCalledWith('a', 'b', 'c')).toFail();
-        expect(expected.wasNotCalledWith('d', 'e', 'f')).toFail();
-        expect(expected.wasNotCalledWith('x', 'y', 'z')).toPass();
-      });
-
-      it('should throw an exception when invoked on a non-spy', shouldThrowAnExceptionWhenInvokedOnANonSpy('wasNotCalledWith'));
-    });
-  });
-
-  describe("ObjectContaining", function () {
-    describe("with an empty object", function () {
-      var containing;
-      beforeEach(function () {
-        containing = new jasmine.Matchers.ObjectContaining({});
-      });
-      it("matches everything", function () {
-         expect(containing.jasmineMatches("foo", [], [])).toBe(true);
-      });
-
-      it("says it didn't expect to contain anything", function () {
-        expect(containing.jasmineToString()).toEqual("<jasmine.objectContaining({  })>");
-      });
-    });
-
-    describe("with an object with items in it", function () {
-      var containing, mismatchKeys, mismatchValues;
-      beforeEach(function () {
-        mismatchKeys = [];
-        mismatchValues = [];
-        containing = new jasmine.Matchers.ObjectContaining({foo: "fooVal", bar: "barVal"});
-      });
-
-      it("doesn't match an empty object", function () {
-        expect(containing.jasmineMatches({}, mismatchKeys, mismatchValues)).toBe(false);
-      });
-
-      it("doesn't match an object with none of the specified options", function () {
-        expect(containing.jasmineMatches({baz:"stuff"}, mismatchKeys, mismatchValues)).toBe(false);
-      });
-
-      it("adds a message for each missing key", function () {
-        containing.jasmineMatches({foo: "fooVal"}, mismatchKeys, mismatchValues);
-        expect(mismatchKeys.length).toEqual(1);
-      });
-
-      it("doesn't match an object when the values are different", function () {
-        expect(containing.jasmineMatches({foo:"notFoo", bar:"notBar"}, mismatchKeys, mismatchValues)).toBe(false);
-      });
-
-      it("adds a message when values don't match", function () {
-        containing.jasmineMatches({foo: "fooVal", bar: "notBar"}, mismatchKeys, mismatchValues);
-        expect(mismatchValues.length).toEqual(1);
-      });
-
-      it("doesn't match an object with only one of the values matching", function () {
-        expect(containing.jasmineMatches({foo:"notFoo", bar:"barVal"}, mismatchKeys, mismatchValues)).toBe(false);
-      });
-
-      it("matches when all the values are the same", function () {
-        expect(containing.jasmineMatches({foo: "fooVal", bar: "barVal"}, mismatchKeys, mismatchValues)).toBe(true);
-      });
-
-      it("matches when there are additional values", function () {
-        expect(containing.jasmineMatches({foo: "fooVal", bar: "barVal", baz: "bazVal"}, mismatchKeys, mismatchValues)).toBe(true);
-      });
-
-      it("doesn't modify missingKeys or missingValues when match is successful", function () {
-        containing.jasmineMatches({foo: "fooVal", bar: "barVal"}, mismatchKeys, mismatchValues);
-        expect(mismatchKeys.length).toEqual(0);
-        expect(mismatchValues.length).toEqual(0);
-      });
-
-      it("says what it expects to contain", function () {
-        expect(containing.jasmineToString()).toEqual("<jasmine.objectContaining(" + jasmine.pp({foo:"fooVal", bar:"barVal"}) + ")>");
-      });
-    });
-
-    describe("in real life", function () {
-      var method;
-      beforeEach(function () {
-        method = jasmine.createSpy("method");
-        method({a:"b", c:"d"});
-      });
-      it("works correctly for positive matches", function () {
-        expect(method).toHaveBeenCalledWith(jasmine.objectContaining({a:"b"}));
-      });
-
-      it("works correctly for negative matches", function () {
-        expect(method).not.toHaveBeenCalledWith(jasmine.objectContaining({z:"x"}));
-      });
-    });
-  });
-
-  describe("Matchers.Any", function () {
-    var any;
-    describe(".jasmineToString", function () {
-      describe("with Object", function () {
-        it("says it's looking for an object", function () {
-          any = jasmine.any(Object);
-          expect(any.jasmineToString().replace(/\n/g, "")).toMatch(/<jasmine\.any\(function Object.*\)>/);
-        });
-      });
-
-      describe("with Function", function () {
-        it("says it's looking for a function", function () {
-          any = jasmine.any(Function);
-          expect(any.jasmineToString().replace(/\n/g, "")).toMatch(/<jasmine\.any\(function Function.*\)>/);
-        });
-      });
-
-      describe("with String", function () {
-        it("says it's looking for a string", function () {
-          any = jasmine.any(String);
-          expect(any.jasmineToString().replace(/\n/g, "")).toMatch(/<jasmine\.any\(function String.*\)>/);
-        });
-      });
-
-      describe("with Number", function () {
-        it("says it's looking for a number", function () {
-          any = jasmine.any(Number);
-          expect(any.jasmineToString().replace(/\n/g, "")).toMatch(/<jasmine\.any\(function Number.*\)>/);
-        });
-      });
-
-      describe("with some other defined 'class'", function () {
-        it("says it's looking for an object", function () {
-          function MyClass () {}
-          any = jasmine.any(MyClass);
-          expect(any.jasmineToString().replace("\n", "")).toMatch(/<jasmine\.any\(function MyClass.*\)>/);
-        });
-      });
-    });
-
-    describe(".jasmineMatches", function () {
-      describe("with Object", function () {
-        beforeEach(function () {
-          any = jasmine.any(Object);
-        });
-
-        it("matches an empty object", function () {
-          expect(any.jasmineMatches({})).toEqual(true);
-        });
-
-        it("matches a newed up object", function () {
-          expect(any.jasmineMatches(new Object())).toEqual(true);
-        });
-
-        it("doesn't match a string", function () {
-          expect(any.jasmineMatches("")).toEqual(false);
-        });
-
-        it("doesn't match a number", function () {
-          expect(any.jasmineMatches(123)).toEqual(false);
-        });
-
-        it("doesn't match a function", function () {
-          expect(any.jasmineMatches(function () {})).toEqual(false);
-        });
-      });
-
-      describe("with Function", function () {
-        beforeEach(function () {
-          any = jasmine.any(Function);
-        });
-
-        it("doesn't match an object", function () {
-          expect(any.jasmineMatches({})).toEqual(false);
-        });
-
-        it("doesn't match a string", function () {
-          expect(any.jasmineMatches("")).toEqual(false);
-        });
-
-        it("doesn't match a number", function () {
-          expect(any.jasmineMatches(123)).toEqual(false);
-        });
-
-        it("matches a function", function () {
-          expect(any.jasmineMatches(function () {})).toEqual(true);
-        });
-      });
-
-      describe("with Number", function () {
-        beforeEach(function () {
-          any = jasmine.any(Number);
-        });
-
-        it("doesn't match an object", function () {
-          expect(any.jasmineMatches({})).toEqual(false);
-        });
-
-        it("doesn't match a string", function () {
-          expect(any.jasmineMatches("")).toEqual(false);
-        });
-
-        it("matches a number", function () {
-          expect(any.jasmineMatches(123)).toEqual(true);
-        });
-
-        it("doesn't match a function", function () {
-          expect(any.jasmineMatches(function () {})).toEqual(false);
-        });
-      });
-
-      describe("with String", function () {
-        beforeEach(function () {
-          any = jasmine.any(String);
-        });
-
-        it("doesn't match an object", function () {
-          expect(any.jasmineMatches({})).toEqual(false);
-        });
-
-        it("matches a string", function () {
-          expect(any.jasmineMatches("")).toEqual(true);
-        });
-
-        it("doesn't match a number", function () {
-          expect(any.jasmineMatches(123)).toEqual(false);
-        });
-
-        it("doesn't match a function", function () {
-          expect(any.jasmineMatches(function () {})).toEqual(false);
-        });
-      });
-
-      describe("with some defined 'class'", function () {
-        function MyClass () {}
-        beforeEach(function () {
-          any = jasmine.any(MyClass);
-        });
-
-        it("doesn't match an object", function () {
-          expect(any.jasmineMatches({})).toEqual(false);
-        });
-
-        it("doesn't match a string", function () {
-          expect(any.jasmineMatches("")).toEqual(false);
-        });
-
-        it("doesn't match a number", function () {
-          expect(any.jasmineMatches(123)).toEqual(false);
-        });
-
-        it("doesn't match a function", function () {
-          expect(any.jasmineMatches(function () {})).toEqual(false);
-        });
-
-        it("matches an instance of the defined class", function () {
-          expect(any.jasmineMatches(new MyClass())).toEqual(true);
-        });
-      });
-    });
-  });
-
-  describe("all matchers", function() {
-    it("should return null, for future-proofing, since we might eventually allow matcher chaining", function() {
-      expect(match(true).toBe(true)).toBeUndefined();
-    });
-  });
-});