import Foundation // QFT iOS 核心层测试。刻意不依赖 XCTest:这样在只有 Command Line Tools、 // 没有 Xcode 的机器上也能 `swiftc` 直接编译运行,CI 与本地一致。 // // 集成测试跑在 MockPCServer.py 上,该 mock 严格复刻 receiver.rs / sender.rs // 的线上语义,因此这里通过 == 线格式与 Windows 端兼容。 // 输出重定向到文件/管道时 stdout 默认是块缓冲的,一旦中途 trap 就什么都看不到, // 排查成本极高。改成行缓冲。 setvbuf(stdout, nil, _IOLBF, 0) var failures = 0 var checks = 0 func check(_ condition: Bool, _ message: String) { checks += 1 if condition { print(" ok \(message)") } else { failures += 1 print(" FAIL \(message)") } } func checkEqual(_ actual: T, _ expected: T, _ message: String) { check(actual == expected, "\(message)(实得 \(actual))") } func section(_ title: String) { print("\n== \(title) ==") } // ---------------------------------------------------------------- Base64URL section("Base64URL") checkEqual(Base64URL.encode("QFT"), "UUZU", "编码无填充") checkEqual(Base64URL.decodeString("UUZU"), "QFT", "解码往返") check(Base64URL.decode("a+b/c") == nil, "拒绝标准 Base64 字母表") check(Base64URL.decode("A") == nil, "拒绝不可能的长度") checkEqual(Base64URL.encode(Data([0xfb, 0xff])), "-_8", "- 与 _ 替换正确") checkEqual(Base64URL.decode("-_8"), Data([0xfb, 0xff]), "- 与 _ 解码正确") for _ in 0..<200 { let raw = Data((0.. String { let data = try! JSONSerialization.data(withJSONObject: object) return prefix + Base64URL.encode(data) } let session = "abcdefghijklmnopqrstuvwxyz012345" let uploadText = makePairingText(prefix: "QFTPAIR2:", [ "v": 2, "s": session, "n": "DESKTOP-QFT", "p": 39393, "e": ["http://192.168.1.20:39393"], ]) let upload = PairingProtocol.parse(uploadText) check(upload != nil, "解析 QFTPAIR2") checkEqual(upload?.direction, .uploadToPC, "方向为上传") checkEqual(upload?.session, session, "会话令牌") checkEqual(upload?.port, 39393, "端口") checkEqual(upload?.pcName, "DESKTOP-QFT", "电脑名") checkEqual(upload?.endpoints.count, 1, "端点数量") let downloadText = makePairingText(prefix: "QFTSEND2:", [ "v": 2, "s": session, "n": "DESKTOP-QFT", "p": 39393, "e": ["http://10.0.0.5:39393"], "d": "d", "f": "报告.pdf", "z": 1_234_567, "h": String(repeating: "ab", count: 32), ]) let download = PairingProtocol.parse(downloadText) check(download != nil, "解析 QFTSEND2") checkEqual(download?.direction, .downloadToPhone, "方向为下载") checkEqual(download?.fileName, "报告.pdf", "文件名支持中文") checkEqual(download?.fileSize, 1_234_567, "文件大小") check(PairingProtocol.parse("QFTPAIR2:" + Base64URL.encode( try! JSONSerialization.data(withJSONObject: [ "v": 2, "s": session, "p": 39393, "e": ["http://192.168.1.20:39393"], "d": "d", ]))) == nil, "前缀与方向不符时拒绝") check(PairingProtocol.parse(makePairingText(prefix: "QFTSEND2:", [ "v": 2, "s": session, "p": 39393, "e": ["http://10.0.0.5:39393"], "d": "d", "f": "x.bin", "z": 1, "h": "not-a-hash", ])) == nil, "SHA-256 格式错误时拒绝") check(PairingProtocol.parse(makePairingText(prefix: "QFTPAIR2:", [ "v": 1, "s": session, "p": 39393, "e": ["http://192.168.1.20:39393"], ])) == nil, "版本号不是 2 时拒绝") check(PairingProtocol.parse(makePairingText(prefix: "QFTPAIR2:", [ "v": 2, "s": "short", "p": 39393, "e": ["http://192.168.1.20:39393"], ])) == nil, "会话令牌过短时拒绝") // ---------------------------------------------------------------- 端点白名单 section("端点白名单(二维码是不可信输入)") let allowed = [ "http://192.168.1.1:39393", "http://10.1.2.3:39393", "http://172.16.0.1:39393", "http://172.31.255.254:39393", "http://127.0.0.1:39393", "http://169.254.1.2:39393", ] for endpoint in allowed { check(PairingProtocol.isAllowedLocalHTTPEndpoint(endpoint, expectedPort: 39393), "接受 \(endpoint)") } let rejected = [ "https://192.168.1.1:39393", // 只允许 http "http://evil.com:39393", // 域名 "http://8.8.8.8:39393", // 公网 "http://172.32.0.1:39393", // 172 段边界外 "http://192.168.1.1:1234", // 端口不符 "http://user@192.168.1.1:39393", // 带凭据 "http://192.168.1.1:39393/path", // 带路径 "http://192.168.1.1:39393?a=b", // 带 query "http://192.168.01.1:39393", // 非规范八位组 "http://192.168.1:39393", // 段数不足 "http://[::1]:39393", // IPv6 ] for endpoint in rejected { check(!PairingProtocol.isAllowedLocalHTTPEndpoint(endpoint, expectedPort: 39393), "拒绝 \(endpoint)") } // ---------------------------------------------------------------- 本地网络 section("本机网络推导") checkEqual(LocalNetwork.ipv4("192.168.1.20"), 0xC0A80114, "IPv4 转整数") checkEqual(LocalNetwork.format(0xC0A80114), "192.168.1.20", "整数转 IPv4") check(LocalNetwork.ipv4("192.168.1.256") == nil, "拒绝越界八位组") // iOS SDK 不导出 net/route.h,路由表报文只能按手写偏移解析。 // macOS SDK 有真类型,在这里逐字段交叉校验——布局一旦变了立刻红。 typealias RM = LocalNetwork.RouteMessage checkEqual(RM.headerSize, MemoryLayout.size, "rt_msghdr 大小") checkEqual(RM.messageLengthOffset, MemoryLayout.offset(of: \.rtm_msglen), "rtm_msglen 偏移") checkEqual(RM.versionOffset, MemoryLayout.offset(of: \.rtm_version), "rtm_version 偏移") checkEqual(RM.interfaceIndexOffset, MemoryLayout.offset(of: \.rtm_index), "rtm_index 偏移") checkEqual(RM.addressMaskOffset, MemoryLayout.offset(of: \.rtm_addrs), "rtm_addrs 偏移") checkEqual(Int32(RM.version), Int32(RTM_VERSION), "RTM_VERSION") checkEqual(RM.gatewayFlag, Int32(RTF_GATEWAY), "RTF_GATEWAY") checkEqual(RM.addressSlots, Int(RTAX_MAX), "RTAX_MAX") checkEqual(RM.destinationSlot, Int(RTAX_DST), "RTAX_DST") checkEqual(RM.gatewaySlot, Int(RTAX_GATEWAY), "RTAX_GATEWAY") // 路由表读的是本机真实状态,不能断言具体内容,但**必须**保证: // 不崩、且返回的东西全部是私有 IPv4——它会被直接当成电脑地址去连。 let gateways = LocalNetwork.defaultGateways() check(gateways.allSatisfy(PairingProtocol.isPrivateIPv4), "默认网关全部是私有 IPv4(读到 \(gateways.count) 个)") check(LocalNetwork.directedBroadcastAddresses().allSatisfy { $0.split(separator: ".").count == 4 }, "定向广播地址格式正确") let candidates = LocalNetwork.hostCandidates(port: 39393, limit: 8) check(candidates.allSatisfy { PairingProtocol.isAllowedLocalHTTPEndpoint($0, expectedPort: 39393) }, "候选地址全部过端点白名单") check(Set(candidates).count == candidates.count, "候选地址无重复") // ---------------------------------------------------------------- 专用网络 section("专用网络(Windows QFT Direct)") let directText = makePairingText(prefix: "QFTPAIR2:", [ "v": 2, "s": session, "n": "DESKTOP-QFT", "p": 39393, "e": [], "w": ["QFT-PC-abc123", "0123456789abcdef"], ]) let direct = PairingProtocol.parse(directText) check(direct != nil, "接受只带 Wi-Fi 凭据、不带地址的专用网络二维码") checkEqual(direct?.wifi, WifiCredentials(ssid: "QFT-PC-abc123", passphrase: "0123456789abcdef"), "Wi-Fi 凭据") check(direct?.endpoints.isEmpty == true, "专用网络二维码不带任何电脑地址") check(PairingProtocol.parse(makePairingText(prefix: "QFTPAIR2:", [ "v": 2, "s": session, "p": 39393, "e": [], ])) == nil, "既无地址又无 Wi-Fi 时拒绝") check(PairingProtocol.parse(makePairingText(prefix: "QFTPAIR2:", [ "v": 2, "s": session, "p": 39393, "e": [], "w": ["QFT-PC", "short"], ])) == nil, "Wi-Fi 密码过短时拒绝") let lanPairing = PairingPayload(version: 2, session: session, pcName: "MAC", port: 39393, endpoints: ["http://192.168.1.9:39393"], wifi: nil, direction: .uploadToPC, fileName: nil, fileSize: nil, sha256: nil) checkEqual(DedicatedNetworkPlan.plan(for: lanPairing, canJoinProgrammatically: true), .useEndpoints(["http://192.168.1.9:39393"]), "有地址时直接连,不去动 Wi-Fi") checkEqual(DedicatedNetworkPlan.plan(for: direct!, canJoinProgrammatically: true), .joinWifi(direct!.wifi!), "有能力时自动加入专用 Wi-Fi") checkEqual(DedicatedNetworkPlan.plan(for: direct!, canJoinProgrammatically: false), .manualJoin(direct!.wifi!), "没有 entitlement 时转为手动加入引导,而不是假装成功") // ---------------------------------------------------------------- Base45 section("Base45(与 desktop/src/base45.rs 同一组向量)") checkEqual(Base45.encode(Data("AB".utf8)), "BB8", "编码 AB") checkEqual(Base45.encode(Data("Hello!!".utf8)), "%69 VD92EX0", "编码 Hello!!") checkEqual(Base45.encode(Data("base-45".utf8)), "UJCLQE7W581", "编码 base-45") checkEqual(Base45.decode("BB8"), Data("AB".utf8), "解码 BB8") checkEqual(Base45.decode("%69 VD92EX0"), Data("Hello!!".utf8), "解码 Hello!!") checkEqual(Base45.decode("K1"), Data([0x41]), "两字符尾块解出单字节") check(Base45.decode("AB") == nil, "两字符尾块超过 0xFF 时拒绝(A+B*45=505)") check(Base45.decode("A") == nil, "长度 %3==1 时拒绝") check(Base45.decode("ab") == nil, "小写不在字母表内,拒绝") check(Base45.decode("::::::") == nil, "超过 0xFFFF 的三元组拒绝") var base45RoundTripOK = true for _ in 0..<200 { let raw = Data((0.. (OpticalManifest, [String]) { let total = payload.isEmpty ? 0 : UInt32((payload.count + chunkSize - 1) / chunkSize) let manifest = OpticalManifest( sessionID: sessionID, senderDevice: "DESKTOP-QFT", fileName: name, fileSize: UInt64(payload.count), chunkSize: chunkSize, totalChunks: total, sha256: Data(hexString: sha256Hex(payload))!) var frames = [OpticalProtocol.text(for: OpticalProtocol.encodeManifest(manifest))] for index in 0.. 0, "重复帧被识别为 duplicate(\(duplicates) 帧),不会重复计入吞吐") checkEqual(accepted, Int(opticalManifest.totalChunks) + 1, "有效新帧数 = 数据片数 + 清单") check(opticalProgressSeen == Int(opticalManifest.totalChunks), "进度回调走到最后一片") if let opticalSaved { let data = try! Data(contentsOf: opticalSaved) checkEqual(sha256Hex(data), sha256Hex(opticalPayload), "落盘内容 SHA-256 一致") checkEqual(opticalSaved.lastPathComponent, "报告.pdf", "落盘文件名正确") } // 摘要对不上时必须整份丢弃,绝不把半份文件交给用户 var tamperedError: String? let tamperedAssembler = OpticalAssembler( destinationDirectory: opticalRoot.appendingPathComponent("bad"), workDirectory: opticalRoot.appendingPathComponent("work")) { event in if case .failed(let message) = event { tamperedError = message } } let liar = OpticalManifest(sessionID: 42, senderDevice: "PC", fileName: "x.bin", fileSize: UInt64(opticalPayload.count), chunkSize: 450, totalChunks: UInt32((opticalPayload.count + 449) / 450), sha256: Data(repeating: 0xAB, count: 32)) tamperedAssembler.accept(text: OpticalProtocol.text(for: OpticalProtocol.encodeManifest(liar))) for index in 0.. 0.8, "搜索态覆盖大半个画面") roi.hit(boundingBox: CGRect(x: 0.30, y: 0.40, width: 0.20, height: 0.12)) check(roi.isLocked, "解出一帧后进入锁定") let locked = roi.decodeRegion check(locked.width < 0.6, "锁定后只解一小块(宽 \(String(format: "%.2f", locked.width)))") // 归一化坐标在 9:16 画面上会把方码拉扁,ROI 必须按像素比例修方 check(abs(locked.width * 0.5625 - locked.height) < 0.02, "锁定框在像素意义上是正方形") for _ in 0..<(OpticalROI.missesBeforeExpand + 1) { roi.miss() } check(roi.decodeRegion.width > locked.width, "连续丢失后逐级放大 ROI") for _ in 0.. 0.8, "持续丢失后回到全画面重新搜索") var edge = OpticalROI(aspect: 1) edge.hit(boundingBox: CGRect(x: 0.95, y: 0.95, width: 0.2, height: 0.2)) let clamped = edge.decodeRegion check(clamped.minX >= 0 && clamped.minY >= 0 && clamped.maxX <= 1.0001 && clamped.maxY <= 1.0001, "越界的 ROI 被夹回画面内") // ---------------------------------------------------------------- 连接码 section("桌面端连接码(与 desktop/src/connect_code.rs 交叉验证)") // 这四组由 Rust 端实现直接产出,任何一边改了编码都会红 let codeVectors: [(String, Int, String, String)] = [ ("192.168.1.20", 39393, "a1b2c3", "480H-98DJ-RCTG"), ("10.0.0.5", 39393, "010203", "4R00-0181-081P-P"), ("172.20.10.3", 40000, "ff007f", "5020-M0WW-83ZG-0ZTH"), ("127.0.0.1", 8080, "deadbe", "5HZG-0001-3Y8D-XBDY-98"), ] for (address, port, secret, text) in codeVectors { guard let decoded = try? ConnectCode.decode(text) else { check(false, "解析 \(text) 失败"); continue } checkEqual(decoded.address, address, "\(text) 的地址") checkEqual(decoded.port, port, "\(text) 的端口") checkEqual(decoded.secretHex, secret, "\(text) 的秘密") checkEqual(decoded.encode(), text, "\(text) 重新编码一致") } check((try? ConnectCode.decode("480h 98dj rctg")) != nil, "小写与空格分隔都接受") check((try? ConnectCode.decode("48OH-98DJ-RCTG")) != nil, "Crockford 容错:O 当成 0") check((try? ConnectCode.decode("480H-98DJ-RCTU")) == nil, "字母表外的字符被拒绝") check((try? ConnectCode.decode("480H-98DJ-RCTF")) == nil, "改一位后校验失败") check((try? ConnectCode.decode("480H")) == nil, "长度不足时拒绝") check(try! ConnectCode.decode("480H-98DJ-RCTG").isUsable, "私有地址的连接码可用") // 连接码同样是不可信输入:公网地址不能因为「码是对的」就放行 let publicCode = ConnectCode(address: "8.8.8.8", port: 39393, secret: [1, 2, 3]) check(!publicCode.isUsable, "公网地址的连接码被端点白名单拒绝") // ---------------------------------------------------------------- 节点浏览 section("QFTBROWSE3 节点应答(不可信输入)") let announce = #"QFTNODE3:{"n":"MacBook-Pro","p":"macos","t":39393,"r":true}"# let peer = PeerBrowser.parseReply(announce, source: "192.168.1.20") checkEqual(peer?.name, "MacBook-Pro", "节点名") checkEqual(peer?.platform, "macos", "平台标识") checkEqual(peer?.port, 39393, "端口") checkEqual(peer?.baseURL, "http://192.168.1.20:39393", "base URL") check(peer?.ready == true, "等待接收标志") check(PeerBrowser.parseReply(announce, source: "8.8.8.8") == nil, "来源不是私有地址时丢弃") check(PeerBrowser.parseReply(#"QFTNODE3:{"n":"x","p":"linux","t":0,"r":true}"#, source: "10.0.0.2") == nil, "端口 0 的应答无意义") check(PeerBrowser.parseReply("QFTHERE2:token:39393", source: "10.0.0.2") == nil, "前缀不符时丢弃") check(PeerBrowser.parseReply("QFTNODE3:not-json", source: "10.0.0.2") == nil, "非 JSON 丢弃") let dirty = PeerBrowser.parseReply( "QFTNODE3:{\"n\":\"bad\\u0000name\",\"p\":\"linux!!\",\"t\":1,\"r\":false}", source: "10.0.0.2") check(dirty?.name.contains("\0") == false, "节点名里的控制字符被清掉") checkEqual(dirty?.platform, "linux", "平台标识只保留字母数字") // ---------------------------------------------------------------- 集成测试 section("集成:与 MockPCServer 的完整传输") let root = URL(fileURLWithPath: CommandLine.arguments.count > 1 ? CommandLine.arguments[1] : NSTemporaryDirectory()).appendingPathComponent("qft-ios-test", isDirectory: true) try? FileManager.default.removeItem(at: root) try! FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) let mockScript = URL(fileURLWithPath: #filePath) .deletingLastPathComponent().appendingPathComponent("MockPCServer.py") // 3 MiB + 一点零头,确保最后一块是不完整块 let payloadSize = 3 * 1024 * 1024 + 4321 var payload = Data(count: payloadSize) payload.withUnsafeMutableBytes { buffer in guard let base = buffer.bindMemory(to: UInt8.self).baseAddress else { return } var state: UInt64 = 0x2026_0810 for index in 0..> 33) & 0xff) } } let sourceURL = root.appendingPathComponent("payload.bin") try! payload.write(to: sourceURL) let payloadHash = sha256Hex(payload) let saveDir = root.appendingPathComponent("received", isDirectory: true) let downloadDir = root.appendingPathComponent("downloads", isDirectory: true) try! FileManager.default.createDirectory(at: downloadDir, withIntermediateDirectories: true) let token = "testsession0123456789abcdefghijk" let process = Process() process.executableURL = URL(fileURLWithPath: "/usr/bin/env") process.arguments = ["python3", mockScript.path, "--token", token, "--serve", sourceURL.path, "--save-dir", saveDir.path, "--port", "0"] let pipe = Pipe() process.standardOutput = pipe try! process.run() var port = 0 let readyLine = readReadyLine(from: pipe.fileHandleForReading, timeout: 10) if let readyLine, readyLine.hasPrefix("READY ") { port = Int(readyLine.dropFirst("READY ".count).trimmingCharacters(in: .whitespaces)) ?? 0 } check(port > 0, "mock 电脑端已启动(端口 \(port))") if port > 0 { let base = "http://127.0.0.1:\(port)" let host = QFTHost(baseURL: base) let sendPairing = PairingPayload( version: 2, session: token, pcName: "MOCK-PC", port: port, endpoints: [base], wifi: nil, direction: .downloadToPhone, fileName: "payload.bin", fileSize: UInt64(payloadSize), sha256: payloadHash) let semaphore = DispatchSemaphore(value: 0) Task { defer { semaphore.signal() } // --- 发现 --- let discovery = HostDiscovery(pairing: sendPairing, deviceName: "iPhone 测试机") let located = try? await discovery.locate() check(located?.baseURL == base, "通过二维码端点定位到电脑") // --- 下载 --- var lastFraction = 0.0 let downloader = DownloadClient(host: host, pairing: sendPairing, deviceName: "iPhone 测试机", destinationDirectory: downloadDir) do { let saved = try await downloader.run { lastFraction = $0.fraction } let received = try Data(contentsOf: saved) checkEqual(received.count, payloadSize, "下载字节数一致") checkEqual(sha256Hex(received), payloadHash, "下载内容 SHA-256 一致") check(lastFraction > 0.99, "进度回调抵达 100%") checkEqual(saved.lastPathComponent, "payload.bin", "落盘文件名正确") check(!FileManager.default.fileExists(atPath: saved.path + ".qftpart"), "临时文件已清理") } catch { check(false, "下载失败:\(error.localizedDescription)") } // --- 下载续传 --- do { let partURL = downloadDir.appendingPathComponent("payload.bin.qftpart") try? FileManager.default.removeItem(at: partURL) try payload.prefix(1_000_000).write(to: partURL) let resumed = try await DownloadClient(host: host, pairing: sendPairing, deviceName: "iPhone", destinationDirectory: downloadDir).run { _ in } let data = try Data(contentsOf: resumed) checkEqual(sha256Hex(data), payloadHash, "从 1,000,000 字节处续传后内容仍正确") try? FileManager.default.removeItem(at: resumed) } catch { check(false, "续传失败:\(error.localizedDescription)") } // --- 并行 Range 下载 --- do { let parallelDir = root.appendingPathComponent("parallel", isDirectory: true) let client = RangeDownloadClient(host: host, token: token, deviceName: "iPhone 测试机", destinationDirectory: parallelDir) // 没有二维码时靠 Range: bytes=0-0 问出文件名与总长度 let probed = try await client.probe() checkEqual(probed.fileName, "payload.bin", "探测拿到文件名") checkEqual(probed.fileSize, UInt64(payloadSize), "探测拿到总长度") let target = RangeDownloadClient.Target(fileName: "payload.bin", fileSize: UInt64(payloadSize), sha256: payloadHash) var parallelFraction = 0.0 let saved = try await client.run(target) { parallelFraction = $0.fraction } let received = try Data(contentsOf: saved) checkEqual(sha256Hex(received), payloadHash, "并行下载内容 SHA-256 一致") check(parallelFraction > 0.99, "并行下载进度回调抵达 100%") check(!FileManager.default.fileExists(atPath: saved.path + ".qftpart"), "分块临时文件已清理") check(!FileManager.default.fileExists( atPath: parallelDir.appendingPathComponent("payload.bin.qftpart.ledger").path), "断点账本已清理") try? FileManager.default.removeItem(at: saved) // 并行分块是乱序落盘的,续传只能靠账本,不能靠「已落盘长度」 let partURL = parallelDir.appendingPathComponent("payload.bin.qftpart") let ledgerURL = parallelDir.appendingPathComponent("payload.bin.qftpart.ledger") let chunk = RangeDownloadClient.chunkSize(for: UInt64(payloadSize)) let totalChunks = Int((UInt64(payloadSize) + chunk - 1) / chunk) var half = [Bool](repeating: false, count: totalChunks) var scratch = Data(count: payloadSize) for index in stride(from: 0, to: totalChunks, by: 2) { half[index] = true let start = Int(UInt64(index) * chunk) let end = min(start + Int(chunk), payloadSize) scratch.replaceSubrange(start.. 0, "不支持分段的 mock 已启动(端口 \(legacyPort))") if legacyPort > 0 { let legacyHost = QFTHost(baseURL: "http://127.0.0.1:\(legacyPort)") let client = RangeDownloadClient(host: legacyHost, token: token, deviceName: "iPhone 测试机", destinationDirectory: root.appendingPathComponent("legacy")) do { _ = try await client.run(RangeDownloadClient.Target( fileName: "payload.bin", fileSize: UInt64(payloadSize), sha256: payloadHash)) { _ in } check(false, "对端忽略 Range 时本应显式失败") } catch QFTError.rangeUnsupported { check(true, "对端忽略 Range 时抛出 rangeUnsupported,上层据此回落单流") } catch { check(false, "应抛 rangeUnsupported,实得 \(error)") } // 回落路径本身必须还能把文件收完整 let fallbackDir = root.appendingPathComponent("legacy-fallback") try FileManager.default.createDirectory(at: fallbackDir, withIntermediateDirectories: true) let fallbackPairing = PairingPayload( version: 2, session: token, pcName: "OLD-PC", port: legacyPort, endpoints: [legacyHost.baseURL], wifi: nil, direction: .downloadToPhone, fileName: "payload.bin", fileSize: UInt64(payloadSize), sha256: payloadHash) let saved = try await DownloadClient(host: legacyHost, pairing: fallbackPairing, deviceName: "iPhone 测试机", destinationDirectory: fallbackDir).run { _ in } checkEqual(sha256Hex(try Data(contentsOf: saved)), payloadHash, "单流回落后内容仍正确") } } catch { check(false, "分段回落用例失败:\(error.localizedDescription)") } // --- 连接码配对 --- do { let paired = try await DesktopPairing.pair(baseURL: base, code: "a1b2c3", deviceName: "iPhone 测试机") checkEqual(paired, token, "连接码换到会话令牌") } catch { check(false, "连接码配对失败:\(error.localizedDescription)") } do { _ = try await DesktopPairing.pair(baseURL: base, code: "000000", deviceName: "iPhone 测试机") check(false, "错误连接码本应失败") } catch { check(true, "错误连接码被拒绝:\(error.localizedDescription)") } // --- 上传 --- let uploadPairing = PairingPayload( version: 2, session: token, pcName: "MOCK-PC", port: port, endpoints: [base], wifi: nil, direction: .uploadToPC, fileName: nil, fileSize: nil, sha256: nil) do { var seen = 0.0 let uploader = UploadClient(host: host, pairing: uploadPairing, deviceName: "iPhone 测试机") let sha = try await uploader.run(fileURL: sourceURL) { seen = $0.fraction } checkEqual(sha, payloadHash, "上传后电脑侧 SHA-256 与本地一致") check(seen > 0.99, "上传进度回调抵达 100%") let landed = saveDir.appendingPathComponent("payload.bin") let data = try Data(contentsOf: landed) checkEqual(data.count, payloadSize, "电脑侧落盘大小一致") checkEqual(sha256Hex(data), payloadHash, "电脑侧落盘内容一致") } catch { check(false, "上传失败:\(error.localizedDescription)") } // --- 错误令牌必须被拒 --- let badPairing = PairingPayload( version: 2, session: "wrongsession0123456789abcdefghij", pcName: "MOCK-PC", port: port, endpoints: [base], wifi: nil, direction: .uploadToPC, fileName: nil, fileSize: nil, sha256: nil) do { _ = try await UploadClient(host: host, pairing: badPairing, deviceName: "iPhone").run(fileURL: sourceURL) { _ in } check(false, "错误令牌本应失败") } catch { check(true, "错误令牌被拒绝:\(error.localizedDescription)") } } semaphore.wait() } process.terminate() // ---------------------------------------------------------------- P2P 配对码 section("隔空投送式配对码") let sampleQueue = try! PeerQueue.encode(sender: "我的 iPhone", files: [ PeerFileMeta(name: "视频.mov", size: 987_654_321, sha256: String(repeating: "cd", count: 32)), PeerFileMeta(name: "笔记.txt", size: 12, sha256: String(repeating: "ef", count: 32)), ]) let peerSample = PeerPairing( version: 2, key: Data((0..<32).map { UInt8($0) }), instance: "qft-abcdefghijkl", senderName: "我的 iPhone", fileCount: 2, totalSize: 987_654_333, queueDigest: PeerQueue.digest(of: sampleQueue), previewName: "视频.mov") let peerRoundTrip = PeerPairing.parse(peerSample.encode()) checkEqual(peerRoundTrip, peerSample, "QFTP2P2 编解码往返一致") check(PeerPairing.isPeerText(peerSample.encode()), "前缀识别") check(PairingProtocol.parse(peerSample.encode()) == nil, "P2P 码不会被误判为 QFTPAIR2") // 多文件的元数据留在链路上,二维码只带摘要——十几个文件的清单会让码密到扫不动 check(peerSample.encode().count < 400, "二维码内容不随文件数增长(\(peerSample.encode().count) 字符)") let queueRoundTrip = PeerQueue.decode(sampleQueue) checkEqual(queueRoundTrip?.files.count, 2, "清单解析出两个文件") checkEqual(queueRoundTrip?.files.first?.name, "视频.mov", "清单里的文件名") check(PeerQueue.decode(Data("{}".utf8)) == nil, "空清单被拒绝") check(PeerQueue.decode(Data(#"{"v":2,"files":[{"name":"../x","size":1,"sha256":"aa"}]}"#.utf8)) == nil, "清单里的路径分隔符被拒绝") func mutatedPeer(_ change: (inout [String: Any]) -> Void) -> String { var object: [String: Any] = [ "v": 2, "k": Base64URL.encode(Data(repeating: 7, count: 32)), "i": "qft-abcdefghijkl", "n": "iPhone", "c": 1, "z": 10, "d": String(repeating: "ab", count: 32), "f": "a.bin", ] change(&object) let data = try! JSONSerialization.data(withJSONObject: object) return PeerPairing.prefix + Base64URL.encode(data) } check(PeerPairing.parse(mutatedPeer { $0["k"] = Base64URL.encode(Data(repeating: 7, count: 16)) }) == nil, "密钥不足 32 字节时拒绝") check(PeerPairing.parse(mutatedPeer { $0["i"] = "bad instance!" }) == nil, "非法实例名时拒绝") check(PeerPairing.parse(mutatedPeer { $0["f"] = "../../etc/passwd" }) == nil, "预览文件名含路径分隔符时拒绝") check(PeerPairing.parse(mutatedPeer { $0["d"] = "zz" }) == nil, "摘要格式错误时拒绝") check(PeerPairing.parse(mutatedPeer { $0["c"] = 0 }) == nil, "文件数为 0 时拒绝") check(PeerPairing.newKey().count == 32, "新密钥为 32 字节") check(PeerPairing.isValidInstance(PeerPairing.newInstance()), "新实例名合法") check(PeerPairing.newKey() != PeerPairing.newKey(), "密钥每次不同") // ---------------------------------------------------------------- P2P 传输 section("隔空投送式点对点传输(TLS-PSK 真实握手,多文件)") let peerDir = root.appendingPathComponent("peer", isDirectory: true) try! FileManager.default.createDirectory(at: peerDir, withIntermediateDirectories: true) // 三个大小各异的文件:大文件跨多个数据帧,空文件是最容易写错的边界 let peerSources: [(String, Data)] = [ ("大文件.bin", payload), ("小文件.txt", Data("QFT 隔空多文件".utf8)), ("空文件.dat", Data()), ] let peerURLs = peerSources.map { name, data -> URL in let url = root.appendingPathComponent(name) try! data.write(to: url) return url } let peerTotal = peerSources.reduce(UInt64(0)) { $0 + UInt64($1.1.count) } let peerSemaphore = DispatchSemaphore(value: 0) Task { defer { peerSemaphore.signal() } let sender = PeerSender(fileURLs: peerURLs, deviceName: "发送端 iPhone") do { let pairing = try sender.start() checkEqual(pairing.fileCount, 3, "配对码里的文件数") checkEqual(pairing.totalSize, peerTotal, "配对码里的总字节数由发送端实读") let port = try await sender.listeningPort() check(port > 0, "监听器就绪(端口 \(port))") // 二维码在真机上是扫出来的,这里模拟:编码 → 解码 → 用解出来的配对码连接 guard let scanned = PeerPairing.parse(pairing.encode()) else { check(false, "配对码无法解析"); return } var receiver = PeerReceiver(pairing: scanned, destinationDirectory: peerDir) receiver.directPort = port // 测试跳过 Bonjour,直连回环 async let sendSide: Void = sender.waitAndSend { _ in } var peerFraction = 0.0 var seenNames: [String] = [] let saved = try await receiver.run { peerFraction = $0.progress.fraction if seenNames.last != $0.fileName { seenNames.append($0.fileName) } } try await sendSide checkEqual(saved.count, 3, "三个文件全部落盘") for (index, source) in peerSources.enumerated() where index < saved.count { let data = try Data(contentsOf: saved[index]) checkEqual(sha256Hex(data), sha256Hex(source.1), "\(source.0) 内容一致") checkEqual(saved[index].lastPathComponent, source.0, "\(source.0) 文件名一致") } check(peerFraction > 0.99, "P2P 进度回调抵达 100%") check(seenNames.count >= 2, "进度回调报告了当前文件名(\(seenNames))") check(!FileManager.default.fileExists(atPath: peerDir.appendingPathComponent("大文件.bin.qftpart").path), "P2P 临时文件已清理") } catch { check(false, "P2P 传输失败:\(error.localizedDescription)") } sender.stop() } if peerSemaphore.wait(timeout: .now() + 60) == .timedOut { check(false, "P2P 传输超时") } // 清单摘要必须锁死「扫到的就是收到的」 let digestSemaphore = DispatchSemaphore(value: 0) Task { defer { digestSemaphore.signal() } let sender = PeerSender(fileURLs: [peerURLs[1]], deviceName: "发送端") do { let pairing = try sender.start() let port = try await sender.listeningPort() let tampered = PeerPairing(version: 2, key: pairing.key, instance: pairing.instance, senderName: pairing.senderName, fileCount: pairing.fileCount, totalSize: pairing.totalSize, queueDigest: String(repeating: "ab", count: 32), previewName: pairing.previewName) var receiver = PeerReceiver(pairing: tampered, destinationDirectory: peerDir.appendingPathComponent("bad")) receiver.directPort = port async let sendSide: Void = sender.waitAndSend { _ in } _ = try await receiver.run { _ in } _ = try? await sendSide check(false, "清单摘要不符本应被拒绝") } catch { check(true, "清单摘要不符时接收端拒绝:\(error.localizedDescription)") } sender.stop() } if digestSemaphore.wait(timeout: .now() + 30) == .timedOut { check(false, "清单摘要用例超时") } // 错误密钥必须握手失败 let wrongKeySemaphore = DispatchSemaphore(value: 0) Task { defer { wrongKeySemaphore.signal() } let sender = PeerSender(fileURLs: [peerURLs[1]], deviceName: "发送端") do { let pairing = try sender.start() let port = try await sender.listeningPort() let tampered = PeerPairing(version: 2, key: PeerPairing.newKey(), instance: pairing.instance, senderName: pairing.senderName, fileCount: pairing.fileCount, totalSize: pairing.totalSize, queueDigest: pairing.queueDigest, previewName: pairing.previewName) var receiver = PeerReceiver(pairing: tampered, destinationDirectory: peerDir) receiver.directPort = port _ = try await receiver.run { _ in } check(false, "错误密钥本应握手失败") } catch { check(true, "错误密钥被 TLS-PSK 拒绝") } sender.stop() } if wrongKeySemaphore.wait(timeout: .now() + 30) == .timedOut { check(false, "错误密钥用例超时(握手未在预期时间内失败)") } // 测试全程只写 root 下的临时目录,不碰 Documents try? FileManager.default.removeItem(at: root) print("\n检查 \(checks) 项,失败 \(failures) 项") if failures > 0 { print("IOS CORE TESTS FAILED") exit(1) } print("IOS CORE TESTS PASSED")