add smoke test

2026-04-12 01:26:41 +08:00
parent 843b8762f6
commit eb79be87a4
9 changed files with 950 additions and 56 deletions
@@ -0,0 +1,586 @@
+/*
+ * Oak Video Editor - Viewer/Preview Subsystem Smoke Tests
+ * Copyright (C) 2025 Olive CE Team
+ *
+ * Comprehensive smoke tests for the viewer and preview display subsystem including:
+ * - ViewerPlaybackTimer timing calculations
+ * - ViewerQueue frame management
+ * - ViewerSafeMarginInfo safety margin calculations
+ * - PreviewAutoCacher cache management
+ */
+
+#include <gtest/gtest.h>
+
+#include <QThread>
+#include <QElapsedTimer>
+
+// Viewer headers
+#include "widget/viewer/viewerplaybacktimer.h"
+#include "widget/viewer/viewerqueue.h"
+#include "widget/viewer/viewersafemargininfo.h"
+#include "render/previewautocacher.h"
+#include "render/audioplaybackcache.h"
+#include "olive/core/util/rational.h"
+
+using namespace olive;
+using namespace olive::core;
+
+namespace olive {
+namespace viewer {
+namespace test {
+
+// ============================================================================
+// Smoke Test: ViewerPlaybackTimer
+// ============================================================================
+
+TEST(ViewerSmokeTimer, DefaultConstruction)
+{
+    ViewerPlaybackTimer timer;
+    // Timer should be in a valid but not-started state
+    // After Start() is called, it should return valid timestamps
+}
+
+TEST(ViewerSmokeTimer, BasicTiming)
+{
+    ViewerPlaybackTimer timer;
+    
+    // Start at timestamp 0, 1x speed, 24fps (timebase = 1/24)
+    timer.Start(0, 1, 1.0 / 24.0);
+    
+    // Immediately get timestamp (should be close to 0)
+    int64_t ts = timer.GetTimestampNow();
+    EXPECT_GE(ts, 0);
+    
+    // Wait a bit and check timestamp has increased
+    QThread::msleep(50); // 50ms
+    int64_t ts2 = timer.GetTimestampNow();
+    
+    // At 24fps, 50ms should be approximately 1 frame (or slightly more)
+    // Allow for some timing variance
+    EXPECT_GE(ts2, ts);
+}
+
+TEST(ViewerSmokeTimer, PlaybackSpeedForward)
+{
+    ViewerPlaybackTimer timer;
+    
+    // Start at timestamp 100, 2x speed, 30fps
+    timer.Start(100, 2, 1.0 / 30.0);
+    
+    int64_t ts1 = timer.GetTimestampNow();
+    QThread::msleep(50);
+    int64_t ts2 = timer.GetTimestampNow();
+    
+    // At 2x speed, time should advance twice as fast
+    EXPECT_GT(ts2, ts1);
+}
+
+TEST(ViewerSmokeTimer, PlaybackSpeedReverse)
+{
+    ViewerPlaybackTimer timer;
+    
+    // Start at timestamp 1000, -1x speed (reverse), 24fps
+    timer.Start(1000, -1, 1.0 / 24.0);
+    
+    int64_t ts1 = timer.GetTimestampNow();
+    QThread::msleep(50);
+    int64_t ts2 = timer.GetTimestampNow();
+    
+    // In reverse, timestamp should decrease
+    EXPECT_LT(ts2, ts1);
+}
+
+TEST(ViewerSmokeTimer, DifferentTimebases)
+{
+    ViewerPlaybackTimer timer;
+    
+    // Test with 24fps
+    timer.Start(0, 1, 1.0 / 24.0);
+    QThread::msleep(100);
+    int64_t ts24 = timer.GetTimestampNow();
+    
+    // Test with 60fps
+    timer.Start(0, 1, 1.0 / 60.0);
+    QThread::msleep(100);
+    int64_t ts60 = timer.GetTimestampNow();
+    
+    // At same real time, 60fps should have more frames than 24fps
+    EXPECT_GT(ts60, ts24);
+}
+
+TEST(ViewerSmokeTimer, ZeroSpeed)
+{
+    ViewerPlaybackTimer timer;
+    
+    // Start with 0 speed (paused)
+    timer.Start(500, 0, 1.0 / 24.0);
+    
+    int64_t ts1 = timer.GetTimestampNow();
+    QThread::msleep(50);
+    int64_t ts2 = timer.GetTimestampNow();
+    
+    // With 0 speed, timestamp should not change
+    EXPECT_EQ(ts1, ts2);
+}
+
+// ============================================================================
+// Smoke Test: ViewerQueue
+// ============================================================================
+
+TEST(ViewerSmokeQueue, DefaultConstruction)
+{
+    ViewerQueue queue;
+    EXPECT_TRUE(queue.empty());
+}
+
+TEST(ViewerSmokeQueue, AppendForwardPlayback)
+{
+    ViewerQueue queue;
+    
+    // Append frames for forward playback
+    ViewerPlaybackFrame frame1{rational(0), QVariant()};
+    ViewerPlaybackFrame frame2{rational(1, 24), QVariant()};
+    ViewerPlaybackFrame frame3{rational(2, 24), QVariant()};
+    
+    queue.AppendTimewise(frame1, 1);  // speed = 1 (forward)
+    queue.AppendTimewise(frame2, 1);
+    queue.AppendTimewise(frame3, 1);
+    
+    EXPECT_EQ(queue.size(), 3);
+    
+    // Verify order (should be chronological for forward playback)
+    auto it = queue.begin();
+    EXPECT_EQ(it->timestamp, rational(0));
+    ++it;
+    EXPECT_EQ(it->timestamp, rational(1, 24));
+    ++it;
+    EXPECT_EQ(it->timestamp, rational(2, 24));
+}
+
+TEST(ViewerSmokeQueue, AppendReversePlayback)
+{
+    ViewerQueue queue;
+    
+    // Append frames for reverse playback
+    ViewerPlaybackFrame frame1{rational(2, 24), QVariant()};
+    ViewerPlaybackFrame frame2{rational(1, 24), QVariant()};
+    ViewerPlaybackFrame frame3{rational(0), QVariant()};
+    
+    queue.AppendTimewise(frame1, -1);  // speed = -1 (reverse)
+    queue.AppendTimewise(frame2, -1);
+    queue.AppendTimewise(frame3, -1);
+    
+    EXPECT_EQ(queue.size(), 3);
+    
+    // Verify order (should be reverse chronological for reverse playback)
+    auto it = queue.begin();
+    EXPECT_EQ(it->timestamp, rational(2, 24));
+    ++it;
+    EXPECT_EQ(it->timestamp, rational(1, 24));
+    ++it;
+    EXPECT_EQ(it->timestamp, rational(0));
+}
+
+TEST(ViewerSmokeQueue, InsertOutOfOrder)
+{
+    ViewerQueue queue;
+    
+    // Insert frames out of order for forward playback
+    ViewerPlaybackFrame frame1{rational(0), QVariant()};
+    ViewerPlaybackFrame frame2{rational(2, 24), QVariant()};
+    ViewerPlaybackFrame frame3{rational(1, 24), QVariant()}; // Middle frame
+    
+    queue.AppendTimewise(frame1, 1);
+    queue.AppendTimewise(frame2, 1);
+    queue.AppendTimewise(frame3, 1); // Should insert in middle
+    
+    EXPECT_EQ(queue.size(), 3);
+    
+    // Verify correct order
+    auto it = queue.begin();
+    EXPECT_EQ(it->timestamp, rational(0));
+    ++it;
+    EXPECT_EQ(it->timestamp, rational(1, 24));
+    ++it;
+    EXPECT_EQ(it->timestamp, rational(2, 24));
+}
+
+TEST(ViewerSmokeQueue, PurgeBefore)
+{
+    ViewerQueue queue;
+    
+    // Add some frames
+    for (int i = 0; i < 10; i++) {
+        ViewerPlaybackFrame frame{rational(i, 24), QVariant()};
+        queue.AppendTimewise(frame, 1);
+    }
+    
+    EXPECT_EQ(queue.size(), 10);
+    
+    // Purge frames before 5/24
+    queue.PurgeBefore(rational(5, 24), 1);
+    
+    // Should have 5 frames remaining (5, 6, 7, 8, 9)
+    EXPECT_EQ(queue.size(), 5);
+    EXPECT_EQ(queue.front().timestamp, rational(5, 24));
+}
+
+TEST(ViewerSmokeQueue, PurgeBeforeReverse)
+{
+    ViewerQueue queue;
+    
+    // Add frames for reverse playback (newest first)
+    for (int i = 9; i >= 0; i--) {
+        ViewerPlaybackFrame frame{rational(i, 24), QVariant()};
+        queue.AppendTimewise(frame, -1);
+    }
+    
+    EXPECT_EQ(queue.size(), 10);
+    
+    // In reverse playback, front() is the largest timestamp (9/24)
+    // PurgeBefore with negative speed removes frames where front > time
+    queue.PurgeBefore(rational(5, 24), -1);
+    
+    // Should have frames 0-5 remaining (those <= 5/24)
+    EXPECT_EQ(queue.size(), 6);
+    EXPECT_EQ(queue.front().timestamp, rational(5, 24));
+}
+
+// ============================================================================
+// Smoke Test: ViewerSafeMarginInfo
+// ============================================================================
+
+TEST(ViewerSmokeSafeMargin, DefaultConstruction)
+{
+    ViewerSafeMarginInfo info;
+    EXPECT_FALSE(info.is_enabled());
+    EXPECT_FALSE(info.custom_ratio());
+    EXPECT_DOUBLE_EQ(info.ratio(), 0.0);
+}
+
+TEST(ViewerSmokeSafeMargin, EnabledConstruction)
+{
+    ViewerSafeMarginInfo info(true);
+    EXPECT_TRUE(info.is_enabled());
+    EXPECT_FALSE(info.custom_ratio());
+}
+
+TEST(ViewerSmokeSafeMargin, CustomRatioConstruction)
+{
+    ViewerSafeMarginInfo info(true, 0.9);
+    EXPECT_TRUE(info.is_enabled());
+    EXPECT_TRUE(info.custom_ratio());
+    EXPECT_DOUBLE_EQ(info.ratio(), 0.9);
+}
+
+TEST(ViewerSmokeSafeMargin, EqualityOperators)
+{
+    ViewerSafeMarginInfo info1(true, 0.9);
+    ViewerSafeMarginInfo info2(true, 0.9);
+    ViewerSafeMarginInfo info3(false, 0.9);
+    ViewerSafeMarginInfo info4(true, 0.8);
+    
+    EXPECT_TRUE(info1 == info2);
+    EXPECT_FALSE(info1 != info2);
+    
+    EXPECT_FALSE(info1 == info3); // Different enabled state
+    EXPECT_FALSE(info1 == info4); // Different ratio
+    EXPECT_TRUE(info1 != info3);
+}
+
+TEST(ViewerSmokeSafeMargin, ZeroRatio)
+{
+    ViewerSafeMarginInfo info(true, 0.0);
+    EXPECT_TRUE(info.is_enabled());
+    EXPECT_FALSE(info.custom_ratio()); // 0 ratio means no custom ratio
+}
+
+TEST(ViewerSmokeSafeMargin, CopyConstruction)
+{
+    ViewerSafeMarginInfo original(true, 0.85);
+    ViewerSafeMarginInfo copy(original);
+    
+    EXPECT_EQ(copy.is_enabled(), original.is_enabled());
+    EXPECT_EQ(copy.custom_ratio(), original.custom_ratio());
+    EXPECT_DOUBLE_EQ(copy.ratio(), original.ratio());
+}
+
+// ============================================================================
+// Smoke Test: AudioPlaybackCache (used by preview system)
+// ============================================================================
+
+TEST(ViewerSmokeAudioCache, DefaultConstruction)
+{
+    AudioPlaybackCache cache;
+    // Should construct without crashing
+    SUCCEED();
+}
+
+TEST(ViewerSmokeAudioCache, ParameterSetters)
+{
+    AudioPlaybackCache cache;
+    
+    AudioParams params(48000, AV_CH_LAYOUT_STEREO, SampleFormat::F32P);
+    cache.SetParameters(params);
+    
+    // Parameters should be retrievable
+    AudioParams retrieved = cache.GetParameters();
+    EXPECT_EQ(retrieved.sample_rate(), params.sample_rate());
+}
+
+TEST(ViewerSmokeAudioCache, ValidateWithRange)
+{
+    AudioPlaybackCache cache;
+    
+    // Initially no validated ranges
+    TimeRangeList validated = cache.GetValidatedRanges();
+    EXPECT_TRUE(validated.isEmpty());
+}
+
+// ============================================================================
+// Smoke Test: PreviewAutoCacher (basic lifecycle)
+// ============================================================================
+
+// NOTE: PreviewAutoCacher requires a QApplication and proper initialization.
+// These tests are disabled in headless mode.
+
+TEST(ViewerSmokeAutoCacher, DISABLED_Construction)
+{
+    // PreviewAutoCacher requires full GUI environment
+    SUCCEED();
+}
+
+TEST(ViewerSmokeAutoCacher, DISABLED_SetPlayhead)
+{
+    // PreviewAutoCacher requires full GUI environment  
+    SUCCEED();
+}
+
+TEST(ViewerSmokeAutoCacher, DISABLED_PauseControls)
+{
+    // PreviewAutoCacher requires full GUI environment
+    SUCCEED();
+}
+
+TEST(ViewerSmokeAutoCacher, DISABLED_SetIgnoreCacheRequests)
+{
+    // PreviewAutoCacher requires full GUI environment
+    SUCCEED();
+}
+
+TEST(ViewerSmokeAutoCacher, DISABLED_SetDisplayColorProcessor)
+{
+    // PreviewAutoCacher requires full GUI environment
+    SUCCEED();
+}
+
+// ============================================================================
+// Smoke Test: Rational Time Calculations (core utility)
+// ============================================================================
+
+TEST(ViewerSmokeRational, DefaultConstruction)
+{
+    rational r;
+    EXPECT_EQ(r.numerator(), 0);
+    EXPECT_EQ(r.denominator(), 1);
+}
+
+TEST(ViewerSmokeRational, ValueConstruction)
+{
+    rational r(24, 1);
+    EXPECT_EQ(r.numerator(), 24);
+    EXPECT_EQ(r.denominator(), 1);
+    
+    rational r2(1, 24);
+    EXPECT_EQ(r2.numerator(), 1);
+    EXPECT_EQ(r2.denominator(), 24);
+}
+
+TEST(ViewerSmokeRational, ToDouble)
+{
+    rational r(1, 2);
+    EXPECT_DOUBLE_EQ(r.toDouble(), 0.5);
+    
+    rational r2(3, 4);
+    EXPECT_DOUBLE_EQ(r2.toDouble(), 0.75);
+}
+
+TEST(ViewerSmokeRational, Arithmetic)
+{
+    rational r1(1, 2);
+    rational r2(1, 4);
+    
+    rational sum = r1 + r2;
+    EXPECT_EQ(sum.numerator(), 3);
+    EXPECT_EQ(sum.denominator(), 4);
+    
+    rational diff = r1 - r2;
+    EXPECT_EQ(diff.numerator(), 1);
+    EXPECT_EQ(diff.denominator(), 4);
+}
+
+TEST(ViewerSmokeRational, Comparison)
+{
+    rational r1(1, 2);
+    rational r2(2, 4);
+    rational r3(3, 4);
+    
+    EXPECT_TRUE(r1 == r2); // Equivalent fractions
+    EXPECT_FALSE(r1 == r3);
+    EXPECT_TRUE(r1 < r3);
+    EXPECT_TRUE(r3 > r1);
+}
+
+TEST(ViewerSmokeRational, NullCheck)
+{
+    rational r;
+    EXPECT_TRUE(r.isNull()); // 0/1 is considered null
+    
+    rational r2(1, 2);
+    EXPECT_FALSE(r2.isNull());
+}
+
+TEST(ViewerSmokeRational, Flipped)
+{
+    rational r(24, 1);
+    rational flipped = r.flipped();
+    
+    EXPECT_EQ(flipped.numerator(), 1);
+    EXPECT_EQ(flipped.denominator(), 24);
+}
+
+// ============================================================================
+// Smoke Test: Thread Safety
+// ============================================================================
+
+TEST(ViewerSmokeThread, ConcurrentTimerAccess)
+{
+    const int num_threads = 4;
+    const int num_iterations = 100;
+    
+    ViewerPlaybackTimer timer;
+    timer.Start(0, 1, 1.0 / 30.0);
+    
+    std::vector<std::thread> threads;
+    std::atomic<int> success_count{0};
+    
+    for (int t = 0; t < num_threads; ++t) {
+        threads.emplace_back([&timer, &success_count, num_iterations]() {
+            for (int i = 0; i < num_iterations; ++i) {
+                int64_t ts = timer.GetTimestampNow();
+                if (ts >= 0) {
+                    success_count++;
+                }
+            }
+        });
+    }
+    
+    for (auto &t : threads) {
+        t.join();
+    }
+    
+    EXPECT_EQ(success_count.load(), num_threads * num_iterations);
+}
+
+TEST(ViewerSmokeThread, ConcurrentQueueAccess)
+{
+    const int num_threads = 4;
+    const int num_frames_per_thread = 25;
+    
+    ViewerQueue queue;
+    std::vector<std::thread> threads;
+    std::atomic<int> append_count{0};
+    
+    for (int t = 0; t < num_threads; ++t) {
+        threads.emplace_back([&queue, &append_count, t, num_frames_per_thread]() {
+            for (int i = 0; i < num_frames_per_thread; ++i) {
+                ViewerPlaybackFrame frame{rational(t * num_frames_per_thread + i, 24), QVariant()};
+                queue.AppendTimewise(frame, 1);
+                append_count++;
+            }
+        });
+    }
+    
+    for (auto &t : threads) {
+        t.join();
+    }
+    
+    EXPECT_EQ(append_count.load(), num_threads * num_frames_per_thread);
+    EXPECT_EQ(queue.size(), num_threads * num_frames_per_thread);
+}
+
+// ============================================================================
+// Smoke Test: Integration Scenarios
+// ============================================================================
+
+TEST(ViewerSmokeIntegration, PlaybackSequenceSimulation)
+{
+    // Simulate a basic playback sequence
+    ViewerPlaybackTimer timer;
+    ViewerQueue queue;
+    
+    // Start playback at frame 0, 24fps
+    timer.Start(0, 1, 1.0 / 24.0);
+    
+    // Queue some frames
+    for (int i = 0; i < 10; i++) {
+        ViewerPlaybackFrame frame{rational(i, 24), QVariant(i)};
+        queue.AppendTimewise(frame, 1);
+    }
+    
+    // Get current timestamp
+    int64_t current_ts = timer.GetTimestampNow();
+    
+    // Find frame closest to current time
+    rational current_time(current_ts, 1);
+    bool found = false;
+    for (const auto &frame : queue) {
+        if (frame.timestamp >= current_time) {
+            found = true;
+            break;
+        }
+    }
+    
+    // Should have frames available
+    EXPECT_FALSE(queue.empty());
+}
+
+TEST(ViewerSmokeIntegration, SafeMarginWithDifferentAspectRatios)
+{
+    // Test safe margins for different aspect ratios
+    std::vector<double> ratios = {0.9, 0.85, 0.8, 0.7};
+    
+    for (double ratio : ratios) {
+        ViewerSafeMarginInfo info(true, ratio);
+        EXPECT_TRUE(info.is_enabled());
+        EXPECT_TRUE(info.custom_ratio());
+        EXPECT_DOUBLE_EQ(info.ratio(), ratio);
+    }
+}
+
+TEST(ViewerSmokeIntegration, ReversePlaybackScenario)
+{
+    ViewerPlaybackTimer timer;
+    ViewerQueue queue;
+    
+    // Start reverse playback from frame 100
+    timer.Start(100, -1, 1.0 / 24.0);
+    
+    // Queue frames in reverse order
+    for (int i = 100; i >= 90; i--) {
+        ViewerPlaybackFrame frame{rational(i, 24), QVariant(i)};
+        queue.AppendTimewise(frame, -1);
+    }
+    
+    // Get timestamps - should decrease
+    int64_t ts1 = timer.GetTimestampNow();
+    QThread::msleep(50);
+    int64_t ts2 = timer.GetTimestampNow();
+    
+    EXPECT_LT(ts2, ts1);
+    EXPECT_EQ(queue.front().timestamp, rational(100, 24));
+}
+
+} // namespace test
+} // namespace viewer
+} // namespace olive