Rewrite ES6 Set and Map comparison to ignore insertion order

spec/core/matchers/toEqualSpec.js

@@ -359,8 +359,9 @@ describe("toEqual", function() {
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
 
-  it("does not report deep mismatches within Sets", function() {
-    // TODO: implement deep comparison of set elements
+  // == Sets ==
+
+  it("reports mismatches between Sets", function() {
     jasmine.getEnv().requireFunctioningSets();
 
     var actual = new Set([1]),
@@ -370,6 +371,16 @@ describe("toEqual", function() {
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
 
+  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 }) ).';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
   it("reports mismatches between Sets nested in objects", function() {
     jasmine.getEnv().requireFunctioningSets();
 
@@ -390,13 +401,46 @@ describe("toEqual", function() {
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
 
-  it("does not report deep mismatches within Maps", function() {
-    // TODO: implement deep comparison of Map elements
+  it("reports mismatches between Sets where actual is missing a value from expected", 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 }) ).';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Sets where actual has a value missing from expected", 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 }) ).';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  // == Maps ==
+
+  it("does not report mismatches between deep equal Maps", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    // values are the same but with different object identity
+    var actual = new Map([['a', {x: 1}]]),
+      expected = new Map([['a', {x: 1}]]);
+
+    expect(compareEquals(actual, expected).pass).toBe(true);
+  });
+
+  it("reports deep mismatches within Maps", function() {
     jasmine.getEnv().requireFunctioningMaps();
 
-    var actual = new Map([['a', 1]]),
-      expected = new Map([['a', 2]]),
-      message = "Expected Map( [ 'a', 1 ] ) to equal Map( [ 'a', 2 ] ).";
+    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 }) ] ).";
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
@@ -405,8 +449,8 @@ describe("toEqual", function() {
     jasmine.getEnv().requireFunctioningMaps();
 
     var actual = {Maps: [new Map([['a', 1]])]},
-      expected = {Maps: [new Map([['a', 2], ['b', 1]])]},
-      message = "Expected $.Maps[0] = Map( [ 'a', 1 ] ) to equal Map( [ 'a', 2 ], [ 'b', 1 ] ).";
+      expected = {Maps: [new Map([['a', 2]])]},
+      message = "Expected $.Maps[0] = Map( [ 'a', 1 ] ) to equal Map( [ 'a', 2 ] ).";
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
@@ -415,11 +459,40 @@ describe("toEqual", function() {
     jasmine.getEnv().requireFunctioningMaps();
 
     var actual = new Map([['a', 1]]),
-      expected = new Map([['a', 2]]),
-      message = "Expected Map( [ 'a', 1 ] ) to equal Map( [ 'a', 2 ] ).";
+      expected = new Map([['a', 2], ['b', 1]]),
+       message = "Expected Map( [ 'a', 1 ] ) to equal Map( [ 'a', 2 ], [ 'b', 1 ] ).";
 
     expect(compareEquals(actual, expected).message).toEqual(message);
-  });  
+  });
+
+  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 ] ).";
+
+    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]]);
+
+    expect(compareEquals(actual, expected).pass).toBe(true);
+  });
+
+  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 ] ).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
 
   function isNotRunningInBrowser() {
     return typeof document === 'undefined'