jasmine-core 2.8.0 → 2.9.0

data/lib/jasmine-core/spec/core/asymmetric_equality/AnythingSpec.js

@@ -23,6 +23,38 @@ describe("Anything", function() {
     expect(anything.asymmetricMatch([1,2,3])).toBe(true);
   });
 
+  it("matches a Map", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var anything = new jasmineUnderTest.Anything();
+
+    expect(anything.asymmetricMatch(new Map())).toBe(true);
+  });
+
+  it("matches a Set", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    var anything = new jasmineUnderTest.Anything();
+
+    expect(anything.asymmetricMatch(new Set())).toBe(true);
+  });
+
+  it("matches a TypedArray", function() {
+    jasmine.getEnv().requireFunctioningTypedArrays();
+
+    var anything = new jasmineUnderTest.Anything();
+
+    expect(anything.asymmetricMatch(new Uint32Array([]))).toBe(true);
+  });
+
+  it("matches a Symbol", function() {
+    jasmine.getEnv().requireFunctioningSymbols();
+
+    var anything = new jasmineUnderTest.Anything();
+
+    expect(anything.asymmetricMatch(Symbol())).toBe(true);
+  });
+
   it("doesn't match undefined", function() {
     var anything = new jasmineUnderTest.Anything();
 

data/lib/jasmine-core/spec/core/integration/EnvSpec.js

@@ -1485,6 +1485,7 @@ describe("Env integration", function() {
     reporter.jasmineDone.and.callFake(function() {
       var specStatus = reporter.specDone.calls.argsFor(0)[0];
 
+      expect(specStatus.status).toBe('pending');
       expect(specStatus.pendingReason).toBe('with a message');
 
       done();
@@ -1499,6 +1500,45 @@ describe("Env integration", function() {
     env.execute();
   });
 
+  it('should report pending spec messages from promise-returning functions', function(done) {
+    function StubPromise(fn) {
+      try {
+        fn();
+      } catch (e) {
+        this.exception = e;
+      }
+    }
+
+    StubPromise.prototype.then = function(resolve, reject) {
+      reject(this.exception);
+    };
+
+    var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          'specDone',
+          'jasmineDone'
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      var specStatus = reporter.specDone.calls.argsFor(0)[0];
+
+      expect(specStatus.status).toBe('pending');
+      expect(specStatus.pendingReason).toBe('with a message');
+
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.it('will be pending', function() {
+      return new StubPromise(function() {
+        env.pending('with a message');
+      });
+    });
+
+    env.execute();
+  });
+
   it('should report using fallback reporter', function(done) {
     var env = new jasmineUnderTest.Env(),
         reporter = jasmine.createSpyObj('fakeReporter', [
@@ -1903,4 +1943,65 @@ describe("Env integration", function() {
 
     env.execute();
   });
+
+  it('should throw on suites/specs/befores/afters nested in methods other than \'describe\'', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+    reporter.jasmineDone.and.callFake(function() {
+      var msg = /\'.*\' should only be used in \'describe\' function/;
+
+      expect(reporter.specDone).toHaveFailedExpecationsForRunnable('suite describe', [msg]);
+      expect(reporter.specDone).toHaveFailedExpecationsForRunnable('suite xdescribe', [msg]);
+      expect(reporter.specDone).toHaveFailedExpecationsForRunnable('suite fdescribe', [msg]);
+
+      expect(reporter.specDone).toHaveFailedExpecationsForRunnable('spec it', [msg]);
+      expect(reporter.specDone).toHaveFailedExpecationsForRunnable('spec xit', [msg]);
+      expect(reporter.specDone).toHaveFailedExpecationsForRunnable('spec fit', [msg]);
+
+      expect(reporter.specDone).toHaveFailedExpecationsForRunnable('beforeAll spec', [msg]);
+      expect(reporter.specDone).toHaveFailedExpecationsForRunnable('beforeEach spec', [msg]);
+
+      expect(reporter.suiteDone).toHaveFailedExpecationsForRunnable('afterAll', [msg]);
+      expect(reporter.specDone).toHaveFailedExpecationsForRunnable('afterEach spec', [msg]);
+
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.describe('suite', function() {
+      env.it('describe', function() { env.describe('inner suite', function() {}); });
+      env.it('xdescribe', function() { env.xdescribe('inner suite', function() {}); });
+      env.it('fdescribe', function() { env.fdescribe('inner suite', function() {}); });
+    });
+
+    env.describe('spec', function() {
+      env.it('it', function() { env.it('inner spec', function() {}); });
+      env.it('xit', function() { env.xit('inner spec', function() {}); });
+      env.it('fit', function() { env.fit('inner spec', function() {}); });
+    });
+
+    env.describe('beforeAll', function() {
+      env.beforeAll(function() { env.beforeAll(function() {}); });
+      env.it('spec', function() {});
+    });
+
+    env.describe('beforeEach', function() {
+      env.beforeEach(function() { env.beforeEach(function() {}); });
+      env.it('spec', function() {});
+    });
+
+    env.describe('afterAll', function() {
+      env.afterAll(function() { env.afterAll(function() {}); });
+      env.it('spec', function() {});
+    });
+
+    env.describe('afterEach', function() {
+      env.afterEach(function() { env.afterEach(function() {}); });
+      env.it('spec', function() {});
+    });
+
+    env.execute();
+  });
 });

data/lib/jasmine-core/spec/core/matchers/matchersUtilSpec.js

@@ -71,7 +71,7 @@ describe("matchersUtil", function() {
 
     it("fails for Arrays whose contents are equivalent, but have differing properties", function() {
       var one = [1,2,3],
-          two = [1,2,3];
+        two = [1,2,3];
 
       one.foo = 'bar';
       two.foo = 'baz';
@@ -81,7 +81,7 @@ describe("matchersUtil", function() {
 
     it("passes for Arrays with equivalent contents and properties", function() {
       var one = [1,2,3],
-          two = [1,2,3];
+        two = [1,2,3];
 
       one.foo = 'bar';
       two.foo = 'bar';
@@ -122,7 +122,7 @@ describe("matchersUtil", function() {
 
     it("passes for Objects that are equivalent (with cycles)", function() {
       var actual = { a: "foo" },
-        expected = { a: "foo" };
+      expected = { a: "foo" };
 
       actual.b = actual;
       expected.b = actual;
@@ -166,6 +166,16 @@ describe("matchersUtil", function() {
 
       expect(jasmineUnderTest.matchersUtil.equals(a,b)).toBe(true);
     });
+    
+    it("passes for equivalent Promises (GitHub issue #1314)", function() {
+      if (typeof Promise === 'undefined') { return; }
+
+      var p1 = new Promise(function () {}),
+        p2 = new Promise(function () {});
+
+      expect(jasmineUnderTest.matchersUtil.equals(p1, p1)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(p1, p2)).toBe(false);
+    });
 
     describe("when running in a browser", function() {
       function isNotRunningInBrowser() {
@@ -332,7 +342,7 @@ describe("matchersUtil", function() {
 
     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; };
+        symmetricTester = function(a, b) { return false; };
 
       expect(jasmineUnderTest.matchersUtil.equals(asymmetricTester, true, [symmetricTester])).toBe(true);
       expect(jasmineUnderTest.matchersUtil.equals(true, asymmetricTester, [symmetricTester])).toBe(true);
@@ -350,7 +360,7 @@ describe("matchersUtil", function() {
 
     it("passes when an Any is compared to an Any that checks for the same type", function() {
       var any1 = new jasmineUnderTest.Any(Function),
-          any2 = new jasmineUnderTest.Any(Function);
+        any2 = new jasmineUnderTest.Any(Function);
 
       expect(jasmineUnderTest.matchersUtil.equals(any1, any2)).toBe(true);
     });
@@ -359,7 +369,7 @@ describe("matchersUtil", function() {
       if (jasmine.getEnv().ieVersion < 9) { return; }
 
       var objA = Object.create(null),
-          objB = Object.create(null);
+        objB = Object.create(null);
 
       objA.name = 'test';
       objB.name = 'test';
@@ -371,7 +381,7 @@ describe("matchersUtil", function() {
       if (jasmine.getEnv().ieVersion < 9) { return; }
 
       var objA = Object.create(null),
-          objB = Object.create(null);
+        objB = Object.create(null);
 
       objA.name = 'test';
       objB.test = 'name';
@@ -386,31 +396,94 @@ describe("matchersUtil", function() {
 
     it("passes when comparing identical sets", function() {
       jasmine.getEnv().requireFunctioningSets();
-      var setA = new Set([6, 5]);
+
+      var setA = new Set();
+      setA.add(6);
+      setA.add(5);
       var setB = new Set();
       setB.add(6);
       setB.add(5);
+
+      expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(true);
+    });
+
+    it("passes when comparing identical sets with different insertion order and simple elements", function() {
+      jasmine.getEnv().requireFunctioningSets();
+
+      var setA = new Set();
+      setA.add(3);
+      setA.add(6);
+      var setB = new Set();
+      setB.add(6);
+      setB.add(3);
+
       expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(true);
     });
 
-    it("passes when comparing identical sets with different insertion order", function() {
+    it("passes when comparing identical sets with different insertion order and complex elements 1", function() {
       jasmine.getEnv().requireFunctioningSets();
-      var setA = new Set([3, 6]);
-      var setB = new Set([6, 3]);
+
+      var setA1 = new Set();
+      setA1.add(['a',3]);
+      setA1.add([6,1]);
+      var setA2 = new Set();
+      setA1.add(['y',3]);
+      setA1.add([6,1]);
+      var setA = new Set();
+      setA.add(setA1);
+      setA.add(setA2);
+
+
+      var setB1 = new Set();
+      setB1.add([6,1]);
+      setB1.add(['a',3]);
+      var setB2 = new Set();
+      setB1.add([6,1]);
+      setB1.add(['y',3]);
+      var setB = new Set();
+      setB.add(setB1);
+      setB.add(setB2);
+
+      expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(true);
+    });
+
+    it("passes when comparing identical sets with different insertion order and complex elements 2", function() {
+      jasmine.getEnv().requireFunctioningSets();
+
+      var setA = new Set();
+      setA.add([[1,2], [3,4]]);
+      setA.add([[5,6], [7,8]]);
+      var setB = new Set();
+      setB.add([[5,6], [7,8]]);
+      setB.add([[1,2], [3,4]]);
+
       expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(true);
     });
 
     it("fails for sets with different elements", function() {
       jasmine.getEnv().requireFunctioningSets();
-      var setA = new Set([6, 3, 5]);
-      var setB = new Set([6, 4, 5]);
+      var setA = new Set();
+      setA.add(6);
+      setA.add(3);
+      setA.add(5);
+      var setB = new Set();
+      setB.add(6);
+      setB.add(4);
+      setB.add(5);
+
       expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(false);
     });
 
     it("fails for sets of different size", function() {
       jasmine.getEnv().requireFunctioningSets();
-      var setA = new Set([6, 3]);
-      var setB = new Set([6, 4, 5]);
+      var setA = new Set();
+      setA.add(6);
+      setA.add(3);
+      var setB = new Set();
+      setB.add(6);
+      setB.add(4);
+      setB.add(5);
+
       expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(false);
     });
 
@@ -421,7 +494,8 @@ describe("matchersUtil", function() {
 
     it("passes when comparing identical maps", function() {
       jasmine.getEnv().requireFunctioningMaps();
-      var mapA = new Map([[6, 5]]);
+      var mapA = new Map();
+      mapA.set(6, 5);
       var mapB = new Map();
       mapB.set(6, 5);
       expect(jasmineUnderTest.matchersUtil.equals(mapA, mapB)).toBe(true);
@@ -429,22 +503,34 @@ describe("matchersUtil", function() {
 
     it("passes when comparing identical maps with different insertion order", function() {
       jasmine.getEnv().requireFunctioningMaps();
-      var mapA = new Map([['a', 3], [6, 1]]);
-      var mapB = new Map([[6, 1], ['a', 3]]);
+      var mapA = new Map();
+      mapA.set("a", 3);
+      mapA.set(6, 1);
+      var mapB = new Map();
+      mapB.set(6, 1);
+      mapB.set("a", 3);
       expect(jasmineUnderTest.matchersUtil.equals(mapA, mapB)).toBe(true);
     });
 
     it("fails for maps with different elements", function() {
       jasmine.getEnv().requireFunctioningMaps();
-      var mapA = new Map([[6, 3], [5, 1]]);
-      var mapB = new Map([[6, 4], [5, 1]]);
+      var mapA = new Map();
+      mapA.set(6, 3);
+      mapA.set(5, 1);
+      var mapB = new Map();
+      mapB.set(6, 4);
+      mapB.set(5, 1);
+
       expect(jasmineUnderTest.matchersUtil.equals(mapA, mapB)).toBe(false);
     });
 
     it("fails for maps of different size", function() {
       jasmine.getEnv().requireFunctioningMaps();
-      var mapA = new Map([[6, 3]]);
-      var mapB = new Map([[6, 4], [5, 1]]);
+      var mapA = new Map();
+      mapA.set(6, 3);
+      var mapB = new Map();
+      mapB.set(6, 4);
+      mapB.set(5, 1);
       expect(jasmineUnderTest.matchersUtil.equals(mapA, mapB)).toBe(false);
     });
 
@@ -461,28 +547,28 @@ describe("matchersUtil", function() {
         Object.defineProperty(Array.prototype, 'findIndex', {
           enumerable: true,
           value: function (predicate) {
-	            if (this === null) {
-	                throw new TypeError('Array.prototype.findIndex called on null or undefined');
-	            }
-
-	            if (typeof predicate !== 'function') {
-	                throw new TypeError('predicate must be a function');
-	            }
-
-	            var list = Object(this);
-	            var length = list.length >>> 0;
-	            var thisArg = arguments[1];
-	            var value;
-
-	            for (var i = 0; i < length; i++) {
-	                value = list[i];
-	                if (predicate.call(thisArg, value, i, list)) {
-	                    return i;
-	                }
-	            }
-
-	            return -1;
-	        }
+            if (this === null) {
+              throw new TypeError('Array.prototype.findIndex called on null or undefined');
+            }
+
+            if (typeof predicate !== 'function') {
+              throw new TypeError('predicate must be a function');
+            }
+
+            var list = Object(this);
+            var length = list.length >>> 0;
+            var thisArg = arguments[1];
+            var value;
+
+            for (var i = 0; i < length; i++) {
+              value = list[i];
+              if (predicate.call(thisArg, value, i, list)) {
+                return i;
+              }
+            }
+
+            return -1;
+          }
         });
       });
 

data/lib/jasmine-core/spec/core/matchers/toEqualSpec.js

@@ -374,9 +374,11 @@ describe("toEqual", function() {
   it("reports mismatches between Sets", function() {
     jasmine.getEnv().requireFunctioningSets();
 
-    var actual = new Set([1]),
-      expected = new Set([2]),
-      message = 'Expected Set( 1 ) to equal Set( 2 ).';
+    var actual = new Set();
+    actual.add(1);
+    var expected = new Set();
+    expected.add(2);
+    var message = 'Expected Set( 1 ) to equal Set( 2 ).';
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
@@ -384,9 +386,11 @@ describe("toEqual", function() {
   it("reports deep mismatches within Sets", function() {
     jasmine.getEnv().requireFunctioningSets();
 
-    var actual = new Set([{x: 1}]),
-      expected = new Set([{x: 2}]),
-       message = 'Expected Set( Object({ x: 1 }) ) to equal Set( Object({ x: 2 }) ).';
+    var actual = new Set();
+    actual.add({x: 1});
+    var expected = new Set();
+    expected.add({x: 2});
+    var message = 'Expected Set( Object({ x: 1 }) ) to equal Set( Object({ x: 2 }) ).';
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
@@ -394,9 +398,14 @@ describe("toEqual", function() {
   it("reports mismatches between Sets nested in objects", function() {
     jasmine.getEnv().requireFunctioningSets();
 
-    var actual = {sets: [new Set([1])]},
-      expected = {sets: [new Set([2])]},
-      message = "Expected $.sets[0] = Set( 1 ) to equal Set( 2 ).";
+    var actualSet = new Set();
+    actualSet.add(1);
+    var expectedSet = new Set();
+    expectedSet.add(2);
+
+    var actual = { sets: [actualSet] };
+    var expected = { sets: [expectedSet] };
+    var message = "Expected $.sets[0] = Set( 1 ) to equal Set( 2 ).";
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
@@ -404,9 +413,12 @@ describe("toEqual", function() {
   it("reports mismatches between Sets of different lengths", function() {
     jasmine.getEnv().requireFunctioningSets();
 
-    var actual = new Set([1, 2]),
-      expected = new Set([2]),
-      message = 'Expected Set( 1, 2 ) to equal Set( 2 ).';
+    var actual = new Set();
+    actual.add(1);
+    actual.add(2);
+    var expected = new Set();
+    expected.add(2);
+    var message = 'Expected Set( 1, 2 ) to equal Set( 2 ).';
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
@@ -415,9 +427,13 @@ describe("toEqual", function() {
     jasmine.getEnv().requireFunctioningSets();
 
     // Use 'duplicate' object in actual so sizes match
-    var actual = new Set([{x: 1}, {x: 1}]),
-      expected = new Set([{x: 1}, {x: 2}]),
-      message = 'Expected Set( Object({ x: 1 }), Object({ x: 1 }) ) to equal Set( Object({ x: 1 }), Object({ x: 2 }) ).';
+    var actual = new Set();
+    actual.add({x: 1});
+    actual.add({x: 1});
+    var expected = new Set();
+    expected.add({x: 1});
+    expected.add({x: 2});
+    var message = 'Expected Set( Object({ x: 1 }), Object({ x: 1 }) ) to equal Set( Object({ x: 1 }), Object({ x: 2 }) ).';
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
@@ -426,9 +442,13 @@ describe("toEqual", function() {
     jasmine.getEnv().requireFunctioningSets();
 
     // Use 'duplicate' object in expected so sizes match
-    var actual = new Set([{x: 1}, {x: 2}]),
-      expected = new Set([{x: 1}, {x: 1}]),
-      message = 'Expected Set( Object({ x: 1 }), Object({ x: 2 }) ) to equal Set( Object({ x: 1 }), Object({ x: 1 }) ).';
+    var actual = new Set();
+    actual.add({x: 1});
+    actual.add({x: 2});
+    var expected = new Set();
+    expected.add({x: 1});
+    expected.add({x: 1});
+    var message = 'Expected Set( Object({ x: 1 }), Object({ x: 2 }) ) to equal Set( Object({ x: 1 }), Object({ x: 1 }) ).';
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
@@ -436,11 +456,13 @@ describe("toEqual", function() {
   // == Maps ==
 
   it("does not report mismatches between deep equal Maps", function() {
-    jasmine.getEnv().requireFunctioningSets();
+    jasmine.getEnv().requireFunctioningMaps();
 
     // values are the same but with different object identity
-    var actual = new Map([['a', {x: 1}]]),
-      expected = new Map([['a', {x: 1}]]);
+    var actual = new Map();
+    actual.set('a',{x:1});
+    var expected = new Map();
+    expected.set('a',{x:1});
 
     expect(compareEquals(actual, expected).pass).toBe(true);
   });
@@ -448,9 +470,11 @@ describe("toEqual", function() {
   it("reports deep mismatches within Maps", function() {
     jasmine.getEnv().requireFunctioningMaps();
 
-    var actual = new Map([['a', {x: 1}]]),
-      expected = new Map([['a', {x: 2}]]),
-      message = "Expected Map( [ 'a', Object({ x: 1 }) ] ) to equal Map( [ 'a', Object({ x: 2 }) ] ).";
+    var actual = new Map();
+    actual.set('a',{x:1});
+    var expected = new Map();
+    expected.set('a',{x:2});
+    var message = "Expected Map( [ 'a', Object({ x: 1 }) ] ) to equal Map( [ 'a', Object({ x: 2 }) ] ).";
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
@@ -458,9 +482,12 @@ describe("toEqual", function() {
   it("reports mismatches between Maps nested in objects", function() {
     jasmine.getEnv().requireFunctioningMaps();
 
-    var actual = {Maps: [new Map([['a', 1]])]},
-      expected = {Maps: [new Map([['a', 2]])]},
-      message = "Expected $.Maps[0] = Map( [ 'a', 1 ] ) to equal Map( [ 'a', 2 ] ).";
+    var actual = {Maps:[new Map()]};
+    actual.Maps[0].set('a',1);
+    var expected = {Maps:[new Map()]};
+    expected.Maps[0].set('a',2);
+
+    var message = "Expected $.Maps[0] = Map( [ 'a', 1 ] ) to equal Map( [ 'a', 2 ] ).";
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
@@ -468,9 +495,12 @@ describe("toEqual", function() {
   it("reports mismatches between Maps of different lengths", function() {
     jasmine.getEnv().requireFunctioningMaps();
 
-    var actual = new Map([['a', 1]]),
-      expected = new Map([['a', 2], ['b', 1]]),
-       message = "Expected Map( [ 'a', 1 ] ) to equal Map( [ 'a', 2 ], [ 'b', 1 ] ).";
+    var actual = new Map();
+    actual.set('a',1);
+    var expected = new Map();
+    expected.set('a',2);
+    expected.set('b',1);
+    var message = "Expected Map( [ 'a', 1 ] ) to equal Map( [ 'a', 2 ], [ 'b', 1 ] ).";
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
@@ -478,18 +508,22 @@ describe("toEqual", function() {
   it("reports mismatches between Maps with equal values but differing keys", function() {
     jasmine.getEnv().requireFunctioningMaps();
 
-    var actual = new Map([['a', 1]]),
-      expected = new Map([['b', 1]]),
-       message = "Expected Map( [ 'a', 1 ] ) to equal Map( [ 'b', 1 ] ).";
+    var actual = new Map();
+    actual.set('a',1);
+    var expected = new Map();
+    expected.set('b',1);
+    var message = "Expected Map( [ 'a', 1 ] ) to equal Map( [ 'b', 1 ] ).";
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
 
   it("does not report mismatches between Maps with keys with same object identity", function() {
     jasmine.getEnv().requireFunctioningMaps();
-    var  key = {x: 1},
-      actual = new Map([[key, 2]]),
-    expected = new Map([[key, 2]]);
+    var  key = {x: 1};
+    var actual = new Map();
+    actual.set(key,2);
+    var expected = new Map();
+    expected.set(key,2);
 
     expect(compareEquals(actual, expected).pass).toBe(true);
   });
@@ -497,13 +531,64 @@ describe("toEqual", function() {
   it("reports mismatches between Maps with identical keys with different object identity", function() {
     jasmine.getEnv().requireFunctioningMaps();
 
-    var actual = new Map([[{x: 1}, 2]]),
-      expected = new Map([[{x: 1}, 2]]),
-       message = "Expected Map( [ Object({ x: 1 }), 2 ] ) to equal Map( [ Object({ x: 1 }), 2 ] ).";
+    var actual = new Map();
+    actual.set({x:1},2);
+    var expected = new Map();
+    expected.set({x:1},2);
+    var message = "Expected Map( [ Object({ x: 1 }), 2 ] ) to equal Map( [ Object({ x: 1 }), 2 ] ).";
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
 
+  it("does not report mismatches when comparing Map key to jasmine.anything()", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var actual = new Map();
+    actual.set('a',1);
+    var expected = new Map();
+    expected.set(jasmineUnderTest.anything(),1);
+
+    expect(compareEquals(actual, expected).pass).toBe(true);
+  });
+
+  it("does not report mismatches when comparing Maps with the same symbol keys", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+    jasmine.getEnv().requireFunctioningSymbols();
+
+    var key = Symbol();
+    var actual = new Map();
+    actual.set(key,1);
+    var expected = new Map();
+    expected.set(key,1);
+
+    expect(compareEquals(actual, expected).pass).toBe(true);
+  });
+
+  it("reports mismatches between Maps with different symbol keys", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+    jasmine.getEnv().requireFunctioningSymbols();
+
+    var actual = new Map();
+    actual.set(Symbol(),1);
+    var expected = new Map();
+    expected.set(Symbol(),1);
+    var message = "Expected Map( [ Symbol(), 1 ] ) to equal Map( [ Symbol(), 1 ] ).";
+
+    expect(compareEquals(actual, expected).message).toBe(message);
+  });
+
+  it("does not report mismatches when comparing Map symbol key to jasmine.anything()", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+    jasmine.getEnv().requireFunctioningSymbols();
+
+    var actual = new Map();
+    actual.set(Symbol(),1);
+    var expected = new Map();
+    expected.set(jasmineUnderTest.anything(),1);
+
+    expect(compareEquals(actual, expected).pass).toBe(true);
+  });
+
   function isNotRunningInBrowser() {
     return typeof document === 'undefined'
   }