Replaced `XCTAssertArray(Float|Double)EqualWithAccuracy(_:_:accuracy:)` with short-circuiting overload of `XCTAssertEqual(_:_:accuracy:)`
This commit is contained in:
parent
ea7f83a526
commit
cf836d6fd1
|
@ -58,11 +58,11 @@ class ConvolutionTests: XCTestCase {
|
|||
let d3f: [Float] = [0, 1, 1]
|
||||
let e3f: [Float] = [0, 0, 0, 0, 0, 0, 0]
|
||||
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: conv(a1f, a2f), a3f, floatAccuracy)
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: conv(b1f, b2f), b3f, floatAccuracy)
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: conv(c1f, c2f), c3f, floatAccuracy)
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: conv(d1f, d2f), d3f, floatAccuracy)
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: conv(e1f, e2f), e3f, floatAccuracy)
|
||||
XCTAssertEqual(conv(a1f, a2f), a3f, accuracy: floatAccuracy)
|
||||
XCTAssertEqual(conv(b1f, b2f), b3f, accuracy: floatAccuracy)
|
||||
XCTAssertEqual(conv(c1f, c2f), c3f, accuracy: floatAccuracy)
|
||||
XCTAssertEqual(conv(d1f, d2f), d3f, accuracy: floatAccuracy)
|
||||
XCTAssertEqual(conv(e1f, e2f), e3f, accuracy: floatAccuracy)
|
||||
}
|
||||
|
||||
// MARK: Convolution - Double
|
||||
|
@ -73,11 +73,11 @@ class ConvolutionTests: XCTestCase {
|
|||
let d3d: [Double] = [0, 1, 1]
|
||||
let e3d: [Double] = [0, 0, 0, 0, 0, 0, 0]
|
||||
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: conv(a1d, a2d), a3d, doubleAccuracy)
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: conv(b1d, b2d), b3d, doubleAccuracy)
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: conv(c1d, c2d), c3d, doubleAccuracy)
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: conv(d1d, d2d), d3d, doubleAccuracy)
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: conv(e1d, e2d), e3d, doubleAccuracy)
|
||||
XCTAssertEqual(conv(a1d, a2d), a3d, accuracy: doubleAccuracy)
|
||||
XCTAssertEqual(conv(b1d, b2d), b3d, accuracy: doubleAccuracy)
|
||||
XCTAssertEqual(conv(c1d, c2d), c3d, accuracy: doubleAccuracy)
|
||||
XCTAssertEqual(conv(d1d, d2d), d3d, accuracy: doubleAccuracy)
|
||||
XCTAssertEqual(conv(e1d, e2d), e3d, accuracy: doubleAccuracy)
|
||||
}
|
||||
|
||||
// MARK: Cross-Correlation - Float
|
||||
|
@ -88,11 +88,11 @@ class ConvolutionTests: XCTestCase {
|
|||
let d3f: [Float] = [1, 1, 0]
|
||||
let e3f: [Float] = [0, 0, 0, 0, 0, 0, 0, 0, 0]
|
||||
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: xcorr(a1f, a2f), a3f, floatAccuracy)
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: xcorr(b1f, b2f), b3f, floatAccuracy)
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: xcorr(c1f, c2f), c3f, floatAccuracy)
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: xcorr(d1f, d2f), d3f, floatAccuracy)
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: xcorr(e1f, e2f), e3f, floatAccuracy)
|
||||
XCTAssertEqual(xcorr(a1f, a2f), a3f, accuracy: floatAccuracy)
|
||||
XCTAssertEqual(xcorr(b1f, b2f), b3f, accuracy: floatAccuracy)
|
||||
XCTAssertEqual(xcorr(c1f, c2f), c3f, accuracy: floatAccuracy)
|
||||
XCTAssertEqual(xcorr(d1f, d2f), d3f, accuracy: floatAccuracy)
|
||||
XCTAssertEqual(xcorr(e1f, e2f), e3f, accuracy: floatAccuracy)
|
||||
}
|
||||
|
||||
// MARK: Cross-Correlation - Double
|
||||
|
@ -103,11 +103,11 @@ class ConvolutionTests: XCTestCase {
|
|||
let d3d: [Double] = [1, 1, 0]
|
||||
let e3d: [Double] = [0, 0, 0, 0, 0, 0, 0, 0, 0]
|
||||
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: xcorr(a1d, a2d), a3d, doubleAccuracy)
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: xcorr(b1d, b2d), b3d, doubleAccuracy)
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: xcorr(c1d, c2d), c3d, doubleAccuracy)
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: xcorr(d1d, d2d), d3d, doubleAccuracy)
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: xcorr(e1d, e2d), e3d, doubleAccuracy)
|
||||
XCTAssertEqual(xcorr(a1d, a2d), a3d, accuracy: doubleAccuracy)
|
||||
XCTAssertEqual(xcorr(b1d, b2d), b3d, accuracy: doubleAccuracy)
|
||||
XCTAssertEqual(xcorr(c1d, c2d), c3d, accuracy: doubleAccuracy)
|
||||
XCTAssertEqual(xcorr(d1d, d2d), d3d, accuracy: doubleAccuracy)
|
||||
XCTAssertEqual(xcorr(e1d, e2d), e3d, accuracy: doubleAccuracy)
|
||||
}
|
||||
|
||||
// MARK: Auto-Correlation - Float
|
||||
|
@ -118,11 +118,11 @@ class ConvolutionTests: XCTestCase {
|
|||
let d3f: [Float] = [1, 2, 1]
|
||||
let e3f: [Float] = [0, 0, 0, 0, 0, 0, 0, 0, 0]
|
||||
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: xcorr(a1f), a3f, floatAccuracy)
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: xcorr(b1f), b3f, floatAccuracy)
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: xcorr(c1f), c3f, floatAccuracy)
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: xcorr(d1f), d3f, floatAccuracy)
|
||||
XCTAssertArrayFloatEqualWithAccuracy(calcArray: xcorr(e1f), e3f, floatAccuracy)
|
||||
XCTAssertEqual(xcorr(a1f), a3f, accuracy: floatAccuracy)
|
||||
XCTAssertEqual(xcorr(b1f), b3f, accuracy: floatAccuracy)
|
||||
XCTAssertEqual(xcorr(c1f), c3f, accuracy: floatAccuracy)
|
||||
XCTAssertEqual(xcorr(d1f), d3f, accuracy: floatAccuracy)
|
||||
XCTAssertEqual(xcorr(e1f), e3f, accuracy: floatAccuracy)
|
||||
}
|
||||
|
||||
// MARK: Auto-Correlation - Double
|
||||
|
@ -133,11 +133,10 @@ class ConvolutionTests: XCTestCase {
|
|||
let d3d: [Double] = [1, 2, 1]
|
||||
let e3d: [Double] = [0, 0, 0, 0, 0, 0, 0, 0, 0]
|
||||
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: xcorr(a1d), a3d, doubleAccuracy)
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: xcorr(b1d), b3d, doubleAccuracy)
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: xcorr(c1d), c3d, doubleAccuracy)
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: xcorr(d1d), d3d, doubleAccuracy)
|
||||
XCTAssertArrayDoubleEqualWithAccuracy(calcArray: xcorr(e1d), e3d, doubleAccuracy)
|
||||
XCTAssertEqual(xcorr(a1d), a3d, accuracy: doubleAccuracy)
|
||||
XCTAssertEqual(xcorr(b1d), b3d, accuracy: doubleAccuracy)
|
||||
XCTAssertEqual(xcorr(c1d), c3d, accuracy: doubleAccuracy)
|
||||
XCTAssertEqual(xcorr(d1d), d3d, accuracy: doubleAccuracy)
|
||||
XCTAssertEqual(xcorr(e1d), e3d, accuracy: doubleAccuracy)
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -0,0 +1,118 @@
|
|||
// Copyright © 2014-2018 the Surge contributors
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
// THE SOFTWARE.
|
||||
|
||||
import Foundation
|
||||
import XCTest
|
||||
|
||||
/// Allows comparing:
|
||||
///
|
||||
/// ```
|
||||
/// T where
|
||||
/// T: Collection,
|
||||
/// T.Element == U,
|
||||
/// U: FloatingPoint
|
||||
/// ```
|
||||
///
|
||||
/// Useful for comparing:
|
||||
/// - `[Float]`
|
||||
/// - `[Double]`
|
||||
@discardableResult
|
||||
func XCTAssertEqual<T, U>(
|
||||
_ expression1: @autoclosure () throws -> T,
|
||||
_ expression2: @autoclosure () throws -> T,
|
||||
accuracy: U,
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line
|
||||
) -> Bool
|
||||
where T: Collection, T.Element == U, U: FloatingPoint
|
||||
{
|
||||
let (actualValues, expectedValues): (T, T)
|
||||
|
||||
do {
|
||||
(actualValues, expectedValues) = (try expression1(), try expression2())
|
||||
} catch let error {
|
||||
XCTFail("Error: \(error)", file: file, line: line)
|
||||
return false
|
||||
}
|
||||
|
||||
XCTAssertEqual(actualValues.count, expectedValues.count, file: file, line: line)
|
||||
|
||||
for (actual, expected) in Swift.zip(actualValues, expectedValues) {
|
||||
guard abs(actual - expected) > abs(accuracy) else {
|
||||
continue
|
||||
}
|
||||
|
||||
let failureMessage = "XCTAssertEqualWithAccuracy failed: (\(actual)) is not equal to (\(expected)) +/- (\(accuracy))"
|
||||
let userMessage = message()
|
||||
let message = "\(failureMessage) - \(userMessage)"
|
||||
XCTFail(message, file: file, line: line)
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
/// Allows comparing:
|
||||
///
|
||||
/// ```
|
||||
/// T where
|
||||
/// T: Collection,
|
||||
/// U: Collection,
|
||||
/// T.Element == U,
|
||||
/// U.Element == V,
|
||||
/// V: FloatingPoint
|
||||
/// ```
|
||||
///
|
||||
/// Useful for comparing:
|
||||
/// - `[[Float]]`
|
||||
/// - `[[Double]]`
|
||||
/// - `Matrix<Float>`
|
||||
/// - `Matrix<Double>`
|
||||
@discardableResult
|
||||
func XCTAssertEqual<T, U, V>(
|
||||
_ expression1: @autoclosure () throws -> T,
|
||||
_ expression2: @autoclosure () throws -> T,
|
||||
accuracy: V,
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line
|
||||
) -> Bool
|
||||
where T: Collection, U: Collection, T.Element == U, U.Element == V, V: FloatingPoint
|
||||
{
|
||||
let (actualValues, expectedValues): (T, T)
|
||||
|
||||
do {
|
||||
(actualValues, expectedValues) = (try expression1(), try expression2())
|
||||
} catch let error {
|
||||
XCTFail("Error: \(error)", file: file, line: line)
|
||||
return false
|
||||
}
|
||||
|
||||
XCTAssertEqual(actualValues.count, expectedValues.count, file: file, line: line)
|
||||
|
||||
for (actual, expected) in Swift.zip(actualValues, expectedValues) {
|
||||
guard XCTAssertEqual(actual, expected, accuracy: accuracy) else {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
|
@ -23,7 +23,7 @@ import XCTest
|
|||
|
||||
extension XCTestCase {
|
||||
func measureAndValidateMappedFunctionWithAccuracy<C: Collection>(source: C, member: (C.Iterator.Element) -> (C.Iterator.Element), mapped: @escaping (C) -> ([C.Iterator.Element]), accuracy: C.Iterator.Element) where C.Iterator.Element: ExpressibleByFloatLiteral & FloatingPoint {
|
||||
var expected = source.map(member)
|
||||
let expected = source.map(member)
|
||||
|
||||
var actual: [C.Iterator.Element] = []
|
||||
self.measure {
|
||||
|
@ -34,18 +34,4 @@ extension XCTestCase {
|
|||
XCTAssertEqual(actual[i], expected[j], accuracy: accuracy)
|
||||
}
|
||||
}
|
||||
|
||||
func XCTAssertArrayFloatEqualWithAccuracy(calcArray: [Float], _ testArray: [Float], _ accuracy: Float) {
|
||||
assert(calcArray.count == testArray.count, "XCTAssertArrayFloatEqualWithAccuracy arrays must be same size")
|
||||
for i: Int in 0..<calcArray.count {
|
||||
XCTAssertEqual(calcArray[i], testArray[i], accuracy: accuracy)
|
||||
}
|
||||
}
|
||||
|
||||
func XCTAssertArrayDoubleEqualWithAccuracy(calcArray: [Double], _ testArray: [Double], _ accuracy: Double) {
|
||||
assert(calcArray.count == testArray.count, "XCTAssertArrayFloatEqualWithAccuracy arrays must be same size")
|
||||
for i: Int in 0..<calcArray.count {
|
||||
XCTAssertEqual(calcArray[i], testArray[i], accuracy: accuracy)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue