mirror of
https://github.com/shadowsocks/ShadowsocksX-NG.git
synced 2026-11-08 23:24:51 +00:00
400 lines
20 KiB
Swift
400 lines
20 KiB
Swift
import XCTest
|
|
|
|
@testable import ShadowsocksX_NG2
|
|
|
|
extension ProxyControlWorkflowIntegrationTests {
|
|
private func enabledSystemProxyComposition(
|
|
probe: ProxyRuntimeFixture.FakeProbe = .reachable()
|
|
) async throws -> Composition {
|
|
let server = try makeSeededCatalog()
|
|
let composition = makeProxies(probe: probe)
|
|
_ = try await composition.catalog.activate(server)
|
|
_ = await composition.control.setAgentEnabled(true)
|
|
_ = await composition.control.setSystemProxyEnabled(true)
|
|
return composition
|
|
}
|
|
|
|
private func waitForSnapshot(
|
|
_ composition: Composition, matching predicate: (ProxyControlSnapshot) -> Bool
|
|
) async throws {
|
|
let deadline = Date().addingTimeInterval(2)
|
|
while !predicate(composition.control.snapshot) && Date() < deadline {
|
|
try await Task.sleep(nanoseconds: 10_000_000)
|
|
}
|
|
XCTAssertTrue(predicate(composition.control.snapshot), "实际快照：\(composition.control.snapshot)")
|
|
}
|
|
|
|
func testCurrentDifferencesIncludeChangedAndNewServicesAndDisappearWhenRestored() async throws {
|
|
let composition = try await enabledSystemProxyComposition()
|
|
let original = systemProxy.services[0]
|
|
systemProxy.services = [
|
|
SystemProxyServiceState(
|
|
identifier: original.identifier, configuration: nil, name: "很长的办公室 Wi-Fi 网络接口名称"),
|
|
SystemProxyServiceState(
|
|
identifier: .init(locationID: "home", serviceID: "ethernet"), configuration: nil,
|
|
name: "USB Ethernet"),
|
|
]
|
|
networkMonitor.emit(.proxyConfiguration)
|
|
try await waitForSnapshot(composition) { $0.systemProxyInspection.differences.count == 2 }
|
|
XCTAssertEqual(
|
|
composition.control.snapshot.systemProxyInspection.differences.map(\.kind),
|
|
[.changed, .notApplied])
|
|
XCTAssertEqual(
|
|
composition.control.snapshot.systemProxyInspection.differences.map(\.name),
|
|
["很长的办公室 Wi-Fi 网络接口名称", "USB Ethernet"])
|
|
XCTAssertEqual(systemProxy.applied.count, 1)
|
|
XCTAssertTrue(composition.control.snapshot.systemProxyInspection.canRepair)
|
|
|
|
systemProxy.services[0] = original
|
|
networkMonitor.emit(.proxyConfiguration)
|
|
try await waitForSnapshot(composition) { $0.systemProxyInspection.differences.count == 1 }
|
|
_ = await composition.control.repairSystemProxy()
|
|
XCTAssertEqual(systemProxy.repairedServices, [.init(locationID: "home", serviceID: "ethernet")])
|
|
XCTAssertEqual(composition.control.snapshot.systemProxyApplication, .applied)
|
|
XCTAssertTrue(composition.control.snapshot.systemProxyInspection.differences.isEmpty)
|
|
}
|
|
|
|
func testRepairReadsLatestLocationAndSkipsAlreadyConsistentServices() async throws {
|
|
let composition = try await enabledSystemProxyComposition()
|
|
let original = systemProxy.services[0]
|
|
systemProxy.services[0] = SystemProxyServiceState(
|
|
identifier: original.identifier, configuration: nil, name: original.name)
|
|
_ = await composition.control.recheckSystemProxy()
|
|
systemProxy.services = [
|
|
SystemProxyServiceState(
|
|
identifier: .init(locationID: "work", serviceID: "vpn"), configuration: nil, name: "VPN"),
|
|
SystemProxyServiceState(
|
|
identifier: .init(locationID: "work", serviceID: "wifi"),
|
|
configuration: original.configuration, name: "Wi-Fi"),
|
|
]
|
|
_ = await composition.control.repairSystemProxy()
|
|
XCTAssertEqual(systemProxy.repairedServices, [.init(locationID: "work", serviceID: "vpn")])
|
|
XCTAssertEqual(composition.control.snapshot.systemProxyApplication, .applied)
|
|
await emitAndWaitForInspection(.networkPath, in: composition)
|
|
XCTAssertEqual(systemProxy.applied.count, 2, "被动事件不重写")
|
|
}
|
|
|
|
func testRepairSuccessResponseCannotHideRemainingDifference() async throws {
|
|
let composition = try await enabledSystemProxyComposition()
|
|
let original = systemProxy.services[0]
|
|
systemProxy.services[0] = SystemProxyServiceState(
|
|
identifier: original.identifier, configuration: nil, name: original.name)
|
|
_ = await composition.control.recheckSystemProxy()
|
|
systemProxy.preserveConfigurationOnApply = true
|
|
_ = await composition.control.repairSystemProxy()
|
|
XCTAssertEqual(composition.control.snapshot.systemProxyApplication, .changed)
|
|
XCTAssertEqual(
|
|
composition.control.snapshot.systemProxyInspection.differences.map(\.kind), [.remaining])
|
|
}
|
|
|
|
func testDuplicateRepairDoesNotWriteTwiceAndKeepsNamesDuringProgress() async throws {
|
|
let composition = try await enabledSystemProxyComposition()
|
|
let original = systemProxy.services[0]
|
|
systemProxy.services[0] = SystemProxyServiceState(
|
|
identifier: original.identifier, configuration: nil, name: original.name)
|
|
_ = await composition.control.recheckSystemProxy()
|
|
let gate = ProxyControlOperationGate(started: expectation(description: "repair paused"))
|
|
defer { gate.resume() }
|
|
systemProxy.beforeRepair = { await gate.wait() }
|
|
let first = Task { await composition.control.repairSystemProxy() }
|
|
await fulfillment(of: [gate.started], timeout: 2)
|
|
XCTAssertEqual(composition.control.snapshot.systemProxyApplication, .repairing)
|
|
XCTAssertEqual(
|
|
composition.control.snapshot.systemProxyInspection.differences.map(\.name), ["Wi-Fi"])
|
|
XCTAssertFalse(composition.control.snapshot.systemProxyInspection.canRepair)
|
|
_ = await composition.control.repairSystemProxy()
|
|
gate.resume()
|
|
_ = await first.value
|
|
XCTAssertEqual(systemProxy.applied.count, 2)
|
|
}
|
|
|
|
func testReadFailureIsUnknownAndRecheckNeverWrites() async throws {
|
|
let composition = try await enabledSystemProxyComposition()
|
|
systemProxy.readError = SystemProxyError.preferencesUnavailable
|
|
let failed = await composition.control.recheckSystemProxy()
|
|
XCTAssertEqual(failed.systemProxyApplication, .unreadable(.operation(.preferencesUnavailable)))
|
|
XCTAssertFalse(failed.systemProxyInspection.canRepair)
|
|
XCTAssertEqual(systemProxy.applied.count, 1)
|
|
systemProxy.readError = nil
|
|
let restored = await composition.control.recheckSystemProxy()
|
|
XCTAssertEqual(restored.systemProxyApplication, .applied)
|
|
XCTAssertEqual(systemProxy.applied.count, 1)
|
|
}
|
|
|
|
func testHealthLossClearsOnceAndRecoveryAutomaticallyApplies() async throws {
|
|
let probe = ProxyRuntimeFixture.FakeProbe.reachable()
|
|
let composition = try await enabledSystemProxyComposition(probe: probe)
|
|
probe.setOutcomes([.refused(detail: "local stopped")])
|
|
try await waitForSnapshot(composition) { $0.systemProxyApplication == .paused }
|
|
XCTAssertTrue(composition.control.snapshot.systemProxyIntentEnabled)
|
|
XCTAssertEqual(systemProxy.clearCount, 1)
|
|
await emitAndWaitForInspection(.networkPath, in: composition)
|
|
XCTAssertEqual(systemProxy.clearCount, 1, "失效期间不循环重试")
|
|
probe.setOutcomes([.reachable])
|
|
try await waitForSnapshot(composition) { $0.systemProxyApplication == .applied }
|
|
XCTAssertEqual(systemProxy.applied.count, 2)
|
|
}
|
|
|
|
func testPausedIntentOffPreventsRecoveryApply() async throws {
|
|
let probe = ProxyRuntimeFixture.FakeProbe.reachable()
|
|
let composition = try await enabledSystemProxyComposition(probe: probe)
|
|
probe.setOutcomes([.refused(detail: "stopped")])
|
|
try await waitForSnapshot(composition) { $0.systemProxyApplication == .paused }
|
|
let healthObservation = composition.controller.systemProxyObserver.systemProxyHealthTask
|
|
XCTAssertNotNil(healthObservation)
|
|
_ = await composition.control.setSystemProxyEnabled(false)
|
|
probe.setOutcomes([.reachable])
|
|
await healthObservation?.value
|
|
XCTAssertFalse(networkMonitor.isObserving, "关闭意图后应停止观察与自动恢复")
|
|
XCTAssertEqual(systemProxy.applied.count, 1)
|
|
XCTAssertFalse(composition.control.snapshot.systemProxyIntentEnabled)
|
|
}
|
|
|
|
func testClearFailureAndApprovalCoexistAfterIntentOffWithoutAutomaticRetry() async throws {
|
|
let composition = try await enabledSystemProxyComposition()
|
|
systemProxy.clearError = SystemProxyError.helperUnavailable("approval missing")
|
|
systemProxyHelper.setStatus(.requiresApproval)
|
|
let failed = await composition.control.setSystemProxyEnabled(false)
|
|
XCTAssertEqual(failed.systemProxyApplication, .clearFailed(.operation(.helperUnavailable)))
|
|
XCTAssertTrue(failed.systemProxyApprovalRequired)
|
|
XCTAssertFalse(failed.systemProxyInspection.canRetryClear)
|
|
XCTAssertNil(StatusMenuModel.summary(from: failed).systemProxyDetail, "批准原因不重复说明")
|
|
systemProxyHelper.setStatus(.approved)
|
|
_ = await composition.control.openSystemProxyHelperApproval()
|
|
XCTAssertEqual(systemProxy.clearCount, 1)
|
|
XCTAssertTrue(composition.control.snapshot.systemProxyInspection.canRetryClear)
|
|
systemProxy.clearError = nil
|
|
let restored = await composition.control.retrySystemProxyClear()
|
|
XCTAssertEqual(restored.systemProxyApplication, .idle)
|
|
XCTAssertEqual(systemProxy.clearCount, 2)
|
|
}
|
|
|
|
func testFailedApplyApprovalDoesNotRetryButUnattemptedEnableContinues() async throws {
|
|
let server = try makeSeededCatalog()
|
|
let composition = makeProxies(probe: ProxyRuntimeFixture.FakeProbe.reachable())
|
|
_ = try await composition.catalog.activate(server)
|
|
_ = await composition.control.setAgentEnabled(true)
|
|
systemProxyHelper.setStatus(.requiresApproval)
|
|
_ = await composition.control.setSystemProxyEnabled(true)
|
|
XCTAssertTrue(systemProxy.applied.isEmpty)
|
|
systemProxy.applyError = SystemProxyError.helperUnavailable("connection failed")
|
|
systemProxyHelper.setStatus(.approved)
|
|
_ = await composition.control.openSystemProxyHelperApproval()
|
|
XCTAssertEqual(
|
|
composition.control.snapshot.systemProxyApplication, .failed(.operation(.helperUnavailable)))
|
|
systemProxyHelper.setStatus(.requiresApproval)
|
|
_ = await composition.control.recheckSystemProxy()
|
|
XCTAssertTrue(composition.control.snapshot.systemProxyApprovalRequired)
|
|
XCTAssertFalse(composition.control.snapshot.systemProxyInspection.canRepair)
|
|
systemProxy.applyError = nil
|
|
systemProxyHelper.setStatus(.approved)
|
|
_ = await composition.control.openSystemProxyHelperApproval()
|
|
XCTAssertTrue(systemProxy.applied.isEmpty)
|
|
XCTAssertTrue(composition.control.snapshot.systemProxyInspection.canRepair)
|
|
_ = await composition.control.repairSystemProxy()
|
|
XCTAssertEqual(composition.control.snapshot.systemProxyApplication, .applied)
|
|
}
|
|
|
|
func testHealthyStartupOnlyReadsAndNewLocationIsNotAppliedCategory() async throws {
|
|
_ = try makeSeededCatalog()
|
|
let composition = makeProxies(
|
|
probe: ProxyRuntimeFixture.FakeProbe.reachable(),
|
|
settings: ProxyRuntimeSettings(
|
|
listen: ActivationFixture.listen, agentEnabled: true, systemProxyEnabled: true),
|
|
proxyMode: .direct)
|
|
let before = systemProxy.applied.count
|
|
await composition.control.resyncOnLaunch()
|
|
XCTAssertEqual(systemProxy.applied.count, before)
|
|
XCTAssertEqual(systemProxy.clearCount, 0)
|
|
systemProxy.services = [
|
|
SystemProxyServiceState(
|
|
identifier: .init(locationID: "new", serviceID: "wifi"), configuration: nil, name: "Airport"
|
|
)
|
|
]
|
|
networkMonitor.emit(.networkConfiguration)
|
|
try await waitForSnapshot(composition) {
|
|
$0.systemProxyInspection.differences.map(\.name) == ["Airport"]
|
|
}
|
|
XCTAssertEqual(
|
|
composition.control.snapshot.systemProxyInspection.differences.map(\.kind), [.notApplied])
|
|
XCTAssertEqual(systemProxy.applied.count, before)
|
|
}
|
|
|
|
func testUnhealthyStartupClearsAndPreservesIntentWithoutApplying() async throws {
|
|
_ = try makeSeededCatalog()
|
|
let composition = makeProxies(
|
|
probe: ProxyRuntimeFixture.FakeProbe.refusing(),
|
|
settings: ProxyRuntimeSettings(
|
|
listen: ActivationFixture.listen, agentEnabled: true, systemProxyEnabled: true))
|
|
await composition.control.resyncOnLaunch()
|
|
XCTAssertEqual(systemProxy.clearCount, 1)
|
|
XCTAssertTrue(systemProxy.applied.isEmpty)
|
|
XCTAssertEqual(composition.control.snapshot.systemProxyApplication, .paused)
|
|
XCTAssertTrue(composition.control.snapshot.systemProxyIntentEnabled)
|
|
}
|
|
|
|
func testSavedExceptionsAutomaticallyApplyButDraftAndDisabledIntentDoNot() async throws {
|
|
let composition = try await enabledSystemProxyComposition()
|
|
let editor = SettingsWorkflow(committing: composition.controller)
|
|
_ = editor.beginProxyExceptionsEditing()
|
|
XCTAssertEqual(systemProxy.applied.count, 1, "草稿不写系统设置")
|
|
_ = await editor.saveProxyExceptions("example.com")
|
|
try await waitForSnapshot(composition) { $0.systemProxyApplication == .applied }
|
|
XCTAssertEqual(systemProxy.applied.count, 2)
|
|
XCTAssertTrue(try XCTUnwrap(systemProxy.applied.last).exceptions.contains("example.com"))
|
|
_ = await composition.control.setSystemProxyEnabled(false)
|
|
_ = await editor.saveProxyExceptions("example.org")
|
|
XCTAssertEqual(systemProxy.applied.count, 2, "关闭意图下保存不应用")
|
|
}
|
|
|
|
func testHealthClearFailurePreservesIntentAndNeedsExplicitRetry() async throws {
|
|
let probe = ProxyRuntimeFixture.FakeProbe.reachable()
|
|
let composition = try await enabledSystemProxyComposition(probe: probe)
|
|
systemProxy.clearError = SystemProxyError.commitFailed("busy")
|
|
probe.setOutcomes([.refused(detail: "local stopped")])
|
|
try await waitForSnapshot(composition) { $0.systemProxyApplication.isClearFailure }
|
|
XCTAssertTrue(composition.control.snapshot.systemProxyIntentEnabled)
|
|
XCTAssertTrue(composition.control.snapshot.systemProxyInspection.canRetryClear)
|
|
XCTAssertFalse(composition.control.snapshot.systemProxyInspection.canRepair)
|
|
await emitAndWaitForInspection(.networkConfiguration, in: composition)
|
|
XCTAssertEqual(systemProxy.clearCount, 1)
|
|
systemProxy.clearError = nil
|
|
_ = await composition.control.retrySystemProxyClear()
|
|
XCTAssertEqual(composition.control.snapshot.systemProxyApplication, .paused)
|
|
XCTAssertEqual(systemProxy.clearCount, 2)
|
|
}
|
|
|
|
func testRepairFailureKeepsDifferenceAndApprovalPathUntilExplicitRetry() async throws {
|
|
let composition = try await enabledSystemProxyComposition()
|
|
let original = systemProxy.services[0]
|
|
systemProxy.services[0] = SystemProxyServiceState(
|
|
identifier: original.identifier, configuration: nil, name: original.name)
|
|
_ = await composition.control.recheckSystemProxy()
|
|
systemProxy.beforeRepair = { [systemProxyHelper] in
|
|
systemProxyHelper?.setStatus(.requiresApproval)
|
|
}
|
|
systemProxy.applyError = SystemProxyError.helperUnavailable("approval")
|
|
let failed = await composition.control.repairSystemProxy()
|
|
XCTAssertEqual(failed.systemProxyApplication, .repairFailed(.operation(.helperUnavailable)))
|
|
XCTAssertEqual(failed.systemProxyInspection.differences.map(\.name), ["Wi-Fi"])
|
|
XCTAssertTrue(failed.systemProxyApprovalRequired)
|
|
XCTAssertFalse(failed.systemProxyInspection.canRepair)
|
|
systemProxyHelper.setStatus(.approved)
|
|
systemProxy.beforeRepair = nil
|
|
systemProxy.applyError = nil
|
|
try await waitForSnapshot(composition) { $0.systemProxyInspection.canRepair }
|
|
XCTAssertEqual(systemProxy.applied.count, 1, "批准后失败操作不自动重试")
|
|
_ = await composition.control.repairSystemProxy()
|
|
XCTAssertEqual(composition.control.snapshot.systemProxyApplication, .applied)
|
|
}
|
|
|
|
func testUnmanagedFieldChangeAndEquivalentWritesStayAppliedWithoutWrites() async throws {
|
|
let composition = try await enabledSystemProxyComposition()
|
|
let original = systemProxy.services[0]
|
|
var dictionary = try SystemProxyPlanner.dictionary(
|
|
from: original.configuration, serviceID: "wifi")
|
|
dictionary["ExternalMetadata"] = "unmanaged"
|
|
dictionary.removeValue(forKey: "ProxyAutoDiscoveryEnable")
|
|
dictionary["ExceptionsList"] = (dictionary["ExceptionsList"] as? [String])?.reversed().map {
|
|
$0
|
|
}
|
|
systemProxy.services[0] = SystemProxyServiceState(
|
|
identifier: original.identifier,
|
|
configuration: try SystemProxyPlanner.propertyListData(from: dictionary, serviceID: "wifi"),
|
|
name: original.name)
|
|
let result = await composition.control.recheckSystemProxy()
|
|
XCTAssertEqual(result.systemProxyApplication, .applied)
|
|
XCTAssertTrue(result.systemProxyInspection.differences.isEmpty)
|
|
XCTAssertEqual(systemProxy.applied.count, 1)
|
|
}
|
|
|
|
func testPassiveReadCannotOverwriteHealthSuspension() async throws {
|
|
let probe = ProxyRuntimeFixture.FakeProbe.reachable()
|
|
let composition = try await enabledSystemProxyComposition(probe: probe)
|
|
let gate = ProxyControlOperationGate(started: expectation(description: "read paused"))
|
|
defer { gate.resume() }
|
|
systemProxy.beforeRead = { await gate.wait() }
|
|
let read = Task { await composition.control.recheckSystemProxy() }
|
|
await fulfillment(of: [gate.started], timeout: 2)
|
|
probe.setOutcomes([.refused(detail: "stopped")])
|
|
try await waitForSnapshot(composition) { $0.systemProxyApplication == .paused }
|
|
gate.resume()
|
|
_ = await read.value
|
|
XCTAssertEqual(composition.control.snapshot.systemProxyApplication, .paused)
|
|
XCTAssertEqual(systemProxy.clearCount, 1)
|
|
}
|
|
|
|
func testPassiveReadCannotOverwriteHealthClearFailure() async throws {
|
|
let probe = ProxyRuntimeFixture.FakeProbe.reachable()
|
|
let composition = try await enabledSystemProxyComposition(probe: probe)
|
|
systemProxy.clearError = SystemProxyError.commitFailed("busy")
|
|
let gate = ProxyControlOperationGate(started: expectation(description: "read paused"))
|
|
defer { gate.resume() }
|
|
systemProxy.beforeRead = { await gate.wait() }
|
|
let read = Task { await composition.control.recheckSystemProxy() }
|
|
await fulfillment(of: [gate.started], timeout: 2)
|
|
probe.setOutcomes([.refused(detail: "stopped")])
|
|
try await waitForSnapshot(composition) { $0.systemProxyApplication.isClearFailure }
|
|
gate.resume()
|
|
_ = await read.value
|
|
XCTAssertEqual(
|
|
composition.control.snapshot.systemProxyApplication, .clearFailed(.operation(.commitFailed)))
|
|
XCTAssertTrue(composition.control.snapshot.systemProxyInspection.canRetryClear)
|
|
}
|
|
|
|
func testIntentOffDuringRepairPreflightPreventsWrite() async throws {
|
|
let composition = try await enabledSystemProxyComposition()
|
|
let original = systemProxy.services[0]
|
|
systemProxy.services[0] = SystemProxyServiceState(
|
|
identifier: original.identifier, configuration: nil, name: original.name)
|
|
_ = await composition.control.recheckSystemProxy()
|
|
let gate = ProxyControlOperationGate(started: expectation(description: "read paused"))
|
|
defer { gate.resume() }
|
|
systemProxy.beforeRead = { await gate.wait() }
|
|
let repair = Task { await composition.control.repairSystemProxy() }
|
|
await fulfillment(of: [gate.started], timeout: 2)
|
|
XCTAssertTrue(composition.control.snapshot.systemProxyInspection.isBusy)
|
|
let off = Task { await composition.control.setSystemProxyEnabled(false) }
|
|
try await waitForSnapshot(composition) { !$0.systemProxyIntentEnabled }
|
|
gate.resume()
|
|
_ = await repair.value
|
|
_ = await off.value
|
|
XCTAssertEqual(systemProxy.applied.count, 1)
|
|
XCTAssertEqual(systemProxy.clearCount, 1)
|
|
XCTAssertEqual(composition.control.snapshot.systemProxyApplication, .idle)
|
|
}
|
|
|
|
func testHealthLossDuringRepairPreflightPreventsWrite() async throws {
|
|
let probe = ProxyRuntimeFixture.FakeProbe.reachable()
|
|
let composition = try await enabledSystemProxyComposition(probe: probe)
|
|
let original = systemProxy.services[0]
|
|
systemProxy.services[0] = SystemProxyServiceState(
|
|
identifier: original.identifier, configuration: nil, name: original.name)
|
|
_ = await composition.control.recheckSystemProxy()
|
|
let gate = ProxyControlOperationGate(started: expectation(description: "read paused"))
|
|
defer { gate.resume() }
|
|
systemProxy.beforeRead = { await gate.wait() }
|
|
let repair = Task { await composition.control.repairSystemProxy() }
|
|
await fulfillment(of: [gate.started], timeout: 2)
|
|
XCTAssertTrue(composition.control.snapshot.systemProxyInspection.isBusy)
|
|
probe.setOutcomes([.refused(detail: "stopped")])
|
|
try await waitForSnapshot(composition) { $0.runtime.status != .running }
|
|
gate.resume()
|
|
_ = await repair.value
|
|
try await waitForSnapshot(composition) { $0.systemProxyApplication == .paused }
|
|
XCTAssertEqual(systemProxy.applied.count, 1)
|
|
XCTAssertEqual(systemProxy.clearCount, 1)
|
|
}
|
|
func testAgentOffClearFailureKeepsApprovalEntryAfterCascade() async throws {
|
|
let composition = try await enabledSystemProxyComposition()
|
|
systemProxyHelper.setStatus(.requiresApproval)
|
|
systemProxy.clearError = SystemProxyError.helperUnavailable("approval")
|
|
let failed = await composition.control.setAgentEnabled(false)
|
|
XCTAssertFalse(failed.systemProxyIntentEnabled)
|
|
XCTAssertFalse(failed.agentIntentEnabled)
|
|
XCTAssertEqual(failed.systemProxyApplication, .clearFailed(.operation(.helperUnavailable)))
|
|
XCTAssertTrue(failed.systemProxyApprovalRequired)
|
|
XCTAssertFalse(failed.systemProxyInspection.canRetryClear)
|
|
}
|
|
}
|