Merge branch 'custom-testers-in-asymmetric-matchers' of https://github.com/joeyparrish/jasmine into joeyparrish-custom-testers-in-asymmetric-matchers

spec/core/asymmetric_equality/ArrayContainingSpec.js

@@ -36,4 +36,17 @@ describe("ArrayContaining", function() {
 
     expect(containing.jasmineToString()).toMatch("<jasmine.arrayContaining");
   });
+
+  it("uses custom equality testers", function() {
+    var tester = function(a, b) {
+      // All "foo*" strings match each other.
+      if (typeof a == "string" && typeof b == "string" &&
+          a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
+        return true;
+      }
+    };
+    var containing = new jasmineUnderTest.ArrayContaining(["fooVal"]);
+
+    expect(containing.asymmetricMatch(["fooBar"], [tester])).toBe(true);
+  });
 });

spec/core/asymmetric_equality/ObjectContainingSpec.js

@@ -86,4 +86,17 @@ describe("ObjectContaining", function() {
 
     expect(containing.asymmetricMatch(obj)).toBe(true);
   });
+
+  it("uses custom equality testers", function() {
+    var tester = function(a, b) {
+      // All "foo*" strings match each other.
+      if (typeof a == "string" && typeof b == "string" &&
+          a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
+        return true;
+      }
+    };
+    var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
+
+    expect(containing.asymmetricMatch({foo: "fooBar"}, [tester])).toBe(true);
+  });
 });

spec/core/integration/CustomMatchersSpec.js

@@ -56,6 +56,29 @@ describe("Custom Matchers (Integration)", function() {
     env.execute();
   });
 
+  it("passes the spec if the custom equality matcher passes for types nested inside asymmetric equality testers", function(done) {
+    env.it("spec using custom equality matcher", function() {
+      var customEqualityFn = function(a, b) {
+        // All "foo*" strings match each other.
+        if (typeof a == "string" && typeof b == "string" &&
+            a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
+          return true;
+        }
+      };
+
+      env.addCustomEqualityTester(customEqualityFn);
+      env.expect({foo: 'fooValue'}).toEqual(jasmine.objectContaining({foo: 'fooBar'}));
+      env.expect(['fooValue']).toEqual(jasmine.arrayContaining(['fooBar']));
+    });
+
+    var specExpectations = function(result) {
+      expect(result.status).toEqual('passed');
+    };
+
+    env.addReporter({ specDone: specExpectations, jasmineDone: done });
+    env.execute();
+  });
+
   it("uses the negative compare function for a negative comparison, if provided", function(done) {
     env.it("spec with custom negative comparison matcher", function() {
       env.addMatchers({

spec/core/matchers/matchersUtilSpec.js

@@ -327,6 +327,16 @@ describe("matchersUtil", function() {
       expect(jasmineUnderTest.matchersUtil.equals(true, asymmetricTester, [symmetricTester])).toBe(true);
     });
 
+    it("passes custom equality matchers to asymmetric equality testers", function() {
+      var tester = function(a, b) {};
+      var asymmetricTester = { asymmetricMatch: jasmine.createSpy('asymmetricMatch') };
+      asymmetricTester.asymmetricMatch.and.returnValue(true);
+      var other = {};
+
+      expect(jasmineUnderTest.matchersUtil.equals(asymmetricTester, other, [tester])).toBe(true);
+      expect(asymmetricTester.asymmetricMatch).toHaveBeenCalledWith(other, [tester]);
+    });
+
     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);