Simple `AssertThrows` and `AssertNoThrow` for unit testing using XCTest in Swift

AssertThrows.swift

public func AssertThrowsSpecific<E:ErrorType>(@autoclosure expression: () throws -> Void, expectedError: E, _ message: String = "", file: String = __FILE__, line: UInt = __LINE__) {
    do {
        try expression()
        FailAssertion(__FUNCTION__, message, file, line)
    } catch let caughtError {
        guard caughtError is E else {
            FailAssertion(__FUNCTION__, message, file, line)
            return
        }
    }
}

public func AssertThrowsSpecific<E where E: ErrorType, E: Equatable>(@autoclosure expression: () throws -> Void, expectedError: E, _ message: String = "", file: String = __FILE__, line: UInt = __LINE__) {
    do {
        try expression()
        FailAssertion(__FUNCTION__, message, file, line)
    } catch let caughtError as E {
        if caughtError != expectedError {
            FailAssertion(__FUNCTION__, message, file, line)
        }
    } catch {
        FailAssertion(__FUNCTION__, message, file, line)
    }
}

public func AssertThrowsSpecific<E: NSError>(@autoclosure expression: () throws -> Void, expectedError: E, _ message: String = "", file: String = __FILE__, line: UInt = __LINE__) {
    do {
        try expression()
        FailAssertion(__FUNCTION__, message, file, line)
    } catch let caughtError as E {
        if !caughtError.isEqual(expectedError)  {
            FailAssertion(__FUNCTION__, message, file, line)
        }
    } catch {
        FailAssertion(__FUNCTION__, message, file, line)
    }
}

public func AssertNoThrowSpecific<E:ErrorType>(@autoclosure expression: () throws -> Void, expectedError: E, _ message: String = "", file: String = __FILE__, line: UInt = __LINE__) {
    do {
        try expression()
        FailAssertion(__FUNCTION__, message, file, line)
    } catch let caughtError {
        guard caughtError is E else {
            FailAssertion(__FUNCTION__, message, file, line)
            return
        }
    }
}

public func AssertNoThrowSpecific<E where E: ErrorType, E: Equatable>(@autoclosure expression: () throws -> Void, expectedError: E, _ message: String = "", file: String = __FILE__, line: UInt = __LINE__) {
    do {
        try expression()
    } catch let caughtError as E {
        if caughtError == expectedError {
            FailAssertion(__FUNCTION__, message, file, line)
        }
    } catch {}
}

public func AssertNoThrowSpecific<E: NSError>(@autoclosure expression: () throws -> Void, expectedError: E, _ message: String = "", file: String = __FILE__, line: UInt = __LINE__) {
    do {
        try expression()
    } catch let caughtError as E {
        if caughtError.isEqual(expectedError)  {
            FailAssertion(__FUNCTION__, message, file, line)
        }
    } catch {}
}

public func AssertThrows(@autoclosure expression: () throws -> Void, _ message: String = "", file: String = __FILE__, line: UInt = __LINE__) {
    if let _ = try? expression() {
        FailAssertion(__FUNCTION__, message, file, line)
    }
}

public func AssertNoThrow(@autoclosure expression: () throws -> Void, _ message: String = "", file: String = __FILE__, line: UInt = __LINE__) {
    guard let _ = try? expression() else {
        FailAssertion(__FUNCTION__, message, file, line)
        return
    }
}

internal func FailAssertion(function: String, _ message: String = "", _ file: String = __FILE__, _ line: UInt = __LINE__) {
    XCTFail("\(function) failed: \(message)", file: file, line: line)
}

For example:

//Test that I can save this CoreData entity
AssertNoThrow(try entity.managedObjectContext.save(), "Save failed for \(entity)")

Also added some extras for specific errors. Had to make 3 versions, one for just matching the specific ErrorType, one for matching the ErrorType if it implements Equatable and one specifically for NSError because it's a bastard.