0001    // This source file is part of the Swift.org open source project
0002    //
0003    // Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
0004    // Licensed under Apache License v2.0 with Runtime Library Exception
0005    //
0006    // See http://swift.org/LICENSE.txt for license information
0007    // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
0008    //
0009    //
0010    //  XCTAssert.swift
0011    //
0012    
0013    private enum _XCTAssertion
XCTAssert.swift:63
    func failureDescription(assertion: _XCTAssertion) -> String {
XCTAssert.swift:84
private func _XCTEvaluateAssertion(assertion: _XCTAssertion, @autoclosure message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__, @noescape expression: () throws -> _XCTAssertionResult) {
 {
0014        case Equal
XCTAssert.swift:31
        case .Equal: return "XCTAssertEqual"
XCTAssert.swift:163
    _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
XCTAssert.swift:174
    _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
XCTAssert.swift:185
    _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
XCTAssert.swift:196
    _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
XCTAssert.swift:207
    _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {

0015        case EqualWithAccuracy
XCTAssert.swift:32
        case .EqualWithAccuracy: return "XCTAssertEqualWithAccuracy"
XCTAssert.swift:218
    _XCTEvaluateAssertion(.EqualWithAccuracy, message: message, file: file, line: line) {

0016        case GreaterThan
XCTAssert.swift:33
        case .GreaterThan: return "XCTAssertGreaterThan"
XCTAssert.swift:240
    _XCTEvaluateAssertion(.GreaterThan, message: message, file: file, line: line) {

0017        case GreaterThanOrEqual
XCTAssert.swift:34
        case .GreaterThanOrEqual: return "XCTAssertGreaterThanOrEqual"
XCTAssert.swift:251
    _XCTEvaluateAssertion(.GreaterThanOrEqual, message: message, file: file, line: line) {

0018        case LessThan
XCTAssert.swift:35
        case .LessThan: return "XCTAssertLessThan"
XCTAssert.swift:262
    _XCTEvaluateAssertion(.LessThan, message: message, file: file, line: line) {

0019        case LessThanOrEqual
XCTAssert.swift:36
        case .LessThanOrEqual: return "XCTAssertLessThanOrEqual"
XCTAssert.swift:273
    _XCTEvaluateAssertion(.LessThanOrEqual, message: message, file: file, line: line) {

0020        case NotEqual
XCTAssert.swift:37
        case .NotEqual: return "XCTAssertNotEqual"
XCTAssert.swift:295
    _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
XCTAssert.swift:306
    _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
XCTAssert.swift:317
    _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
XCTAssert.swift:328
    _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
XCTAssert.swift:339
    _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {

0021        case NotEqualWithAccuracy
XCTAssert.swift:38
        case .NotEqualWithAccuracy: return "XCTAssertNotEqualWithAccuracy"
XCTAssert.swift:350
    _XCTEvaluateAssertion(.NotEqualWithAccuracy, message: message, file: file, line: line) {

0022        case Nil
XCTAssert.swift:39
        case .Nil: return "XCTAssertNil"
XCTAssert.swift:284
    _XCTEvaluateAssertion(.Nil, message: message, file: file, line: line) {
XCTAssert.swift:361
    _XCTEvaluateAssertion(.Nil, message: message, file: file, line: line) {

0023        case NotNil
XCTAssert.swift:40
        case .NotNil: return "XCTAssertNotNil"

0024        case True
XCTAssert.swift:41
        case .True: return "XCTAssertTrue"
XCTAssert.swift:372
    _XCTEvaluateAssertion(.True, message: message, file: file, line: line) {

0025        case False
XCTAssert.swift:42
        case .False: return "XCTAssertFalse"
XCTAssert.swift:229
    _XCTEvaluateAssertion(.False, message: message, file: file, line: line) {

0026        case Fail
XCTAssert.swift:44
        case .Fail: return nil
XCTAssert.swift:383
    _XCTEvaluateAssertion(.Fail, message: message, file: file, line: line) {

0027        case ThrowsError
XCTAssert.swift:43
        case .ThrowsError: return "XCTAssertThrowsError"
XCTAssert.swift:389
    _XCTEvaluateAssertion(.ThrowsError, message: message, file: file, line: line) {

0028    
0029        var name
XCTAssert.swift:76
        if let name = assertion.name {
: String? {
0030            switch(self) {
0031            case .Equal: return "XCTAssertEqual"
0032            case .EqualWithAccuracy: return "XCTAssertEqualWithAccuracy"
0033            case .GreaterThan: return "XCTAssertGreaterThan"
0034            case .GreaterThanOrEqual: return "XCTAssertGreaterThanOrEqual"
0035            case .LessThan: return "XCTAssertLessThan"
0036            case .LessThanOrEqual: return "XCTAssertLessThanOrEqual"
0037            case .NotEqual: return "XCTAssertNotEqual"
0038            case .NotEqualWithAccuracy: return "XCTAssertNotEqualWithAccuracy"
0039            case .Nil: return "XCTAssertNil"
0040            case .NotNil: return "XCTAssertNotNil"
0041            case .True: return "XCTAssertTrue"
0042            case .False: return "XCTAssertFalse"
0043            case .ThrowsError: return "XCTAssertThrowsError"
0044            case .Fail: return nil
0045            }
0046        }
0047    }
0048    
0049    private enum _XCTAssertionResult
XCTAssert.swift:84
private func _XCTEvaluateAssertion(assertion: _XCTAssertion, @autoclosure message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__, @noescape expression: () throws -> _XCTAssertionResult) {
XCTAssert.swift:85
    let result: _XCTAssertionResult
 {
0050        case Success
XCTAssert.swift:66
        case .Success:
XCTAssert.swift:93
    case .Success:
XCTAssert.swift:166
            return .Success
XCTAssert.swift:177
            return .Success
XCTAssert.swift:188
            return .Success
XCTAssert.swift:199
            return .Success
XCTAssert.swift:210
            return .Success
XCTAssert.swift:221
            return .Success
XCTAssert.swift:232
            return .Success
XCTAssert.swift:243
            return .Success
XCTAssert.swift:254
            return .Success
XCTAssert.swift:265
            return .Success
XCTAssert.swift:276
            return .Success
XCTAssert.swift:287
            return .Success
XCTAssert.swift:298
            return .Success
XCTAssert.swift:309
            return .Success
XCTAssert.swift:320
            return .Success
XCTAssert.swift:331
            return .Success
XCTAssert.swift:342
            return .Success
XCTAssert.swift:353
            return .Success
XCTAssert.swift:364
            return .Success
XCTAssert.swift:375
            return .Success
XCTAssert.swift:399
            return .Success

0051        case ExpectedFailure
XCTAssert.swift:68
        case .ExpectedFailure(let details?):
XCTAssert.swift:70
        case .ExpectedFailure(_):
XCTAssert.swift:168
            return .ExpectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\")")
XCTAssert.swift:179
            return .ExpectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\")")
XCTAssert.swift:190
            return .ExpectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\")")
XCTAssert.swift:201
            return .ExpectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\")")
XCTAssert.swift:212
            return .ExpectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\")")
XCTAssert.swift:223
            return .ExpectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\") +/- (\"\(accuracy)\")")
XCTAssert.swift:234
            return .ExpectedFailure(nil)
XCTAssert.swift:245
            return .ExpectedFailure("(\"\(value1)\") is not greater than (\"\(value2)\")")
XCTAssert.swift:256
            return .ExpectedFailure("(\"\(value1)\") is less than (\"\(value2)\")")
XCTAssert.swift:267
            return .ExpectedFailure("(\"\(value1)\") is not less than (\"\(value2)\")")
XCTAssert.swift:278
            return .ExpectedFailure("(\"\(value1)\") is greater than (\"\(value2)\")")
XCTAssert.swift:289
            return .ExpectedFailure("\"\(value!)\"")
XCTAssert.swift:300
            return .ExpectedFailure("(\"\(value1)\") is equal to (\"\(value2)\")")
XCTAssert.swift:311
            return .ExpectedFailure("(\"\(value1)\") is equal to (\"\(value2)\")")
XCTAssert.swift:322
            return .ExpectedFailure("(\"\(value1)\") is equal to (\"\(value2)\")")
XCTAssert.swift:333
            return .ExpectedFailure("(\"\(value1)\") is equal to (\"\(value2)\")")
XCTAssert.swift:344
            return .ExpectedFailure("(\"\(value1)\") is equal to (\"\(value2)\")")
XCTAssert.swift:355
            return .ExpectedFailure("(\"\(value1)\") is equal to (\"\(value2)\") +/- (\"\(accuracy)\")")
XCTAssert.swift:366
            return .ExpectedFailure(nil)
XCTAssert.swift:377
            return .ExpectedFailure(nil)
XCTAssert.swift:384
        return .ExpectedFailure(nil)
XCTAssert.swift:401
            return .ExpectedFailure("did not throw error")
(String?)
0052        case UnexpectedFailure
XCTAssert.swift:56
        case .UnexpectedFailure(_):
XCTAssert.swift:72
        case .UnexpectedFailure(let error):
XCTAssert.swift:89
        result = .UnexpectedFailure(error)
(ErrorType)
0053    
0054        var expected
XCTAssert.swift:98
            handler(XCTFailure(message: message(), failureDescription: result.failureDescription(assertion), expected: result.expected, file: file, line: line))
: Bool {
0055            switch (self) {
0056            case .UnexpectedFailure(_):
0057                return false
0058            default:
0059                return true
0060            }
0061        }
0062    
0063        func failureDescription
XCTAssert.swift:98
            handler(XCTFailure(message: message(), failureDescription: result.failureDescription(assertion), expected: result.expected, file: file, line: line))
(assertion: _XCTAssertion) -> String {
0064            let explanation: String
0065            switch (self) {
0066            case .Success:
0067                explanation = "passed"
0068            case .ExpectedFailure(let details?):
0069                explanation = "failed: \(details)"
0070            case .ExpectedFailure(_):
0071                explanation = "failed"
0072            case .UnexpectedFailure(let error):
0073                explanation = "threw error \"\(error)\""
0074            }
0075    
0076            if let name = assertion.name {
0077                return "\(name) \(explanation)"
0078            } else {
0079                return explanation
0080            }
0081        }
0082    }
0083    
0084    private func _XCTEvaluateAssertion
XCTAssert.swift:163
    _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
XCTAssert.swift:174
    _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
XCTAssert.swift:185
    _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
XCTAssert.swift:196
    _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
XCTAssert.swift:207
    _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
XCTAssert.swift:218
    _XCTEvaluateAssertion(.EqualWithAccuracy, message: message, file: file, line: line) {
XCTAssert.swift:229
    _XCTEvaluateAssertion(.False, message: message, file: file, line: line) {
XCTAssert.swift:240
    _XCTEvaluateAssertion(.GreaterThan, message: message, file: file, line: line) {
XCTAssert.swift:251
    _XCTEvaluateAssertion(.GreaterThanOrEqual, message: message, file: file, line: line) {
XCTAssert.swift:262
    _XCTEvaluateAssertion(.LessThan, message: message, file: file, line: line) {
XCTAssert.swift:273
    _XCTEvaluateAssertion(.LessThanOrEqual, message: message, file: file, line: line) {
XCTAssert.swift:284
    _XCTEvaluateAssertion(.Nil, message: message, file: file, line: line) {
XCTAssert.swift:295
    _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
XCTAssert.swift:306
    _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
XCTAssert.swift:317
    _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
XCTAssert.swift:328
    _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
XCTAssert.swift:339
    _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
XCTAssert.swift:350
    _XCTEvaluateAssertion(.NotEqualWithAccuracy, message: message, file: file, line: line) {
XCTAssert.swift:361
    _XCTEvaluateAssertion(.Nil, message: message, file: file, line: line) {
XCTAssert.swift:372
    _XCTEvaluateAssertion(.True, message: message, file: file, line: line) {
XCTAssert.swift:383
    _XCTEvaluateAssertion(.Fail, message: message, file: file, line: line) {
XCTAssert.swift:389
    _XCTEvaluateAssertion(.ThrowsError, message: message, file: file, line: line) {
(assertion: _XCTAssertion, @autoclosure message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__, @noescape expression: () throws -> _XCTAssertionResult) {
0085        let result: _XCTAssertionResult
0086        do {
0087            result = try expression()
0088        } catch {
0089            result = .UnexpectedFailure(error)
0090        }
0091    
0092        switch result {
0093        case .Success:
0094            return
0095    
0096        default:
0097            if let handler = XCTFailureHandler {
0098                handler(XCTFailure(message: message(), failureDescription: result.failureDescription(assertion), expected: result.expected, file: file, line: line))
0099            }
0100        }
0101    }
0102    
0103    /// This function emits a test failure if the general Bool expression passed
0104    /// to it evaluates to false.
0105    ///
0106    /// - Requires: This and all other XCTAssert* functions must be called from
0107    ///   within a test method, as indicated by `XCTestCaseProvider.allTests`.
0108    ///   Assertion failures that occur outside of a test method will *not* be
0109    ///   reported as failures.
0110    ///
0111    /// - Parameter expression: A boolean test. If it evaluates to false, the
0112    ///   assertion fails and emits a test failure.
0113    /// - Parameter message: An optional message to use in the failure if the
0114    ///   assertion fails. If no message is supplied a default message is used.
0115    /// - Parameter file: The file name to use in the error message if the assertion
0116    ///   fails. Default is the file containing the call to this function. It is
0117    ///   rare to provide this parameter when calling this function.
0118    /// - Parameter line: The line number to use in the error message if the
0119    ///   assertion fails. Default is the line number of the call to this function
0120    ///   in the calling file. It is rare to provide this parameter when calling
0121    ///   this function.
0122    ///
0123    /// - Note: It is rare to provide the `file` and `line` parameters when calling
0124    ///   this function, although you may consider doing so when creating your own
0125    ///   assertion functions. For example, consider the following custom assertion:
0126    ///
0127    ///   ```
0128    ///   // AssertEmpty.swift
0129    ///
0130    ///   func AssertEmpty<T>(elements: [T]) {
0131    ///       XCTAssertEqual(elements.count, 0, "Array is not empty")
0132    ///   }
0133    ///   ```
0134    ///
0135    ///  Calling this assertion will cause XCTest to report the failure occured
0136    ///  in the file where `AssertEmpty()` is defined, and on the line where
0137    ///  `XCTAssertEqual` is called from within that function:
0138    ///
0139    ///  ```
0140    ///  // MyFile.swift
0141    ///
0142    ///  AssertEmpty([1, 2, 3]) // Emits "AssertEmpty.swift:3: error: ..."
0143    ///  ```
0144    ///
0145    ///  To have XCTest properly report the file and line where the assertion
0146    ///  failed, you may specify the file and line yourself:
0147    ///
0148    ///  ```
0149    ///  // AssertEmpty.swift
0150    ///
0151    ///  func AssertEmpty<T>(elements: [T], file: StaticString = __FILE__, line: UInt = __LINE__) {
0152    ///      XCTAssertEqual(elements.count, 0, "Array is not empty", file: file, line: line)
0153    ///  }
0154    ///  ```
0155    ///
0156    ///  Now calling failures in `AssertEmpty` will be reported in the file and on
0157    ///  the line that the assert function is *called*, not where it is defined.
0158    public func XCTAssert(@autoclosure expression: () throws -> BooleanType, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0159        XCTAssertTrue(expression, message, file: file, line: line)
0160    }
0161    
0162    public func XCTAssertEqual<T: Equatable>(@autoclosure expression1: () throws -> T?, @autoclosure _ expression2: () throws -> T?, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0163        _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
0164            let (value1, value2) = (try expression1(), try expression2())
0165            if value1 == value2 {
0166                return .Success
0167            } else {
0168                return .ExpectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\")")
0169            }
0170        }
0171    }
0172    
0173    public func XCTAssertEqual<T: Equatable>(@autoclosure expression1: () throws -> ArraySlice<T>, @autoclosure _ expression2: () throws -> ArraySlice<T>, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0174        _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
0175            let (value1, value2) = (try expression1(), try expression2())
0176            if value1 == value2 {
0177                return .Success
0178            } else {
0179                return .ExpectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\")")
0180            }
0181        }
0182    }
0183    
0184    public func XCTAssertEqual<T: Equatable>(@autoclosure expression1: () throws -> ContiguousArray<T>, @autoclosure _ expression2: () throws -> ContiguousArray<T>, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0185        _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
0186            let (value1, value2) = (try expression1(), try expression2())
0187            if value1 == value2 {
0188                return .Success
0189            } else {
0190                return .ExpectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\")")
0191            }
0192        }
0193    }
0194    
0195    public func XCTAssertEqual<T: Equatable>(@autoclosure expression1: () throws -> [T], @autoclosure _ expression2: () throws -> [T], @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0196        _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
0197            let (value1, value2) = (try expression1(), try expression2())
0198            if value1 == value2 {
0199                return .Success
0200            } else {
0201                return .ExpectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\")")
0202            }
0203        }
0204    }
0205    
0206    public func XCTAssertEqual<T, U: Equatable>(@autoclosure expression1: () throws -> [T: U], @autoclosure _ expression2: () throws -> [T: U], @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0207        _XCTEvaluateAssertion(.Equal, message: message, file: file, line: line) {
0208            let (value1, value2) = (try expression1(), try expression2())
0209            if value1 == value2 {
0210                return .Success
0211            } else {
0212                return .ExpectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\")")
0213            }
0214        }
0215    }
0216    
0217    public func XCTAssertEqualWithAccuracy<T: FloatingPointType>(@autoclosure expression1: () throws -> T, @autoclosure _ expression2: () throws -> T, accuracy: T, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0218        _XCTEvaluateAssertion(.EqualWithAccuracy, message: message, file: file, line: line) {
0219            let (value1, value2) = (try expression1(), try expression2())
0220            if abs(value1.distanceTo(value2)) <= abs(accuracy.distanceTo(T(0))) {
0221                return .Success
0222            } else {
0223                return .ExpectedFailure("(\"\(value1)\") is not equal to (\"\(value2)\") +/- (\"\(accuracy)\")")
0224            }
0225        }
0226    }
0227    
0228    public func XCTAssertFalse(@autoclosure expression: () throws -> BooleanType, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0229        _XCTEvaluateAssertion(.False, message: message, file: file, line: line) {
0230            let value = try expression()
0231            if !value.boolValue {
0232                return .Success
0233            } else {
0234                return .ExpectedFailure(nil)
0235            }
0236        }
0237    }
0238    
0239    public func XCTAssertGreaterThan<T: Comparable>(@autoclosure expression1: () throws -> T, @autoclosure _ expression2: () throws -> T, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0240        _XCTEvaluateAssertion(.GreaterThan, message: message, file: file, line: line) {
0241            let (value1, value2) = (try expression1(), try expression2())
0242            if value1 > value2 {
0243                return .Success
0244            } else {
0245                return .ExpectedFailure("(\"\(value1)\") is not greater than (\"\(value2)\")")
0246            }
0247        }
0248    }
0249    
0250    public func XCTAssertGreaterThanOrEqual<T: Comparable>(@autoclosure expression1: () throws -> T, @autoclosure _ expression2: () throws -> T, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0251        _XCTEvaluateAssertion(.GreaterThanOrEqual, message: message, file: file, line: line) {
0252            let (value1, value2) = (try expression1(), try expression2())
0253            if value1 >= value2 {
0254                return .Success
0255            } else {
0256                return .ExpectedFailure("(\"\(value1)\") is less than (\"\(value2)\")")
0257            }
0258        }
0259    }
0260    
0261    public func XCTAssertLessThan<T: Comparable>(@autoclosure expression1: () throws -> T, @autoclosure _ expression2: () throws -> T, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0262        _XCTEvaluateAssertion(.LessThan, message: message, file: file, line: line) {
0263            let (value1, value2) = (try expression1(), try expression2())
0264            if value1 < value2 {
0265                return .Success
0266            } else {
0267                return .ExpectedFailure("(\"\(value1)\") is not less than (\"\(value2)\")")
0268            }
0269        }
0270    }
0271    
0272    public func XCTAssertLessThanOrEqual<T: Comparable>(@autoclosure expression1: () throws -> T, @autoclosure _ expression2: () throws -> T, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0273        _XCTEvaluateAssertion(.LessThanOrEqual, message: message, file: file, line: line) {
0274            let (value1, value2) = (try expression1(), try expression2())
0275            if value1 <= value2 {
0276                return .Success
0277            } else {
0278                return .ExpectedFailure("(\"\(value1)\") is greater than (\"\(value2)\")")
0279            }
0280        }
0281    }
0282    
0283    public func XCTAssertNil(@autoclosure expression: () throws -> Any?, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0284        _XCTEvaluateAssertion(.Nil, message: message, file: file, line: line) {
0285            let value = try expression()
0286            if value == nil {
0287                return .Success
0288            } else {
0289                return .ExpectedFailure("\"\(value!)\"")
0290            }
0291        }
0292    }
0293    
0294    public func XCTAssertNotEqual<T: Equatable>(@autoclosure expression1: () throws -> T?, @autoclosure _ expression2: () throws -> T?, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0295        _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
0296            let (value1, value2) = (try expression1(), try expression2())
0297            if value1 != value2 {
0298                return .Success
0299            } else {
0300                return .ExpectedFailure("(\"\(value1)\") is equal to (\"\(value2)\")")
0301            }
0302        }
0303    }
0304    
0305    public func XCTAssertNotEqual<T: Equatable>(@autoclosure expression1: () throws -> ContiguousArray<T>, @autoclosure _ expression2: () throws -> ContiguousArray<T>, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0306        _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
0307            let (value1, value2) = (try expression1(), try expression2())
0308            if value1 != value2 {
0309                return .Success
0310            } else {
0311                return .ExpectedFailure("(\"\(value1)\") is equal to (\"\(value2)\")")
0312            }
0313        }
0314    }
0315    
0316    public func XCTAssertNotEqual<T: Equatable>(@autoclosure expression1: () throws -> ArraySlice<T>, @autoclosure _ expression2: () throws -> ArraySlice<T>, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0317        _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
0318            let (value1, value2) = (try expression1(), try expression2())
0319            if value1 != value2 {
0320                return .Success
0321            } else {
0322                return .ExpectedFailure("(\"\(value1)\") is equal to (\"\(value2)\")")
0323            }
0324        }
0325    }
0326    
0327    public func XCTAssertNotEqual<T: Equatable>(@autoclosure expression1: () throws -> [T], @autoclosure _ expression2: () throws -> [T], @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0328        _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
0329            let (value1, value2) = (try expression1(), try expression2())
0330            if value1 != value2 {
0331                return .Success
0332            } else {
0333                return .ExpectedFailure("(\"\(value1)\") is equal to (\"\(value2)\")")
0334            }
0335        }
0336    }
0337    
0338    public func XCTAssertNotEqual<T, U: Equatable>(@autoclosure expression1: () throws -> [T: U], @autoclosure _ expression2: () throws -> [T: U], @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0339        _XCTEvaluateAssertion(.NotEqual, message: message, file: file, line: line) {
0340            let (value1, value2) = (try expression1(), try expression2())
0341            if value1 != value2 {
0342                return .Success
0343            } else {
0344                return .ExpectedFailure("(\"\(value1)\") is equal to (\"\(value2)\")")
0345            }
0346        }
0347    }
0348    
0349    public func XCTAssertNotEqualWithAccuracy<T: FloatingPointType>(@autoclosure expression1: () throws -> T, @autoclosure _ expression2: () throws -> T, _ accuracy: T, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0350        _XCTEvaluateAssertion(.NotEqualWithAccuracy, message: message, file: file, line: line) {
0351            let (value1, value2) = (try expression1(), try expression2())
0352            if abs(value1.distanceTo(value2)) > abs(accuracy.distanceTo(T(0))) {
0353                return .Success
0354            } else {
0355                return .ExpectedFailure("(\"\(value1)\") is equal to (\"\(value2)\") +/- (\"\(accuracy)\")")
0356            }
0357        }
0358    }
0359    
0360    public func XCTAssertNotNil(@autoclosure expression: () throws -> Any?, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0361        _XCTEvaluateAssertion(.Nil, message: message, file: file, line: line) {
0362            let value = try expression()
0363            if value != nil {
0364                return .Success
0365            } else {
0366                return .ExpectedFailure(nil)
0367            }
0368        }
0369    }
0370    
0371    public func XCTAssertTrue
XCTAssert.swift:159
    XCTAssertTrue(expression, message, file: file, line: line)
(@autoclosure expression: () throws -> BooleanType, @autoclosure _ message: () -> String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0372        _XCTEvaluateAssertion(.True, message: message, file: file, line: line) {
0373            let value = try expression()
0374            if value.boolValue {
0375                return .Success
0376            } else {
0377                return .ExpectedFailure(nil)
0378            }
0379        }
0380    }
0381    
0382    public func XCTFail(message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__) {
0383        _XCTEvaluateAssertion(.Fail, message: message, file: file, line: line) {
0384            return .ExpectedFailure(nil)
0385        }
0386    }
0387    
0388    public func XCTAssertThrowsError<T>(@autoclosure expression: () throws -> T, _ message: String = "", file: StaticString = __FILE__, line: UInt = __LINE__, _ errorHandler: (error: ErrorType) -> Void = { _ in }) {
0389        _XCTEvaluateAssertion(.ThrowsError, message: message, file: file, line: line) {
0390            var caughtErrorOptional: ErrorType?
0391            do {
0392                _ = try expression()
0393            } catch {
0394                caughtErrorOptional = error
0395            }
0396    
0397            if let caughtError = caughtErrorOptional {
0398                errorHandler(error: caughtError)
0399                return .Success
0400            } else {
0401                return .ExpectedFailure("did not throw error")
0402            }
0403        }
0404    }
0405