看代码:

func catchBadInstruction(block: () -> ()) -> BadInstructionException? {
    var context = exceptionContext()
    var result: BadInstructionException? = nil
    do {
        var handlerThread: pthread_t = nil
        defer {
            // 8. Wait for the thread to terminate *if* we actually made it to the creation point
            // The mach port should be destroyed *before* calling pthread_join to avoid a deadlock.
            if handlerThread != nil {
                pthread_join(handlerThread,nil)
            }
        }

        try kernCheck {
            // 1. Create the mach port
            mach_port_allocate(mach_task_self_,MACH_PORT_RIGHT_RECEIVE,&context.currentExceptionPort)
        }
        defer {
            // 7. Cleanup the mach port
            mach_port_destroy(mach_task_self_,context.currentExceptionPort)
        }

        try kernCheck {
            // 2. Configure the mach port
            mach_port_insert_right(mach_task_self_,context.currentExceptionPort,MACH_MSG_TYPE_MAKE_SEND)
        }

        try kernCheck { withUnsafeMutablePointers(&context.masks,&context.ports,&context.behaviors) {
            (m,p,b) in withUnsafeMutablePointer(&context.flavors) {
            // 3. Apply the mach port as the handler for this thread
            thread_swap_exception_ports(mach_thread_self(),EXC_MASK_BAD_INSTRUCTION,Int32(bitPattern: UInt32(EXCEPTION_STATE) |
                MACH_EXCEPTION_CODES),x86_THREAD_STATE64,UnsafeMutablePointer<exception_mask_t>(m),&context.count,UnsafeMutablePointer<mach_port_t>(p),UnsafeMutablePointer<exception_behavior_t>(b),UnsafeMutablePointer<thread_state_flavor_t>($0))
        } } }
        defer { withUnsafeMutablePointers(&context.masks,b) in withUnsafeMutablePointer(&context.flavors) {
            // 6. Unapply the mach port
            thread_swap_exception_ports(mach_thread_self(),0,EXCEPTION_DEFAULT,THREAD_STATE_NONE,UnsafeMutablePointer<thread_state_flavor_t>($0))
        } } }

        try withUnsafeMutablePointer(&context) { c throws in
            // 4. Create the thread
            guard pthread_create(&handlerThread,nil,machMessageHandler,c) == 0 else {
                throw PthreadError.Any
            }

            // 5. Run the block
            result = BadInstructionException.catchException(block)
        }
    } catch {
        // Should never be reached but this is testing code,don't try to recover,just abort
        fatalError("Mach port error: \(error)")
    }
    return result
}

kernCheck 函数是一个自定义函数，用于读取 Mach 函数的返回码，如果它没有错误的话，将返回结果转换成一个 Swift ErrorType 抛出。它相当于某种宏，用于转换 C 中的错误类型。

catchBadInstruction 函数负责完成除了 machMessageHandler 函数（用第 4 步的 pthread_create 方法调用）之外的所有事情。machMessageHandler 则负责监视和等待接收某个 Mach 消息。它的代码如下：

private func machMessageHandler(arg: UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void> {
    let context = UnsafeMutablePointer<ExceptionContext>(arg).memory
    var request = request_mach_exception_raise_t()
    var reply = reply_mach_exception_raise_state_t()

    do {
        // Request the next mach message from the port
        request.Head.msgh_local_port = context.currentExceptionPort
        request.Head.msgh_size = UInt32(sizeofValue(request))
        try kernCheck { withUnsafeMutablePointer(&request) {
            mach_msg(UnsafeMutablePointer<mach_msg_header_t>($0),MACH_RCV_MSG | MACH_RCV_INTERRUPT,request.Head.msgh_size,UInt32(MACH_PORT_NULL))
        } }

        // Prepare the reply structure
        reply.Head.msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(request.Head.msgh_bits),0)
        reply.Head.msgh_local_port = UInt32(MACH_PORT_NULL)
        reply.Head.msgh_remote_port = request.Head.msgh_remote_port
        reply.Head.msgh_size = UInt32(sizeofValue(reply))
        reply.NDR = NDR_record

        // Use the MiG generated server to invoke our handler for the request and fill in
        // the rest of the reply structure
        guard withUnsafeMutablePointers(&request,&reply,{
            mach_exc_server(UnsafeMutablePointer<mach_msg_header_t>($0),UnsafeMutablePointer<mach_msg_header_t>($1))
        }) != 0 else { throw MachExcServer.Any }

        // Send the reply
        try kernCheck { withUnsafeMutablePointer(&reply) {
            mach_msg(UnsafeMutablePointer<mach_msg_header_t>($0),MACH_SEND_MSG,reply.Head.msgh_size,UInt32(MACH_PORT_NULL),UInt32(MACH_PORT_NULL))
        } }
    } catch let error as NSError where (error.domain == NSMachErrorDomain && (error.code ==
        Int(MACH_RCV_PORT_CHANGED) || error.code == Int(MACH_RCV_INVALID_NAME))) {
        // Port was already closed before we started or closed while we were listening.
        // This means the block completed without raising an EXC_BAD_INSTRUCTION. Not a problem.
    } catch {
        // Should never be reached but this is testing code,just abort
        fatalError("Mach message error: \(error)")
    }

    return nil
}

用法

项目代码位于 github：mattgallagher/CwlPreconditionTesting。

Readme.md 文件中描述了使用方式，简化步骤为：

1. git clone https://github.com/mattgallagher/CwlPreconditionTesting.git

2. 将 “CwlPreconditionTesting.xcodeproj” 文件拖到你的 Xcode 项目文件树中

3. 打开测试目标的 Build Phase settings，找到”Target Dependencies“，点”+“按钮，然后选择对应的 “CwlPreconditionTesting” 目标 (根据你的测试目标所用的 SDK 比如 “_iOS” 或者 “_OSX”进行选择)
4. 在要使用catchBadInstruction 函数进行测试的文件的顶部 import CwlPreconditionTesting (当你这样做的时候 Swift 会自动连接)
5. 用 CwlCatchBadInstructionTests.swift 中的 catchBadInstruction 对文件进行测试

结论

CwlPreconditionTesting.catchBadInstruction 能够捕获 Swift 的 precondition 前置条件断言失败，因此我们能够准确地测试不完全函数。我想本文介绍的 Mach 异常处理器应该是有史以来包含 Swift 代码比例最高的 Mach 异常处理器了（我甚至怀疑不会有多少 Swift 写的 Mach 异常处理器）。

本文是“重返 Cocoa with Love，截然不同的选择”三部曲的最终章：

第一部: 再见，骇客。Cocoa with Love
第二部: 不要使用不完全函数
第三步: 用骇客技术测试不完全函数

这里，如果我们忽略本文上下文中的不同问题域（App 的实现、API 设计和测试）的话，这看起来似乎有点自相矛盾，当然这我的一个小玩笑。因为我们可以跨过这三个问题域使用 Swift、Xcode 和别的工具，我们极易忘记它们之间的差异。但这并不表示它们是相同的。在测试代码中正确的东西在发布版 App 确是错误的——反之亦然。

App 需要解决的是用户不确定和持续的改变。API 需要的是高效和可重用性。对测试，没有什么严格的限制，只要我们的测试易于编写，易于阅读和全面，别的都不重要。