// QualityLoadTest.cpp - 吞吐判据(自适应质量的第二判据)单元测试 // // 这个测试直接 include 真实的 common/commands.h,不复制实现。 // 对比:同目录的 QualityAdaptiveTest.cpp 把阈值表和 GetTargetQualityLevel 抄了一份, // 测的是副本 —— 改了 commands.h 它不会失败。新增的判据不要再走那条路。 // // 判据的核心不是"传了多少字节",而是"链路是否拒绝交付要求的东西": // 帧率低于基线,同时字节速率仍贴着该档标称码率,才说明管道满了。 #include #include "commands.h" // 帧率达标时不构成带宽问题,传多少字节都无所谓 TEST(LoadCriterion, NoConstraintWhenFpsHealthy) { EXPECT_EQ(-1, GetTargetQualityLevelByLoad(20, 20, 3000, 3000)); EXPECT_EQ(-1, GetTargetQualityLevelByLoad(12, 20, 5000, 3000)); // 20*0.6=12,刚好达标 } // 最关键的一条:画面变化少的时候帧率和字节速率一起掉,这不是带宽问题。 // 如果只看"帧率低"或只看"字节少",这里就会误降档。 // 判据比的是"每帧字节数",所以 600kbps@8fps(每帧 9.4KB,标称 18.75KB)不会被判成饱和。 TEST(LoadCriterion, LowMotionIsNotCongestion) { EXPECT_EQ(-1, GetTargetQualityLevelByLoad(1, 20, 160, 3000)); // 静止:12.5KB/帧 EXPECT_EQ(-1, GetTargetQualityLevelByLoad(8, 20, 600, 3000)); // 变化少:9.4KB/帧 } // 反过来:帧率低且每帧明显超标称(2 倍以上),才是链路交付不动 TEST(LoadCriterion, OversizedFramesMeanCongestion) { // 2Mbps 链路跑 Good(3000kbps):2fps × 125KB/帧,标称只有 18.75KB/帧 EXPECT_EQ(QUALITY_LOW, GetTargetQualityLevelByLoad(2, 20, 2000, 3000)); // 容量远低于标称码率时(900kbps 跑 3000kbps 档)同样要能判出来 —— // 这正是"用每秒总字节数占比"会漏掉的情形:900/3000 只有 30%,永远到不了"半满"。 EXPECT_EQ(QUALITY_MINIMAL, GetTargetQualityLevelByLoad(2, 20, 900, 3000)); } // 反查表用的是 0.85 余量:kbps*0.85 >= 该档 bitRate 才算装得下 TEST(LoadCriterion, ReverseLookupMatchesBitrateTable) { EXPECT_EQ(QUALITY_MEDIUM, GetTargetQualityLevelByLoad(2, 20, 2400, 3000)); // 2040 >= 2000 EXPECT_EQ(QUALITY_LOW, GetTargetQualityLevelByLoad(2, 20, 2000, 3000)); // 1700 < 2000 EXPECT_EQ(QUALITY_LOW, GetTargetQualityLevelByLoad(2, 20, 1500, 3000)); // 1275 >= 1200 EXPECT_EQ(QUALITY_MINIMAL, GetTargetQualityLevelByLoad(2, 20, 900, 3000)); // 765 < 800 } // Ultra/High 走 DIFF/RGB565,没有码率控制,没有标称码率可比: // 帧率缺口本身就是唯一证据,直接按实测吞吐反查目标档。 // 这正是 RTT 判据抓不到的那一类 —— RTT 20~40ms 时它会选到这两个零码率控制的档位。 TEST(LoadCriterion, ZeroBitrateLevelsTriggerOnFpsAlone) { EXPECT_EQ(QUALITY_LOW, GetTargetQualityLevelByLoad(2, 20, 2000, 0)); } // ===== 慢流量:大帧把链路堵住时,1 秒窗口永远是 0 帧 ===== // // 控制端只在整帧收全后才计数(m_ulFramesThisSecond),一帧要传好几秒时每秒帧数 // 都是 0;而"帧率明显低于基线"是零码率档位唯一的证据 —— 1 秒样本为空就等于判据 // 弃权,档位永远降不下来(实测现场:Ultra/High 之间来回翻,帧率 0~1)。 // 改用最近 N 秒的窗口均值,0.3fps 这种速率才能表达出来。 TEST(LoadCriterion, SlowStreamUsesWindowedSample) { int fps = 0, baseline = 0, kbps = 0; // 10 秒窗口里只有 3 帧、12MB → 0.3fps、基线 8fps、≈9.8Mbps GetWindowedLoadSample(3, 12ULL * 1024 * 1024, 10, 8, fps, baseline, kbps); EXPECT_EQ(30, fps); // 放大 100 倍表示 0.3fps EXPECT_EQ(800, baseline); // 基线同步放大,比值不变 EXPECT_EQ(9830, kbps); // 这个样本喂给判据:帧率缺口成立,实测吞吐装得下 Good EXPECT_EQ(QUALITY_GOOD, GetTargetQualityLevelByLoad(fps, baseline, kbps, 0)); // 同一段流量按"每秒"去看,堵住的那几秒一帧都没有 → 判据弃权(这就是原来的死结) EXPECT_EQ(-1, GetTargetQualityLevelByLoad(0, 8, 0, 0)); } // 画面静止时客户端 memcmp 跳帧,窗口里同样一帧都没有:不能因为"没帧"就降档。 TEST(LoadCriterion, IdleWindowIsNotCongestion) { int fps = 99, baseline = 99, kbps = 99; GetWindowedLoadSample(0, 0, 10, 8, fps, baseline, kbps); EXPECT_EQ(0, fps); EXPECT_EQ(-1, GetTargetQualityLevelByLoad(fps, baseline, kbps, 0)); } // ===== 窗口样本的可用性:三种"看着像拥塞其实不是"的现场 ===== // // 窗口均值本身分不清"链路交付不动"和"内容本来就一阵一阵的"。直接喂给判据, // 滚动一下停住就会把 LAN 上的 Ultra 降成 Good —— 评审里的假阳性。 // 判定在 GetCongestedLoadSample 里,下面逐个现场验证。 // ① 滚动 3 秒(22 帧)然后停住:窗口均值是"1fps + 22Mbps",但没有任何一秒 // 交付过满速之外的证据 —— 恰恰相反,那些秒都跑在 8fps 附近,链路没问题。 TEST(LoadCriterion, ScrollThenIdleIsNotCongestion) { int f = 0, b = 0, k = 0; EXPECT_FALSE(GetCongestedLoadSample(22, 22ULL * 1024 * 1024, 3, 8, 10, 3, 8, 64 * 1024, f, b, k)); } // ② 一个大帧闪了一下(开个窗口、翻一页),谈不上"持续交付不动" TEST(LoadCriterion, SingleFrameIsNotCongestion) { int f = 0, b = 0, k = 0; EXPECT_FALSE(GetCongestedLoadSample(1, 4ULL * 1024 * 1024, 1, 1, 10, 1, 8, 64 * 1024, f, b, k)); EXPECT_FALSE(GetCongestedLoadSample(2, 8ULL * 1024 * 1024, 1, 2, 10, 1, 8, 64 * 1024, f, b, k)); } // 短促突发:3 帧全挤在同一秒(滚一下鼠标、开个窗口),链路一秒就交完了。 // 只看帧数和"最忙那秒有没有到 0.6 基线"(3 < 4.8)都会误判,靠"至少散布在 3 个 // 不同的秒里"挡掉 —— 这一条正是「滚动一下停住」最常见的形态。 TEST(LoadCriterion, ShortBurstInOneSecondIsNotCongestion) { int f = 0, b = 0, k = 0; EXPECT_FALSE(GetCongestedLoadSample(3, 12ULL * 1024 * 1024, 1, 3, 10, 1, 8, 64 * 1024, f, b, k)); // 同样这 3 帧散在 3 个秒里 → 才是"持续交付不动" EXPECT_TRUE (GetCongestedLoadSample(3, 12ULL * 1024 * 1024, 3, 1, 10, 1, 8, 64 * 1024, f, b, k)); } // ③ 最后一帧已经过去 5 秒:窗口里剩的是停顿前的流量,不能拿它判现在 TEST(LoadCriterion, StaleWindowIsNotCongestion) { int f = 0, b = 0, k = 0; EXPECT_FALSE(GetCongestedLoadSample(3, 12ULL * 1024 * 1024, 3, 1, 10, 5, 8, 64 * 1024, f, b, k)); } // 现场本身:0.3fps、每帧 4MB、最后一帧刚过去 2 秒 → 可用,且判据给出 Good TEST(LoadCriterion, SteadySlowStreamIsCongestion) { int f = 0, b = 0, k = 0; ASSERT_TRUE(GetCongestedLoadSample(3, 12ULL * 1024 * 1024, 3, 1, 10, 2, 8, 64 * 1024, f, b, k)); EXPECT_EQ(30, f); // 0.3fps EXPECT_EQ(800, b); // 基线 8fps EXPECT_EQ(9830, k); EXPECT_EQ(QUALITY_GOOD, GetTargetQualityLevelByLoad(f, b, k, 0)); } // 边界:某一秒交付到 0.6 基线(8fps 的 0.6 = 4.8 帧)就算"链路能交付满速", // 不算拥塞。5 帧拒绝、4 帧通过。 TEST(LoadCriterion, BusiestSecondAtThresholdRejects) { int f = 0, b = 0, k = 0; EXPECT_FALSE(GetCongestedLoadSample(20, 20ULL * 1024 * 1024, 10, 5, 10, 1, 8, 0, f, b, k)); EXPECT_TRUE (GetCongestedLoadSample(20, 20ULL * 1024 * 1024, 10, 4, 10, 1, 8, 0, f, b, k)); } // 小帧下限只对没有码率控制的档位生效:H264 档位由判据自己的"每帧是否明显超过 // 标称"把关,再加一道绝对下限会误伤小屏/慢链路(1024×768 的 30KB 增量帧 // 在 300kbps 上确实堵,但它不是"几 KB 的时钟补丁")。 TEST(LoadCriterion, MinFrameBytesOnlyForRawLevels) { int f = 0, b = 0, k = 0; // 4 帧 × 2KB 的小补丁:raw 档判不了,H264 档交给判据 EXPECT_FALSE(GetCongestedLoadSample(4, 8ULL * 1024, 4, 2, 10, 1, 8, 64 * 1024, f, b, k)); EXPECT_TRUE (GetCongestedLoadSample(4, 8ULL * 1024, 4, 2, 10, 1, 8, 0, f, b, k)); } // ===== 1 秒样本(窗口不可用时的退路)===== // // 窗口被拒之后不能直接拿 1 秒计数去判:同一道小帧下限必须一起过,否则窗口路径 // 挡掉的「静止桌面上的时钟补丁」会从这条路原样走回来,把 LAN 上的 Ultra 压成 // Minimal。这正是评审挑出来的漏洞。 TEST(LoadCriterion, SecondSampleAppliesMinFrameBytes) { int f = 0, b = 0, k = 0; // raw 档、1 帧/s、每帧 1KB 的时钟补丁 → 不可用 EXPECT_FALSE(GetSecondLoadSample(1, 1024, 1000, 16, 64 * 1024, f, b, k)); // 真拥塞:2 帧/s、每帧 125KB(2Mbps 上跑 Ultra)→ 可用,判据能反查出低档 ASSERT_TRUE(GetSecondLoadSample(2, 250ULL * 1024, 1000, 16, 64 * 1024, f, b, k)); EXPECT_EQ(200, f); // 2fps EXPECT_EQ(1600, b); EXPECT_EQ(2000, k); // 250KB/s ≈ 2000kbps EXPECT_EQ(QUALITY_LOW, GetTargetQualityLevelByLoad(f, b, k, 0)); // 有码率控制的档位不设绝对下限:小帧交给判据自己的「每帧是否超过标称」把关 ASSERT_TRUE(GetSecondLoadSample(1, 1024, 1000, 16, 0, f, b, k)); EXPECT_EQ(100, f); EXPECT_EQ(8, k); } // 定时器被 UI 阻塞推迟时,一格代表的不止一秒:速率要按实际毫秒数摊开, // 否则 2 秒里到的 2 帧会被算成 2fps,帧率缺口被抹平、拥塞漏判。 TEST(LoadCriterion, SecondSampleScalesByElapsedTime) { int f = 0, b = 0, k = 0; ASSERT_TRUE(GetSecondLoadSample(2, 250ULL * 1024, 2000, 16, 0, f, b, k)); EXPECT_EQ(100, f); // 1fps EXPECT_EQ(1000, k); // 125KB/s // 同一批字节按 1 秒算会得出 2fps/2000kbps(→ Low),按真实的 2 秒摊开是 // 1fps/1000kbps(→ Minimal):不按实际时长归一,就会把拥塞程度看轻一档。 EXPECT_EQ(QUALITY_MINIMAL, GetTargetQualityLevelByLoad(f, b, k, 3000)); } TEST(LoadCriterion, SecondSampleRejectsMissingData) { int f = 99, b = 99, k = 99; EXPECT_FALSE(GetSecondLoadSample(0, 1024, 1000, 16, 0, f, b, k)); // 一帧都没有 EXPECT_FALSE(GetSecondLoadSample(1, 0, 1000, 16, 0, f, b, k)); // 没有吞吐 EXPECT_FALSE(GetSecondLoadSample(1, 1024, 0, 16, 0, f, b, k)); // 时长未知 EXPECT_FALSE(GetSecondLoadSample(1, 1024, 1000, 0, 0, f, b, k)); // 基线未学到 EXPECT_FALSE(GetSecondLoadSample(10001, 1024, 1000, 16, 0, f, b, k)); // 帧数异常 EXPECT_EQ(0, f); // 被拒绝时输出一律清零,调用方不会拿到半份样本 EXPECT_EQ(0, k); } // ===== 本机瓶颈判定 ===== // // 「帧率低 + 帧不大」在画面静止时同样成立(客户端 memcmp 跳帧),必须要求最近 // 一秒真的在发帧 —— 否则一次静止就把吞吐判据永久停用。 TEST(LoadCriterion, LocalBottleneckNeedsActiveScreen) { // 静止:窗口样本是「1fps + 小帧」,最后一个完整秒只有 1 帧 → 证据不足 EXPECT_FALSE(IsLocalBottleneck(100, 1600, 10, 3000, 1)); // 本机慢:2fps、每帧 32KB(标称每帧 24KB,没到 2 倍)→ 帧发得出来却不多 → 本机 EXPECT_TRUE(IsLocalBottleneck(200, 1600, 500, 3000, 2)); // 链路拥塞:2fps 但每帧 125KB(标称 2 倍以上)→ 是带宽问题,不能停用吞吐判据 EXPECT_FALSE(IsLocalBottleneck(200, 1600, 2000, 3000, 8)); // 帧率本来就不低 EXPECT_FALSE(IsLocalBottleneck(1600, 1600, 500, 3000, 16)); } // 缺数据一律不可用 TEST(LoadCriterion, CongestedSampleRejectsMissingData) { int f = 0, b = 0, k = 0; EXPECT_FALSE(GetCongestedLoadSample(0, 0, 0, 0, 10, 1, 8, 0, f, b, k)); // 窗口里没有帧 EXPECT_FALSE(GetCongestedLoadSample(5, 5ULL << 20, 5, 1, 0, 1, 8, 0, f, b, k));// 没有秒数 EXPECT_FALSE(GetCongestedLoadSample(5, 5ULL << 20, 5, 1, 10, -1, 8, 0, f, b, k));// 从没收到过帧 EXPECT_FALSE(GetCongestedLoadSample(5, 5ULL << 20, 5, 1, 10, 1, 0, 0, f, b, k));// 基线未学到 } // 窗口还没填满时按已填入的秒数做分母,不能按 10 秒算(会把速率摊薄成 1/5) TEST(LoadCriterion, PartiallyFilledWindow) { int fps = 0, baseline = 0, kbps = 0; GetWindowedLoadSample(2, 2ULL * 1024 * 1024, 2, 8, fps, baseline, kbps); EXPECT_EQ(100, fps); // 1fps EXPECT_EQ(800, baseline); EXPECT_EQ(8192, kbps); // 2MB / 2s } // 数据不全时一律返回"无约束",绝不能因为缺数据就降档 TEST(LoadCriterion, InvalidInputsAreNoConstraint) { EXPECT_EQ(-1, GetTargetQualityLevelByLoad(2, 0, 2000, 3000)); // 基线未学到 EXPECT_EQ(-1, GetTargetQualityLevelByLoad(0, 20, 2000, 3000)); // 一帧都没收到 EXPECT_EQ(-1, GetTargetQualityLevelByLoad(-1, 20, 2000, 3000)); // 帧数异常 EXPECT_EQ(-1, GetTargetQualityLevelByLoad(2, 20, -1, 3000)); // 速率异常 // 没有实测吞吐时不能反查目标档,否则零码率控制的档位会误返回最低档 EXPECT_EQ(-1, GetTargetQualityLevelByLoad(2, 20, 0, 0)); } // 与 RTT 判据的合并语义:取更保守者(档位数字越大越差)。 // 这里验证两个判据各自的结果可以简单用 max 组合 —— 加权平均会让"RTT 好"掩盖"带宽窄"。 TEST(LoadCriterion, CombineWithRttByMax) { // 短 RTT(20ms 直连 → ULTRA)但链路只有 2Mbps → 吞吐判据说了算 int levelRtt = GetTargetQualityLevel(20, 0); int levelLoad = GetTargetQualityLevelByLoad(2, 20, 2000, 0); EXPECT_EQ(QUALITY_ULTRA, levelRtt); EXPECT_EQ(QUALITY_LOW, levelLoad); EXPECT_EQ(QUALITY_LOW, (levelRtt > levelLoad) ? levelRtt : levelLoad); // 长 RTT(400ms 直连 → MINIMAL)但链路很宽 → RTT 判据说了算 levelRtt = GetTargetQualityLevel(400, 0); levelLoad = GetTargetQualityLevelByLoad(20, 20, 20000, 3000); EXPECT_EQ(QUALITY_MINIMAL, levelRtt); EXPECT_EQ(-1, levelLoad); EXPECT_EQ(QUALITY_MINIMAL, (levelRtt > levelLoad) ? levelRtt : levelLoad); } // ===== 迟滞:防止 RTT 在阈值边界上抖动导致档位反复切换 ===== // // 直连阈值表 {30, 80, 150, 250, 400}。当前档 2(Good) 的两个边界: // 升到 1(High):rtt 必须 < 80*0.85 = 68 // 降到 3(Medium):rtt 必须 > 150*1.15 = 172.5 // 也就是说 rtt 落在 [68, 172] 这段死区里,档位保持不动。 TEST(RttHysteresis, DeadZoneHoldsCurrentLevel) { // 死区里:raw 已经指向相邻档,但没到"明显变好/变坏",保持不动 EXPECT_EQ(2, GetTargetQualityLevelHysteresis(70, 0, 2)); // raw=1,70 >= 68 EXPECT_EQ(2, GetTargetQualityLevelHysteresis(79, 0, 2)); EXPECT_EQ(2, GetTargetQualityLevelHysteresis(160, 0, 2)); // raw=3,160 <= 172 EXPECT_EQ(2, GetTargetQualityLevelHysteresis(150, 0, 2)); } // 越过死区才允许动作 TEST(RttHysteresis, OutsideDeadZoneMoves) { EXPECT_EQ(1, GetTargetQualityLevelHysteresis(60, 0, 2)); // 60 < 68 → 升档 EXPECT_EQ(3, GetTargetQualityLevelHysteresis(180, 0, 2)); // 180 > 172 → 降档 // 一次跳多级是允许的:RTT 骤降时没必要逐级爬 EXPECT_EQ(5, GetTargetQualityLevelHysteresis(1000, 0, 2)); EXPECT_EQ(0, GetTargetQualityLevelHysteresis(20, 0, 2)); } // 同一 RTT 下,迟滞结果永远不比无迟滞结果更激进(只能保持或更保守) TEST(RttHysteresis, NeverMovesBeforeRawLevel) { for (int rtt = 5; rtt <= 900; rtt += 5) { int raw = GetTargetQualityLevel(rtt, 0); for (int cur = 0; cur < QUALITY_COUNT; cur++) { int h = GetTargetQualityLevelHysteresis(rtt, 0, cur); if (h < cur) EXPECT_GE(h, raw); // 升档不会越过 raw if (h > cur) EXPECT_LE(h, raw); // 降档不会越过 raw } } } // 已经稳定的档位不该被迟滞推走;缺数据时保持不动 TEST(RttHysteresis, StableAndInvalidInputs) { EXPECT_EQ(1, GetTargetQualityLevelHysteresis(70, 0, 1)); // raw == current EXPECT_EQ(5, GetTargetQualityLevelHysteresis(9999, 0, 5)); EXPECT_EQ(2, GetTargetQualityLevelHysteresis(0, 0, 2)); // rtt 取不到 EXPECT_EQ(2, GetTargetQualityLevelHysteresis(-1, 0, 2)); // currentLevel 非法时退化成无迟滞版本 EXPECT_EQ(1, GetTargetQualityLevelHysteresis(70, 0, 99)); } // FRP 阈值表更宽松({60,160,300,500,800}),死区跟着一起放宽 TEST(RttHysteresis, FrpTableIsWider) { // FRP 下当前档 2 的死区是 [160*0.85, 300*1.15] = [136, 345] EXPECT_EQ(2, GetTargetQualityLevelHysteresis(140, 1, 2)); // raw=1,但 140 >= 136 EXPECT_EQ(1, GetTargetQualityLevelHysteresis(120, 1, 2)); EXPECT_EQ(2, GetTargetQualityLevelHysteresis(320, 1, 2)); EXPECT_EQ(3, GetTargetQualityLevelHysteresis(360, 1, 2)); }