839 lines
42 KiB
Swift
839 lines
42 KiB
Swift
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")
|