Files
zhy200308 eae24000e9 优化IOS
2026-08-19 09:31:21 +08:00

839 lines
42 KiB
Swift
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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<T: Equatable>(_ 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..<Int.random(in: 0...64)).map { _ in UInt8.random(in: 0...255) })
if Base64URL.decode(Base64URL.encode(raw)) != raw {
check(false, "随机往返失败")
break
}
}
check(true, "200 组随机字节往返一致")
// ---------------------------------------------------------------- 配对二维码
section("配对二维码解析")
func makePairingText(prefix: String, _ object: [String: Any]) -> 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<rt_msghdr>.size, "rt_msghdr 大小")
checkEqual(RM.messageLengthOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_msglen), "rtm_msglen 偏移")
checkEqual(RM.versionOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_version), "rtm_version 偏移")
checkEqual(RM.interfaceIndexOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_index), "rtm_index 偏移")
checkEqual(RM.addressMaskOffset, MemoryLayout<rt_msghdr>.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..<Int.random(in: 0...600)).map { _ in UInt8.random(in: 0...255) })
if Base45.decode(Base45.encode(raw)) != raw { base45RoundTripOK = false; break }
}
check(base45RoundTripOK, "200 组随机字节 Base45 往返一致")
// ---------------------------------------------------------------- 光学协议
section("光学 QFT2 帧")
func opticalPlaylist(payload: Data, chunkSize: Int, name: String,
sessionID: UInt64 = 0x0123_4567_89ab_cdef) -> (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..<Int(total) {
let start = index * chunkSize
let end = min(start + chunkSize, payload.count)
frames.append(OpticalProtocol.text(for: OpticalProtocol.encodeFrame(
kind: .data, sessionID: sessionID, seq: UInt32(index),
totalChunks: total, payload: payload.subdata(in: start..<end))))
}
frames.append(OpticalProtocol.text(for: OpticalProtocol.encodeFrame(
kind: .end, sessionID: sessionID, seq: 0, totalChunks: total, payload: Data())))
return (manifest, frames)
}
let opticalPayload = Data((0..<4321).map { UInt8($0 % 251) })
let (opticalManifest, opticalFrames) = opticalPlaylist(payload: opticalPayload,
chunkSize: 450, name: "报告.pdf")
check(opticalFrames.allSatisfy { $0.hasPrefix("QFT2:") }, "帧文本前缀为 QFT2:")
check(opticalFrames.allSatisfy(OpticalProtocol.isOpticalText), "全部被识别为光学帧")
let parsedManifest = OpticalProtocol.parseText(opticalFrames[0]).flatMap(OpticalProtocol.parseManifest)
checkEqual(parsedManifest, opticalManifest, "清单帧编解码往返一致")
checkEqual(parsedManifest?.fileName, "报告.pdf", "文件名支持中文")
checkEqual(parsedManifest?.sha256Hex, sha256Hex(opticalPayload), "清单里的 SHA-256")
// CRC 是唯一能挡住「语法合法但内容错误」的相机误识别的手段
var corrupted = OpticalProtocol.encodeFrame(kind: .data, sessionID: 1, seq: 0,
totalChunks: 1, payload: Data([1, 2, 3]))
corrupted[OpticalProtocol.headerSize] ^= 0x40
check(OpticalProtocol.parseBinary(corrupted, magic: "QFT2", version: 2) == nil, "CRC 不符时整帧丢弃")
check(OpticalProtocol.parseText("QFT2:" + String(repeating: "0", count: 60)) == nil, "噪声文本不会被当成帧")
check(OpticalProtocol.parseText("QFT2:") == nil, "空帧被拒绝")
check(OpticalProtocol.parseText("hello") == nil, "非 QFT 文本被忽略")
checkEqual(OpticalProtocol.sanitizeFileName("../../etc/passwd"), "etc_passwd", "文件名里的路径分隔符被清掉")
checkEqual(OpticalProtocol.sanitizeFileName(" "), "qft.bin", "空文件名有兜底")
// ---------------------------------------------------------------- 光学装配
section("光学会话装配")
let opticalRoot = URL(fileURLWithPath: NSTemporaryDirectory())
.appendingPathComponent("qft-optical-\(UUID().uuidString)", isDirectory: true)
try! FileManager.default.createDirectory(at: opticalRoot, withIntermediateDirectories: true)
var opticalSaved: URL?
var opticalErrors: [String] = []
var opticalProgressSeen = 0
let assembler = OpticalAssembler(destinationDirectory: opticalRoot,
workDirectory: opticalRoot.appendingPathComponent("work")) { event in
switch event {
case .completed(_, let url): opticalSaved = url
case .failed(let message): opticalErrors.append(message)
case .progress(_, let received, _): opticalProgressSeen = received
case .started: break
}
}
// 真实场景是循环重播:乱序 + 大量重复
var duplicates = 0
var accepted = 0
for text in opticalFrames.shuffled() + opticalFrames {
switch assembler.accept(text: text) {
case .accepted: accepted += 1
case .duplicate: duplicates += 1
case .ignored: break
}
}
check(opticalErrors.isEmpty, "乱序重播过程中没有错误:\(opticalErrors)")
check(opticalSaved != nil, "收齐后自动落盘")
check(duplicates > 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..<Int(liar.totalChunks) {
let start = index * 450
let end = min(start + 450, opticalPayload.count)
tamperedAssembler.accept(text: OpticalProtocol.text(for: OpticalProtocol.encodeFrame(
kind: .data, sessionID: 42, seq: UInt32(index), totalChunks: liar.totalChunks,
payload: opticalPayload.subdata(in: start..<end))))
}
check(tamperedError?.contains("SHA-256") == true, "整份校验失败时报错并丢弃")
check(!FileManager.default.fileExists(
atPath: opticalRoot.appendingPathComponent("bad/x.bin").path), "校验失败的文件不会落到目标目录")
// 空文件是合法的边界:清单里 0 片,收到清单即完成
var emptySaved: URL?
let emptyAssembler = OpticalAssembler(
destinationDirectory: opticalRoot.appendingPathComponent("empty"),
workDirectory: opticalRoot.appendingPathComponent("work")) { event in
if case .completed(_, let url) = event { emptySaved = url }
}
let (_, emptyFrames) = opticalPlaylist(payload: Data(), chunkSize: 450, name: "empty.bin",
sessionID: 7)
emptyAssembler.accept(text: emptyFrames[0])
check(emptySaved != nil, "0 字节文件也能正常收完")
try? FileManager.default.removeItem(at: opticalRoot)
// ---------------------------------------------------------------- ROI
section("光学 ROI 状态机")
var roi = OpticalROI(aspect: 0.5625) // 竖屏 720×1280
check(!roi.isLocked, "初始为搜索态")
check(roi.decodeRegion.width > 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..<OpticalROI.missesBeforeReacquire { roi.miss() }
check(!roi.isLocked && roi.decodeRegion.width > 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..<payloadSize {
state = state &* 6364136223846793005 &+ 1442695040888963407
base[index] = UInt8((state >> 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..<end, with: payload[start..<end])
}
try scratch.write(to: partURL)
try DownloadLedger(size: UInt64(payloadSize), chunkSize: chunk,
sha256: payloadHash, completed: half).encode().write(to: ledgerURL)
let resumed = try await client.run(target) { _ in }
checkEqual(sha256Hex(try Data(contentsOf: resumed)), payloadHash,
"按账本只补缺失块后内容仍正确")
try? FileManager.default.removeItem(at: resumed)
} catch {
check(false, "并行下载失败:\(error.localizedDescription)")
}
// --- 不支持分段下载的电脑端:必须能被识别出来,交给上层回落单流 ---
do {
let legacyProcess = Process()
legacyProcess.executableURL = URL(fileURLWithPath: "/usr/bin/env")
legacyProcess.arguments = ["python3", mockScript.path, "--token", token,
"--serve", sourceURL.path, "--save-dir", saveDir.path,
"--port", "0", "--ignore-range"]
let legacyPipe = Pipe()
legacyProcess.standardOutput = legacyPipe
try legacyProcess.run()
defer { legacyProcess.terminate() }
let line = readReadyLine(from: legacyPipe.fileHandleForReading, timeout: 10) ?? ""
let legacyPort = Int(line.dropFirst("READY ".count).trimmingCharacters(in: .whitespaces)) ?? 0
check(legacyPort > 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")