mirror of
https://github.com/kunkundi/crossdesk.git
synced 2026-10-16 00:33:22 +08:00
194 lines
11 KiB
Python
194 lines
11 KiB
Python
"""Exercise production statistics with deterministic monotonic time."""
|
|
|
|
from pathlib import Path
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
|
|
|
|
@unittest.skipUnless(sys.platform == "darwin", "requires the Apple Swift runtime")
|
|
class NetworkStatisticsTest(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.temp = tempfile.TemporaryDirectory(prefix="crossdesk-network-statistics-")
|
|
cls.addClassCleanup(cls.temp.cleanup)
|
|
root = Path(cls.temp.name)
|
|
harness = root / "NetworkStatisticsTests.swift"
|
|
harness.write_text(r'''
|
|
import Foundation
|
|
|
|
func expect(_ condition: @autoclosure () -> Bool, _ message: String) {
|
|
if !condition() { fatalError(message) }
|
|
}
|
|
|
|
func near(_ value: Double?, _ expected: Double) -> Bool {
|
|
guard let value else { return false }
|
|
return abs(value - expected) < 0.0001
|
|
}
|
|
|
|
@main
|
|
enum NetworkStatisticsTests {
|
|
static func main() {
|
|
var state = RemoteNetworkStatistics()
|
|
var report = RemoteNetworkReport(
|
|
video: RemoteTrafficStatistics(inboundBitrate: 8_000_000, outboundBitrate: 0, lossRate: 0.02),
|
|
audio: RemoteTrafficStatistics(inboundBitrate: 64_000, outboundBitrate: 0, lossRate: 0.01),
|
|
data: RemoteTrafficStatistics(inboundBitrate: 2_000, outboundBitrate: 3_000, lossRate: 0.03),
|
|
total: RemoteTrafficStatistics(inboundBitrate: 8_066_000, outboundBitrate: 3_000, lossRate: 0.06),
|
|
mode: .relay, srtpActive: true, rttMilliseconds: 20
|
|
)
|
|
let test = CommandLine.arguments[1]
|
|
if test == "report" {
|
|
expect(state.snapshot(at: 10).report == nil, "No measurements before a report")
|
|
expect(state.snapshot(at: 10).connectionMode == "—", "Unknown is not P2P")
|
|
state.receive(report, at: 10)
|
|
let snapshot = state.snapshot(at: 10)
|
|
expect(snapshot.report?.video.inboundBitrate == 8_000_000, "Video rate survives")
|
|
expect(snapshot.report?.audio.inboundBitrate == 64_000, "Audio rate survives")
|
|
expect(snapshot.report?.data.outboundBitrate == 3_000, "Data upload survives")
|
|
expect(snapshot.report?.total.inboundBitrate == 8_066_000, "Total is transport-provided")
|
|
expect(snapshot.report?.audio.lossRate == 0.01, "Media loss stays separate")
|
|
expect(snapshot.report?.srtpActive == true && snapshot.connectionMode == "TURN 中继", "Actual security and route")
|
|
report.mode = .direct
|
|
report.srtpActive = false
|
|
state.receive(report, at: 11)
|
|
expect(state.snapshot(at: 11).connectionMode == "P2P 直连", "Route updates")
|
|
expect(state.snapshot(at: 11).report?.srtpActive == false, "Security is not inferred from connection")
|
|
} else if test == "expiry" {
|
|
state.receive(report, at: 10)
|
|
expect(state.snapshot(at: 12.99).report != nil, "One missed report does not flicker")
|
|
let expired = state.snapshot(at: 13)
|
|
expect(expired.report == nil && expired.rttMilliseconds == nil, "Stalled reports expire")
|
|
expect(expired.connectionMode == "—", "Stale route expires")
|
|
state = RemoteNetworkStatistics()
|
|
expect(state.snapshot(at: 13).report == nil, "Reconnect clears prior peer")
|
|
} else if test == "rtt" {
|
|
state.receive(report, at: 10)
|
|
report.rttMilliseconds = 100
|
|
state.receive(report, at: 11)
|
|
expect(near(state.snapshot(at: 11).rttMilliseconds, 40), "Desktop EWMA alpha is 0.25")
|
|
for invalid in [-1.0, Double.nan, Double.infinity, 2_001] {
|
|
report.rttMilliseconds = invalid
|
|
state.receive(report, at: 12)
|
|
expect(near(state.snapshot(at: 12).rttMilliseconds, 40), "Invalid RTT cannot contaminate average")
|
|
}
|
|
expect(state.snapshot(at: 14).rttMilliseconds == nil, "Invalid reports cannot keep RTT alive")
|
|
expect(state.snapshot(at: 14).report != nil, "Traffic and RTT expire independently")
|
|
report.rttMilliseconds = 0
|
|
state.receive(report, at: 15)
|
|
expect(near(state.snapshot(at: 15).rttMilliseconds, 0), "Zero RTT is valid; expired average is replaced")
|
|
} else if test == "frames" {
|
|
state.recordSubmittedFrame(id: 1, captureUptime: 9.9, at: 10)
|
|
state.recordSubmittedFrame(id: 1, captureUptime: 9.9, at: 10.1)
|
|
state.recordSubmittedFrame(id: 2, captureUptime: 10, at: 10.2)
|
|
let snapshot = state.snapshot(at: 10.3)
|
|
expect(snapshot.framesPerSecond == 2, "Redrawing a frame is not FPS")
|
|
expect(near(snapshot.videoLatencyMilliseconds, 150), "Average includes time through display submission")
|
|
expect(state.snapshot(at: 11).framesPerSecond == 1, "One-second rolling window")
|
|
expect(state.snapshot(at: 11.3).framesPerSecond == 0, "Idle video must reach zero FPS")
|
|
expect(state.snapshot(at: 11.3).videoLatencyMilliseconds == nil, "Idle latency expires")
|
|
} else if test == "video_reset" {
|
|
state.receive(report, at: 10)
|
|
state.recordSubmittedFrame(id: 1, captureUptime: 9.9, at: 10)
|
|
state.resetVideo()
|
|
state.recordSubmittedFrame(id: 1, captureUptime: 9.9, at: 10.1)
|
|
expect(state.snapshot(at: 10.1).framesPerSecond == 0, "Foreground cached frame is not counted again")
|
|
expect(state.snapshot(at: 10.1).report != nil, "Switching displays preserves transport stats")
|
|
state.recordSubmittedFrame(id: 2, captureUptime: 0, at: 10.2)
|
|
state.recordSubmittedFrame(id: 3, captureUptime: 12, at: 10.3)
|
|
state.recordSubmittedFrame(id: 4, captureUptime: 1, at: 10.4)
|
|
state.recordSubmittedFrame(id: 5, captureUptime: .nan, at: 10.5)
|
|
expect(state.snapshot(at: 10.5).framesPerSecond == 4, "Uncalibrated frames still count for FPS")
|
|
expect(state.snapshot(at: 10.5).videoLatencyMilliseconds == nil, "Invalid capture estimates are unavailable")
|
|
state.recordSubmittedFrame(id: 6, captureUptime: 10.5, at: 10.6)
|
|
expect(near(state.snapshot(at: 10.6).videoLatencyMilliseconds, 100), "Calibration recovers without invalid samples")
|
|
} else if test == "display_cadence" {
|
|
state.receive(report, at: 10)
|
|
state.recordSubmittedFrame(id: 1, captureUptime: 9.9, at: 10)
|
|
let first = state.displaySnapshot(at: 10)
|
|
expect(near(first.videoLatencyMilliseconds, 100), "Initial display sample")
|
|
for frame in 1...59 {
|
|
let now = 10 + Double(frame) / 60
|
|
let delay = frame.isMultiple(of: 2) ? 0.3 : 0.2
|
|
state.recordSubmittedFrame(id: UInt64(frame + 1), captureUptime: now - delay, at: now)
|
|
report.rttMilliseconds = 100
|
|
report.total.inboundBitrate = 9_000_000
|
|
state.receive(report, at: now)
|
|
let displayed = state.displaySnapshot(at: now)
|
|
expect(near(displayed.videoLatencyMilliseconds, 100), "60 FPS callbacks cannot refresh the displayed delay")
|
|
expect(displayed.framesPerSecond == first.framesPerSecond, "FPS is sampled with delay")
|
|
expect(near(displayed.rttMilliseconds, 20), "RTT is frozen between ticks")
|
|
expect(displayed.report?.total.inboundBitrate == 8_066_000, "Reports are sampled with video stats")
|
|
}
|
|
let next = state.displaySnapshot(at: 11)
|
|
expect(next.framesPerSecond == 59, "The next tick samples all recent frames")
|
|
expect((next.videoLatencyMilliseconds ?? 0) > 200, "Delay updates at the one-second boundary")
|
|
expect(next.report?.total.inboundBitrate == 9_000_000, "The next tick sees current traffic")
|
|
let idle = state.displaySnapshot(at: 12)
|
|
expect(idle.framesPerSecond == 0 && idle.videoLatencyMilliseconds == nil, "Timer ticks expire idle video without new frames")
|
|
let expired = state.displaySnapshot(at: 14)
|
|
expect(expired.report == nil && expired.rttMilliseconds == nil, "Timer ticks expire missing reports")
|
|
} else if test == "display_reset" {
|
|
state.receive(report, at: 10)
|
|
state.recordSubmittedFrame(id: 1, captureUptime: 9.9, at: 10)
|
|
_ = state.displaySnapshot(at: 10)
|
|
state.resetVideo()
|
|
let switched = state.displaySnapshot(at: 10.1)
|
|
expect(switched.framesPerSecond == 0 && switched.videoLatencyMilliseconds == nil, "Switching displays clears cached video immediately")
|
|
expect(switched.report != nil, "Video reset keeps transport state")
|
|
state = RemoteNetworkStatistics()
|
|
let reconnected = state.displaySnapshot(at: 10.2)
|
|
expect(reconnected.report == nil && reconnected.videoLatencyMilliseconds == nil, "A new session cannot reuse the old display cache")
|
|
} else if test == "format" {
|
|
expect(RemoteNetworkSnapshot.bitrate(nil) == "—", "Unavailable is not zero")
|
|
expect(RemoteNetworkSnapshot.bitrate(0) == "0 bps", "Zero traffic is valid")
|
|
expect(RemoteNetworkSnapshot.bitrate(64_000) == "64 Kbps", "Bitrate units")
|
|
expect(RemoteNetworkSnapshot.bitrate(8_000_000) == "8.0 Mbps", "Mbps units")
|
|
expect(RemoteNetworkSnapshot.latency(0) == "<1 ms", "Sub-millisecond RTT")
|
|
expect(RemoteNetworkSnapshot.latency(nil) == "—", "Missing calibration")
|
|
expect(RemoteNetworkSnapshot.lossRate(0.005) == "0.5%", "Small losses remain visible")
|
|
expect(RemoteNetworkSnapshot.lossRate(1.2) == "120.0%", "Desktop aggregate is not silently clamped")
|
|
expect(RemoteNetworkSnapshot.lossRate(.nan) == "—", "Nonfinite loss is unavailable")
|
|
} else {
|
|
fatalError("Unknown test")
|
|
}
|
|
}
|
|
}
|
|
''')
|
|
source = Path(__file__).resolve().parents[1] / "CrossDeskMobile/RemoteNetworkStatistics.swift"
|
|
cls.binary = root / "network-statistics-tests"
|
|
subprocess.run(["xcrun", "swiftc", str(source), str(harness), "-o", str(cls.binary)],
|
|
check=True, capture_output=True, text=True)
|
|
|
|
def test_channel_and_security_reports(self):
|
|
self.run_case("report")
|
|
|
|
def test_missing_reports_and_reconnect(self):
|
|
self.run_case("expiry")
|
|
|
|
def test_rtt_smoothing_and_recovery(self):
|
|
self.run_case("rtt")
|
|
|
|
def test_frame_submission_and_idle_video(self):
|
|
self.run_case("frames")
|
|
|
|
def test_display_switch_and_invalid_capture_time(self):
|
|
self.run_case("video_reset")
|
|
|
|
def test_units_and_unavailable_values(self):
|
|
self.run_case("format")
|
|
|
|
def test_display_refresh_is_independent_of_video_frames(self):
|
|
self.run_case("display_cadence")
|
|
|
|
def test_display_cache_resets_with_video_and_session(self):
|
|
self.run_case("display_reset")
|
|
|
|
def run_case(self, name):
|
|
subprocess.run([str(self.binary), name], check=True, capture_output=True, text=True)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|