Print additional details when emitting assertion failure messages

This brings the output in line with what Darwin's XCTest outputs
* Includes the name of the failing assertion function
* Includes details about the asserted expressions when appropriate

Author: briancroom

XCTest/XCTAssert.swift

@@ -10,101 +10,193 @@
 //  XCTAssert.swift
 //
 
+private enum _XCTAssertion {
+    case Equal(Any, Any)
+    case EqualWithAccuracy(Any, Any, accuracy: Any)
+    case GreaterThan(Any, Any)
+    case GreaterThanOrEqual(Any, Any)
+    case LessThan(Any, Any)
+    case LessThanOrEqual(Any, Any)
+    case NotEqual(Any, Any)
+    case NotEqualWithAccuracy(Any, Any, accuracy: Any)
+    case Nil
+    case NotNil
+    case True
+    case False
+    case Fail
+
+    var name: String? {
+        switch(self) {
+        case .Equal: return "XCTAssertEqual"
+        case .EqualWithAccuracy: return "XCTAssertEqualWithAccuracy"
+        case .GreaterThan: return "XCTAssertGreaterThan"
+        case .GreaterThanOrEqual: return "XCTAssertGreaterThanOrEqual"
+        case .LessThan: return "XCTAssertLessThan"
+        case .LessThanOrEqual: return "XCTAssertLessThanOrEqual"
+        case .NotEqual: return "XCTAssertNotEqual"
+        case .NotEqualWithAccuracy: return "XCTAssertNotEqualWithAccuracy"
+        case .Nil: return "XCTAssertNil"
+        case .NotNil: return "XCTAssertNotNil"
+        case .True: return "XCTAssertTrue"
+        case .False: return "XCTAssertFalse"
+        case .Fail: return nil
+        }
+    }
+
+    var failureDetails: String? {
+        switch(self) {
+        case .Equal(let value1, let value2):
+            return "(\"\(value1)\") is not equal to (\"\(value2)\")"
+        case .EqualWithAccuracy(let value1, let value2, let accuracy):
+            return "(\"\(value1)\") is not equal to (\"\(value2)\") +/- (\"\(accuracy)\")"
+        case .GreaterThan(let value1, let value2):
+            return "(\"\(value1)\") is not greater than (\"\(value2)\")"
+        case .GreaterThanOrEqual(let value1, let value2):
+            return "(\"\(value1)\") is less than (\"\(value2)\")"
+        case .LessThan(let value1, let value2):
+            return "(\"\(value1)\") is not less than (\"\(value2)\")"
+        case .LessThanOrEqual(let value1, let value2):
+            return "(\"\(value1)\") is greater than (\"\(value2)\")"
+        case .NotEqual(let value1, let value2):
+            return "(\"\(value1)\") is equal to (\"\(value2)\")"
+        case .NotEqualWithAccuracy(let value1, let value2, let accuracy):
+            return "(\"\(value1)\") is equal to (\"\(value2)\") +/- (\"\(accuracy)\")"
+        case .Nil:
+            return "\"notnil\""
+        case .NotNil: return nil
+        case .True: return nil
+        case .False: return nil
+        case .Fail: return nil
+        }
+    }
+
+    var failureDescription: String {
+        switch (name, failureDetails) {
+        case let (name?, description?):
+            return "\(name) failed: \(description)"
+        case let (name?, _):
+            return "\(name) failed"
+        default:
+            return "failed"
+        }
+    }
+}
+
+private func _XCTAssert(@autoclosure expression: () -> BooleanType, @autoclosure assertion: () -> _XCTAssertion, _ message: String, file: StaticString, line: UInt) {
+    if !expression().boolValue {
+        if let test = XCTCurrentTestCase {
+            test.testFailure(message, failureDescription: assertion().failureDescription, expected: true, file: file, line: line)
+        }
+    }
+}
+
 /**
-The primitive assertion function for XCTest. All other XCTAssert* functions are implemented in terms of this. This function emits a test failure if the general Bool expression passed to it evaluates to false.
+This function emits a test failure if the general Bool expression passed to it evaluates to false.
 - Parameter expression: A boolean test. If it evaluates to false, the assertion fails and emits a test failure.
-- Parameter message: An optional message to use in the failure if the assetion fails. If no message is supplied a default message is used.
+- Parameter message: An optional message to use in the failure if the assertion fails.
 - Parameter file: The file name to use in the error message if the assertion fails. Default is the file containing the call to this function. It is rare to provide this parameter when calling this function.
 - Parameter line: The line number to use in the error message if the assertion fails. Default is the line number of the call to this function in the calling file. It is rare to provide this parameter when calling this function.
 */
 public func XCTAssert(@autoclosure expression: () -> BooleanType, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    if !expression().boolValue {
-        if let test = XCTCurrentTestCase {
-            test.testFailure(message, expected: true, file: file, line: line)
-        }
-    }
+    XCTAssertTrue(expression, message, file: file, line: line)
 }
 
 public func XCTAssertEqual<T : Equatable>(@autoclosure expression1: () -> T?, @autoclosure _ expression2: () -> T?, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() == expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 == value2, assertion: .Equal(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertEqual<T : Equatable>(@autoclosure expression1: () -> ArraySlice<T>, @autoclosure _ expression2: () -> ArraySlice<T>, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() == expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 == value2, assertion: .Equal(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertEqual<T : Equatable>(@autoclosure expression1: () -> ContiguousArray<T>, @autoclosure _ expression2: () -> ContiguousArray<T>, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() == expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 == value2, assertion: .Equal(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertEqual<T : Equatable>(@autoclosure expression1: () -> [T], @autoclosure _ expression2: () -> [T], _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() == expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 == value2, assertion: .Equal(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertEqual<T, U : Equatable>(@autoclosure expression1: () -> [T : U], @autoclosure _ expression2: () -> [T : U], _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() == expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 == value2, assertion: .Equal(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertEqualWithAccuracy<T : FloatingPointType>(@autoclosure expression1: () -> T, @autoclosure _ expression2: () -> T, accuracy: T, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(abs(expression1().distanceTo(expression2())) <= abs(accuracy.distanceTo(T(0))), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(abs(value1.distanceTo(value2)) <= abs(accuracy.distanceTo(T(0))), assertion: .EqualWithAccuracy(value1, value2, accuracy: accuracy), message, file: file, line: line)
 }
 
 public func XCTAssertFalse(@autoclosure expression: () -> BooleanType, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(!expression().boolValue, message, file: file, line: line)
+    _XCTAssert(!expression().boolValue, assertion: .False, message, file: file, line: line)
 }
 
 public func XCTAssertGreaterThan<T : Comparable>(@autoclosure expression1: () -> T, @autoclosure _ expression2: () -> T, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() > expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 > value2, assertion: .GreaterThan(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertGreaterThanOrEqual<T : Comparable>(@autoclosure expression1: () -> T, @autoclosure _ expression2: () -> T, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() >= expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 >= value2, assertion: .GreaterThanOrEqual(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertLessThan<T : Comparable>(@autoclosure expression1: () -> T, @autoclosure _ expression2: () -> T, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() < expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 < value2, assertion: .LessThan(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertLessThanOrEqual<T : Comparable>(@autoclosure expression1: () -> T, @autoclosure _ expression2: () -> T, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() <= expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 <= value2, assertion: .LessThanOrEqual(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertNil(@autoclosure expression: () -> Any?, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression() == nil, message, file: file, line: line)
+    _XCTAssert(expression() == nil, assertion: .Nil, message, file: file, line: line)
 }
 
 public func XCTAssertNotEqual<T : Equatable>(@autoclosure expression1: () -> T?, @autoclosure _ expression2: () -> T?, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() != expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 != value2, assertion: .NotEqual(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertNotEqual<T : Equatable>(@autoclosure expression1: () -> ContiguousArray<T>, @autoclosure _ expression2: () -> ContiguousArray<T>, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() != expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 != value2, assertion: .NotEqual(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertNotEqual<T : Equatable>(@autoclosure expression1: () -> ArraySlice<T>, @autoclosure _ expression2: () -> ArraySlice<T>, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() != expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 != value2, assertion: .NotEqual(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertNotEqual<T : Equatable>(@autoclosure expression1: () -> [T], @autoclosure _ expression2: () -> [T], _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() != expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 != value2, assertion: .NotEqual(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertNotEqual<T, U : Equatable>(@autoclosure expression1: () -> [T : U], @autoclosure _ expression2: () -> [T : U], _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression1() != expression2(), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(value1 != value2, assertion: .NotEqual(value1, value2), message, file: file, line: line)
 }
 
 public func XCTAssertNotEqualWithAccuracy<T : FloatingPointType>(@autoclosure expression1: () -> T, @autoclosure _ expression2: () -> T, _ accuracy: T, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(abs(expression1().distanceTo(expression2())) > abs(accuracy.distanceTo(T(0))), message, file: file, line: line)
+    let (value1, value2) = (expression1(), expression2())
+    _XCTAssert(abs(value1.distanceTo(value2)) > abs(accuracy.distanceTo(T(0))), assertion: .NotEqualWithAccuracy(value1, value2, accuracy: accuracy), message, file: file, line: line)
 }
 
 public func XCTAssertNotNil(@autoclosure expression: () -> Any?, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression() != nil, message, file: file, line: line)
+    _XCTAssert(expression() != nil, assertion: .NotNil, message, file: file, line: line)
 }
 
 public func XCTAssertTrue(@autoclosure expression: () -> BooleanType, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(expression().boolValue, message, file: file, line: line)
+    _XCTAssert(expression().boolValue, assertion: .True, message, file: file, line: line)
 }
 
 public func XCTFail(message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
-    XCTAssert(false, message, file: file, line: line)
+    _XCTAssert(false, assertion: .Fail, message, file: file, line: line)
 }

XCTest/XCTestCase.swift

@@ -77,11 +77,11 @@ extension XCTestCase {
     }
 
     // This function is for the use of XCTestCase only, but we must make it public or clients will get a link failure when using XCTest (23476006)
-    public func testFailure(message: String, expected: Bool, file: StaticString , line: UInt) {
+    public func testFailure(message: String, failureDescription: String, expected: Bool, file: StaticString, line: UInt) {
         if !continueAfterFailure {
             assert(false, message, file: file, line: line)
         } else {
-            XCTCurrentFailures.append(XCTFailure(message: message, expected: expected, file: file, line: line))
+            XCTCurrentFailures.append(XCTFailure(message: message, failureDescription: failureDescription, expected: expected, file: file, line: line))
         }
     }
 

XCTest/XCTestMain.swift

@@ -20,12 +20,13 @@ import Darwin
 
 struct XCTFailure {
     var message: String
+    var failureDescription: String
     var expected: Bool
     var file: StaticString
     var line: UInt
 
     func emit(method: String) {
-        print("\(file):\(line): \(expected ? "" : "unexpected ")error: \(method) : \(message)")
+        print("\(file):\(line): \(expected ? "" : "unexpected ")error: \(method) : \(failureDescription) - \(message)")
     }
 }