JMockit 이중 배열 인수에 대한 기대

Question

일치하는 double은 까다로운 작업입니다. 경험상 우리는 작은 이중 차이를 허용하기 위해 EPSILON을 사용하는 방법을 배웠습니다.

어떻게 JMockit에서 이중 일치를 처리합니까? 예를 들어

, 나는 다음과 같은 코드가있을 때 :

new Expectations() {{ 
     mock.applyWithDouble(4.5); 
     return 4.0; 

     mock.applyWithDoubleArray(new Double[] { 4.0, 5.0 }); 
     returns(7.5); 
    }}; 

내가 JMockit이 호출을 일치시킬 것이라는 점을 확실 할 수 있습니까?

Answer 1

좋은 질문입니다. 다음은 내가 어떻게 할 것인가입니다 :

public class DoubleMatchingTest { 
    static class Dependency { 
     public double applyWithDouble(double value) { return 0; } 
     public double applyWithDoubles(double... values) { return 0; } 
     public double applyWithDoubleArray(Double[] values) { return 0; } 
    } 

    @Mocked Dependency mock; 

    @Test 
    public void matchDoubles() { 
     new Expectations() {{ 
      // Match the expected double value within a given tolerance: 
      mock.applyWithDouble(withEqual(4.5, 0.01)); 
      result = 4.0; 

      // Argument matchers can be used on the values of a varargs parameter: 
      mock.applyWithDoubles(withEqual(4.0, 0.1), withEqual(5.0, 0.1)); 
      result = 8.3; 

      // Matchers cannot be used in arrays, so create/reuse a custom matcher: 
      mock.applyWithDoubleArray(with(new DoubleArrayMatcher(0.1, 4.0, 5.0))); 
      result = 7.5; 
     }}; 

     assertEquals(4.0, mock.applyWithDouble(4.51), 0); 
     assertEquals(8.3, mock.applyWithDoubles(4.1, 4.9), 0); 
     assertEquals(7.5, mock.applyWithDoubleArray(new Double[] {4.1, 4.9}), 0); 
    } 

    // Reusable custom matcher. 
    static final class DoubleArrayMatcher implements Delegate<Double[]> { 
     private final double tolerance; 
     private final Double[] expected; 

     DoubleArrayMatcher(double tolerance, Double... expectedValues) { 
      this.tolerance = tolerance; 
      expected = expectedValues; 
     } 

     @SuppressWarnings("unused") 
     boolean matches(Double[] actual) { 
      if (actual == null || actual.length != expected.length) return false; 

      for (int i = 0; i < actual.length; i++) { 
       double diff = expected[i] - actual[i]; 
       if (Math.abs(diff) > tolerance) return false; 
      } 

      return true; 
     } 
    } 
}