         // if you specified the write type as `.withResponse`.
         let writeType: CBCharacteristicWriteType = operation.withResponse ? .withResponse : .withoutResponse
         peripheralObject.writeValue(operation.data, for: characteristicObject, type: writeType)
-        return operation.withResponse
+        guard operation.withResponse else {
+            operation.continuation.resume()
+            return false
+        }
+        return true
     }
     
     func execute(_ operation: Operation.DiscoverDescriptors) {

            }
            
            let peripheral = Peripheral(corePeripheral)
            guard let continuation = self.central.continuation.discoverServices[peripheral] else {
                assertionFailure("Missing continuation")
                return
            }
            if let error = error {
                continuation.resume(throwing: error)
            } else {
                let serviceObjects = corePeripheral.services ?? []
                let services = serviceObjects.map { serviceObject in
                    Service(
                        service: serviceObject,
                        peripheral: corePeripheral
                    )
                }
                for (index, service) in services.enumerated() {
                    self.central.cache.services[service] = serviceObjects[index]
                }
                continuation.resume(returning: services)
            }
            // remove callback
            self.central.continuation.discoverServices[peripheral] = nil
        }
        
        @objc(peripheral:didDiscoverCharacteristicsForService:error:)

        case writeDescriptor(WriteDescriptor)
        case isReadyToWriteWithoutResponse(WriteWithoutResponseReady)
        case setNotification(NotificationState)
    }
}

internal extension DarwinCentral.Operation {
    
    func resume(throwing error: Swift.Error) {
        switch self {
        case let .connect(operation):
            operation.continuation.resume(throwing: error)
        case let .discoverServices(operation):
            operation.continuation.resume(throwing: error)
        case let .discoverIncludedServices(operation):
            operation.continuation.resume(throwing: error)
        case let .discoverCharacteristics(operation):
            operation.continuation.resume(throwing: error)
        case let .writeCharacteristic(operation):
            operation.continuation.resume(throwing: error)
        case let .readCharacteristic(operation):
            operation.continuation.resume(throwing: error)
        case let .discoverDescriptors(operation):
            operation.continuation.resume(throwing: error)
        case let .readDescriptor(operation):
            operation.continuation.resume(throwing: error)
        case let .writeDescriptor(operation):
            operation.continuation.resume(throwing: error)
        case let .isReadyToWriteWithoutResponse(operation):
            operation.continuation.resume(throwing: error)
        case let .setNotification(operation):
            operation.continuation.resume(throwing: error)
        }
    }
}

