[BREAKING] Use FloatingPoint protocol in beCloseTo matcher

Author: ikesyo

Sources/Nimble/Matchers/BeCloseTo.swift

@@ -1,31 +1,66 @@
 import Foundation
 
 // swiftlint:disable:next identifier_name
-public let DefaultDelta = 0.0001
-
-internal func isCloseTo(_ actualValue: NMBDoubleConvertible?,
-                        expectedValue: NMBDoubleConvertible,
-                        delta: Double)
-    -> PredicateResult {
-        let errorMessage = "be close to <\(stringify(expectedValue))> (within \(stringify(delta)))"
-        return PredicateResult(
-            bool: actualValue != nil &&
-                abs(actualValue!.doubleValue - expectedValue.doubleValue) < delta,
-            message: .expectedCustomValueTo(errorMessage, actual: "<\(stringify(actualValue))>")
-        )
+public let DefaultDelta: Double = 0.0001
+
+public func defaultDelta<F: FloatingPoint>() -> F { 1/10000 /* 0.0001 */ }
+
+internal func isCloseTo<Value: FloatingPoint>(
+    _ actualValue: Value?,
+    expectedValue: Value,
+    delta: Value
+) -> PredicateResult {
+    let errorMessage = "be close to <\(stringify(expectedValue))> (within \(stringify(delta)))"
+    return PredicateResult(
+        bool: actualValue != nil &&
+            abs(actualValue! - expectedValue) < delta,
+        message: .expectedCustomValueTo(errorMessage, actual: "<\(stringify(actualValue))>")
+    )
+}
+
+internal func isCloseTo(
+    _ actualValue: NMBDoubleConvertible?,
+    expectedValue: NMBDoubleConvertible,
+    delta: Double
+) -> PredicateResult {
+    let errorMessage = "be close to <\(stringify(expectedValue))> (within \(stringify(delta)))"
+    return PredicateResult(
+        bool: actualValue != nil &&
+            abs(actualValue!.doubleValue - expectedValue.doubleValue) < delta,
+        message: .expectedCustomValueTo(errorMessage, actual: "<\(stringify(actualValue))>")
+    )
 }
 
 /// A Nimble matcher that succeeds when a value is close to another. This is used for floating
 /// point values which can have imprecise results when doing arithmetic on them.
 ///
 /// @see equal
-public func beCloseTo<Value: NMBDoubleConvertible>(_ expectedValue: Value, within delta: Double = DefaultDelta) -> Predicate<Value> {
+public func beCloseTo<Value: FloatingPoint>(
+    _ expectedValue: Value,
+    within delta: Value = defaultDelta()
+) -> Predicate<Value> {
     return Predicate.define { actualExpression in
         return isCloseTo(try actualExpression.evaluate(), expectedValue: expectedValue, delta: delta)
     }
 }
 
-private func beCloseTo(_ expectedValue: NMBDoubleConvertible, within delta: Double = DefaultDelta) -> Predicate<NMBDoubleConvertible> {
+/// A Nimble matcher that succeeds when a value is close to another. This is used for floating
+/// point values which can have imprecise results when doing arithmetic on them.
+///
+/// @see equal
+public func beCloseTo<Value: NMBDoubleConvertible>(
+    _ expectedValue: Value,
+    within delta: Double = DefaultDelta
+) -> Predicate<Value> {
+    return Predicate.define { actualExpression in
+        return isCloseTo(try actualExpression.evaluate(), expectedValue: expectedValue, delta: delta)
+    }
+}
+
+private func beCloseTo(
+    _ expectedValue: NMBDoubleConvertible,
+    within delta: Double = DefaultDelta
+) -> Predicate<NMBDoubleConvertible> {
     return Predicate.define { actualExpression in
         return isCloseTo(try actualExpression.evaluate(), expectedValue: expectedValue, delta: delta)
     }
@@ -61,48 +96,68 @@ extension NMBPredicate {
 }
 #endif
 
-public func beCloseTo(_ expectedValues: [Double], within delta: Double = DefaultDelta) -> Predicate<[Double]> {
+public func beCloseTo<Value: FloatingPoint, Values: Collection>(
+    _ expectedValues: Values,
+    within delta: Value = defaultDelta()
+) -> Predicate<Values> where Values.Element == Value {
     let errorMessage = "be close to <\(stringify(expectedValues))> (each within \(stringify(delta)))"
     return Predicate.simple(errorMessage) { actualExpression in
-        if let actual = try actualExpression.evaluate() {
-            if actual.count != expectedValues.count {
+        guard let actualValues = try actualExpression.evaluate() else {
+            return .doesNotMatch
+        }
+
+        if actualValues.count != expectedValues.count {
+            return .doesNotMatch
+        }
+
+        for index in actualValues.indices {
+            if abs(actualValues[index] - expectedValues[index]) > delta {
                 return .doesNotMatch
-            } else {
-                for (index, actualItem) in actual.enumerated() {
-                    if fabs(actualItem - expectedValues[index]) > delta {
-                        return .doesNotMatch
-                    }
-                }
-                return .matches
             }
         }
-        return .doesNotMatch
+        return .matches
     }
 }
 
 // MARK: - Operators
 
 infix operator ≈ : ComparisonPrecedence
 
-extension Expectation where T == [Double] {
+extension Expectation where T: Collection, T.Element: FloatingPoint {
     // swiftlint:disable:next identifier_name
-    public static func ≈(lhs: Expectation, rhs: [Double]) {
+    public static func ≈(lhs: Expectation, rhs: T) {
         lhs.to(beCloseTo(rhs))
     }
 }
 
-extension Expectation where T == NMBDoubleConvertible {
+extension Expectation where T: FloatingPoint {
     // swiftlint:disable:next identifier_name
-    public static func ≈(lhs: Expectation, rhs: NMBDoubleConvertible) {
+    public static func ≈(lhs: Expectation, rhs: T) {
         lhs.to(beCloseTo(rhs))
     }
 
     // swiftlint:disable:next identifier_name
-    public static func ≈(lhs: Expectation, rhs: (expected: NMBDoubleConvertible, delta: Double)) {
+    public static func ≈(lhs: Expectation, rhs: (expected: T, delta: T)) {
         lhs.to(beCloseTo(rhs.expected, within: rhs.delta))
     }
 
-    public static func == (lhs: Expectation, rhs: (expected: NMBDoubleConvertible, delta: Double)) {
+    public static func == (lhs: Expectation, rhs: (expected: T, delta: T)) {
+        lhs.to(beCloseTo(rhs.expected, within: rhs.delta))
+    }
+}
+
+extension Expectation where T: NMBDoubleConvertible {
+    // swiftlint:disable:next identifier_name
+    public static func ≈(lhs: Expectation, rhs: T) {
+        lhs.to(beCloseTo(rhs))
+    }
+
+    // swiftlint:disable:next identifier_name
+    public static func ≈(lhs: Expectation, rhs: (expected: T, delta: Double)) {
+        lhs.to(beCloseTo(rhs.expected, within: rhs.delta))
+    }
+
+    public static func == (lhs: Expectation, rhs: (expected: T, delta: Double)) {
         lhs.to(beCloseTo(rhs.expected, within: rhs.delta))
     }
 }
@@ -115,6 +170,10 @@ precedencegroup PlusMinusOperatorPrecedence {
 
 infix operator ± : PlusMinusOperatorPrecedence
 // swiftlint:disable:next identifier_name
-public func ±(lhs: NMBDoubleConvertible, rhs: Double) -> (expected: NMBDoubleConvertible, delta: Double) {
+public func ±<Value: FloatingPoint>(lhs: Value, rhs: Value) -> (expected: Value, delta: Value) {
+    return (expected: lhs, delta: rhs)
+}
+// swiftlint:disable:next identifier_name
+public func ±<Value: NMBDoubleConvertible>(lhs: Value, rhs: Double) -> (expected: Value, delta: Double) {
     return (expected: lhs, delta: rhs)
 }

Sources/Nimble/Matchers/MatcherProtocols.swift

@@ -43,24 +43,6 @@ public protocol NMBDoubleConvertible {
     var doubleValue: CDouble { get }
 }
 
-extension Double: NMBDoubleConvertible {
-    public var doubleValue: CDouble {
-        return self
-    }
-}
-
-extension Float: NMBDoubleConvertible {
-    public var doubleValue: CDouble {
-        return CDouble(self)
-    }
-}
-
-extension CGFloat: NMBDoubleConvertible {
-    public var doubleValue: CDouble {
-        return CDouble(self)
-    }
-}
-
 extension NSNumber: NMBDoubleConvertible {
 }