dnrops
/
Surge
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replaced `XCTAssertArray(Float|Double)EqualWithAccuracy(_:_:accuracy:)` with short-circuiting overload of `XCTAssertEqual(_:_:accuracy:)`

This commit is contained in:
Vincent Esche 2019-08-06 09:59:23 +02:00
parent ea7f83a526
commit cf836d6fd1
3 changed files with 149 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
Tests/SurgeTests/ConvolutionTests.swift
View File

@ -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)
}
}

118
Tests/SurgeTests/XCTAssert+Surge.swift Normal file
View File

@ -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
}

16
Tests/SurgeTests/XCTestCase+Surge.swift
View File

@ -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)
}
}
}