chore: import upstream snapshot with attribution

2026-07-13 12:22:33 +08:00
commit fc4fcbab58
1848 changed files with 472303 additions and 0 deletions
@@ -0,0 +1,141 @@
+import AdaptiveReplayKit
+import Foundation
+import Testing
+
+struct CodingActivityReplayPolicyTests {
+    private static let now = Date(timeIntervalSinceReferenceDate: 10000)
+
+    private func input(
+        menuAge: TimeInterval?,
+        activityAge: TimeInterval?,
+        constrained: Bool = false) -> ReplayPolicyInput
+    {
+        ReplayPolicyInput(
+            now: Self.now,
+            lastMenuOpenAt: menuAge.map { Self.now.addingTimeInterval(-$0) },
+            lastCodingActivityAt: activityAge.map { Self.now.addingTimeInterval(-$0) },
+            lowPowerModeEnabled: constrained,
+            thermalState: .nominal)
+    }
+
+    @Test
+    func `active coding caps idle and long-idle decisions at five minutes`() {
+        let policy = CodingActivityAdaptivePolicy()
+
+        #expect(policy.name == "adaptive-activity")
+        #expect(policy.decide(self.input(menuAge: 2 * 3600, activityAge: 10)).delaySeconds == 300)
+        #expect(policy.decide(self.input(menuAge: nil, activityAge: 10)).delaySeconds == 300)
+        #expect(policy.decide(self.input(menuAge: nil, activityAge: 10)).reason == "codingActivity")
+    }
+
+    @Test
+    func `existing recent and warm decisions remain unchanged`() {
+        let policy = CodingActivityAdaptivePolicy()
+
+        #expect(policy.decide(self.input(menuAge: 60, activityAge: 10)).delaySeconds == 120)
+        #expect(policy.decide(self.input(menuAge: 600, activityAge: 10)).delaySeconds == 300)
+    }
+
+    @Test
+    func `constrained state wins and exact threshold is inactive`() {
+        let policy = CodingActivityAdaptivePolicy()
+
+        #expect(policy.decide(self.input(menuAge: nil, activityAge: 10, constrained: true)).delaySeconds == 1800)
+        #expect(policy.decide(self.input(menuAge: nil, activityAge: 300)).delaySeconds == 1800)
+        #expect(policy.decide(self.input(menuAge: nil, activityAge: nil)).delaySeconds == 1800)
+    }
+
+    @Test
+    func `future activity samples never backfill an earlier replay decision`() {
+        let trace: [AdaptiveRefreshTraceRecord] = [
+            .decision(
+                timestamp: Self.now,
+                menuAgeSeconds: nil,
+                lowPowerModeEnabled: false,
+                thermalState: .nominal,
+                reason: "longIdle",
+                delaySeconds: 1800),
+            .decision(
+                timestamp: Self.now.addingTimeInterval(600),
+                menuAgeSeconds: nil,
+                lowPowerModeEnabled: false,
+                thermalState: .nominal,
+                reason: "longIdle",
+                delaySeconds: 1800,
+                codexActivitySeconds: 0),
+        ]
+
+        let metrics = ReplayEngine.run(trace: trace, policy: CodingActivityAdaptivePolicy())
+
+        #expect(metrics.codingActiveDecisionCount == 0)
+        #expect(metrics.totalRefreshCount == 0)
+    }
+
+    @Test
+    func `a newer unavailable observation invalidates older activity`() {
+        let trace: [AdaptiveRefreshTraceRecord] = [
+            .menuOpen(timestamp: Self.now),
+            .decision(
+                timestamp: Self.now,
+                menuAgeSeconds: 0,
+                lowPowerModeEnabled: false,
+                thermalState: .nominal,
+                reason: "recentInteraction",
+                delaySeconds: 120,
+                codexActivitySeconds: 0),
+            .decision(
+                timestamp: Self.now.addingTimeInterval(100),
+                menuAgeSeconds: 100,
+                lowPowerModeEnabled: false,
+                thermalState: .nominal,
+                reason: "recentInteraction",
+                delaySeconds: 120),
+            .refreshCompleted(timestamp: Self.now.addingTimeInterval(240)),
+        ]
+
+        let metrics = ReplayEngine.run(trace: trace, policy: CodingActivityAdaptivePolicy())
+
+        #expect(metrics.totalRefreshCount == 2)
+        #expect(metrics.codingActiveDecisionCount == 1)
+    }
+
+    @Test
+    func `active compliance denominator excludes constrained decisions`() {
+        let trace: [AdaptiveRefreshTraceRecord] = [
+            .decision(
+                timestamp: Self.now,
+                menuAgeSeconds: nil,
+                lowPowerModeEnabled: true,
+                thermalState: .nominal,
+                reason: "constrained",
+                delaySeconds: 1800,
+                codexActivitySeconds: 0),
+            .refreshCompleted(timestamp: Self.now.addingTimeInterval(1800)),
+        ]
+
+        let metrics = ReplayEngine.run(trace: trace, policy: CodingActivityAdaptivePolicy())
+
+        #expect(metrics.codingActiveDecisionCount == 0)
+        #expect(metrics.codingActiveDelayViolationCount == 0)
+    }
+
+    @Test
+    func `manual policy counts as slower than the active freshness cap`() {
+        let trace: [AdaptiveRefreshTraceRecord] = [
+            .decision(
+                timestamp: Self.now,
+                menuAgeSeconds: nil,
+                lowPowerModeEnabled: false,
+                thermalState: .nominal,
+                reason: "longIdle",
+                delaySeconds: 1800,
+                codexActivitySeconds: 0),
+            .refreshCompleted(timestamp: Self.now.addingTimeInterval(600)),
+        ]
+
+        let metrics = ReplayEngine.run(trace: trace, policy: ManualPolicy())
+
+        #expect(metrics.codingActiveDecisionCount == 1)
+        #expect(metrics.codingActiveDelayViolationCount == 1)
+    }
+}