diff --git a/Tests/SurgeTests/ConvolutionTests.swift b/Tests/SurgeTests/ConvolutionTests.swift index 6eeebf1..2e1d7d4 100644 --- a/Tests/SurgeTests/ConvolutionTests.swift +++ b/Tests/SurgeTests/ConvolutionTests.swift @@ -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) } - } diff --git a/Tests/SurgeTests/XCTAssert+Surge.swift b/Tests/SurgeTests/XCTAssert+Surge.swift new file mode 100644 index 0000000..89ab2b2 --- /dev/null +++ b/Tests/SurgeTests/XCTAssert+Surge.swift @@ -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( + _ 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` +/// - `Matrix` +@discardableResult +func XCTAssertEqual( + _ 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 +} diff --git a/Tests/SurgeTests/XCTestCase+Surge.swift b/Tests/SurgeTests/XCTestCase+Surge.swift index 8dda562..010038d 100644 --- a/Tests/SurgeTests/XCTestCase+Surge.swift +++ b/Tests/SurgeTests/XCTestCase+Surge.swift @@ -23,7 +23,7 @@ import XCTest extension XCTestCase { func measureAndValidateMappedFunctionWithAccuracy(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..