Use custom equality testers in Spy#withArgs

Fixes #1836.

spec/core/SpySpec.js

@@ -231,7 +231,7 @@ describe('Spies', function() {
     expect(spy('baz', 'grault', 'waldo')).toEqual(42);
   });
 
-  it('uses custom equality testers when selecting a strategy', function() {
+  it('uses asymmetric equality testers when selecting a strategy', function() {
     var spy = env.createSpy('foo');
     spy.and.returnValue(42);
     spy.withArgs(jasmineUnderTest.any(String)).and.returnValue(-1);
@@ -240,6 +240,23 @@ describe('Spies', function() {
     expect(spy({})).toEqual(42);
   });
 
+  it('uses the provided matchersUtil selecting a strategy', function() {
+    const matchersUtil = new jasmineUnderTest.MatchersUtil({
+      customTesters: [
+        function(a, b) {
+          if ((a === 'bar' && b === 'baz') || (a === 'baz' && b === 'bar')) {
+            return true;
+          }
+        }
+      ]
+    });
+    const spy = new jasmineUnderTest.Spy('aSpy', matchersUtil);
+    spy.and.returnValue('default strategy return value');
+    spy.withArgs('bar').and.returnValue('custom strategy return value');
+    expect(spy('foo')).toEqual('default strategy return value');
+    expect(spy('baz')).toEqual('custom strategy return value');
+  });
+
   it('can reconfigure an argument-specific strategy', function() {
     var spy = env.createSpy('foo');
     spy.withArgs('foo').and.returnValue(42);

spec/core/integration/EnvSpec.js

@@ -3413,4 +3413,56 @@ describe('Env integration', function() {
       done();
     });
   });
+
+  it('uses custom equality testers in Spy#withArgs', async function() {
+    env.it('a spec', function() {
+      const createSpySpy = env.createSpy('via createSpy');
+      const spiedOn = { foo: function() {} };
+      env.spyOn(spiedOn, 'foo');
+      const spyObj = env.createSpyObj('spyObj', ['foo']);
+      const spiedOnAllFuncs = { foo: function() {} };
+      env.spyOnAllFunctions(spiedOnAllFuncs);
+
+      for (spy of [
+        createSpySpy,
+        spiedOn.foo,
+        spyObj.foo,
+        spiedOnAllFuncs.foo
+      ]) {
+        spy.and.returnValue('default strategy');
+        spy.withArgs(42).and.returnValue('custom strategy');
+      }
+
+      env.addCustomEqualityTester(function(a, b) {
+        if ((a === 'x' && b === 42) || (a === 42 && b === 'x')) {
+          return true;
+        }
+      });
+
+      env
+        .expect(createSpySpy('x'))
+        .withContext('createSpy')
+        .toEqual('custom strategy');
+      env
+        .expect(spiedOn.foo('x'))
+        .withContext('spyOn')
+        .toEqual('custom strategy');
+      env
+        .expect(spyObj.foo('x'))
+        .withContext('createSpyObj')
+        .toEqual('custom strategy');
+      env
+        .expect(spiedOnAllFuncs.foo('x'))
+        .withContext('spyOnAllFunctions')
+        .toEqual('custom strategy');
+    });
+
+    let failedExpectations;
+    env.addReporter({
+      specDone: r => (failedExpectations = r.failedExpectations)
+    });
+
+    await env.execute();
+    expect(failedExpectations).toEqual([]);
+  });
 });