Clean up source code

vav2/Vav2Player/Vav2UnitTest/tests/VideoRendererTest.cpp

@@ -0,0 +1,286 @@
+#include "pch.h"
+#include "MockVideoRenderer.h"
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace Vav2PlayerUnitTests;
+
+namespace Vav2PlayerUnitTests
+{
+    TEST_CLASS(VideoRendererTest)
+    {
+    public:
+        TEST_METHOD(MockVideoRenderer_Initialize_Success_ShouldReturnSOK)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+
+            // Act
+            HRESULT result = mockRenderer.Initialize(1920, 1080);
+
+            // Assert
+            Assert::AreEqual(S_OK, result);
+            Assert::IsTrue(mockRenderer.IsInitialized());
+            Assert::AreEqual(1920u, mockRenderer.GetWidth());
+            Assert::AreEqual(1080u, mockRenderer.GetHeight());
+            Assert::AreEqual(1u, mockRenderer.GetInitializeCallCount());
+        }
+
+        TEST_METHOD(MockVideoRenderer_Initialize_Failure_ShouldReturnError)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+            mockRenderer.SetInitializeResult(E_FAIL);
+
+            // Act
+            HRESULT result = mockRenderer.Initialize(1920, 1080);
+
+            // Assert
+            Assert::AreEqual(E_FAIL, result);
+            Assert::IsFalse(mockRenderer.IsInitialized());
+        }
+
+        TEST_METHOD(MockVideoRenderer_RenderVideoFrame_WhenInitialized_ShouldSucceed)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+            mockRenderer.Initialize(1920, 1080);
+
+            VideoFrame testFrame;
+            testFrame.width = 1920;
+            testFrame.height = 1080;
+            testFrame.format = PixelFormat::YUV420P;
+            testFrame.frame_index = 0;
+            testFrame.timestamp_ns = 0;
+
+            // Create test YUV data
+            testFrame.y_stride = 1920;
+            testFrame.u_stride = 960;
+            testFrame.v_stride = 960;
+
+            size_t y_size = testFrame.y_stride * testFrame.height;
+            size_t uv_size = testFrame.u_stride * (testFrame.height / 2);
+
+            testFrame.y_plane = std::make_unique<uint8_t[]>(y_size);
+            testFrame.u_plane = std::make_unique<uint8_t[]>(uv_size);
+            testFrame.v_plane = std::make_unique<uint8_t[]>(uv_size);
+
+            // Fill with test pattern
+            std::memset(testFrame.y_plane.get(), 128, y_size);
+            std::memset(testFrame.u_plane.get(), 64, uv_size);
+            std::memset(testFrame.v_plane.get(), 192, uv_size);
+
+            // Act
+            HRESULT result = mockRenderer.RenderVideoFrame(testFrame);
+
+            // Assert
+            Assert::AreEqual(S_OK, result);
+            Assert::AreEqual(1u, mockRenderer.GetRenderFrameCallCount());
+            Assert::AreEqual(1u, mockRenderer.GetTotalRenderedFrames());
+
+            const auto& renderedFrames = mockRenderer.GetRenderedFrames();
+            Assert::AreEqual(1u, static_cast<uint32_t>(renderedFrames.size()));
+            Assert::AreEqual(1920u, renderedFrames[0].width);
+            Assert::AreEqual(1080u, renderedFrames[0].height);
+        }
+
+        TEST_METHOD(MockVideoRenderer_TryRenderFrame_WhenInitialized_ShouldReturnTrue)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+            mockRenderer.Initialize(1920, 1080);
+
+            VideoFrame testFrame;
+            testFrame.width = 1920;
+            testFrame.height = 1080;
+            testFrame.format = PixelFormat::YUV420P;
+
+            // Act
+            bool result = mockRenderer.TryRenderFrame(testFrame);
+
+            // Assert
+            Assert::IsTrue(result);
+            Assert::AreEqual(1u, mockRenderer.GetTryRenderFrameCallCount());
+        }
+
+        TEST_METHOD(MockVideoRenderer_TryRenderFrame_WhenNotInitialized_ShouldReturnFalse)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+
+            VideoFrame testFrame;
+            testFrame.width = 1920;
+            testFrame.height = 1080;
+
+            // Act
+            bool result = mockRenderer.TryRenderFrame(testFrame);
+
+            // Assert
+            Assert::IsFalse(result);
+        }
+
+        TEST_METHOD(MockVideoRenderer_Present_WhenInitialized_ShouldReturnSOK)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+            mockRenderer.Initialize(1920, 1080);
+
+            // Act
+            HRESULT result = mockRenderer.Present();
+
+            // Assert
+            Assert::AreEqual(S_OK, result);
+            Assert::AreEqual(1u, mockRenderer.GetPresentCallCount());
+        }
+
+        TEST_METHOD(MockVideoRenderer_Resize_ValidSize_ShouldUpdateDimensions)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+            mockRenderer.Initialize(1920, 1080);
+
+            // Act
+            HRESULT result = mockRenderer.Resize(3840, 2160);
+
+            // Assert
+            Assert::AreEqual(S_OK, result);
+            Assert::AreEqual(3840u, mockRenderer.GetWidth());
+            Assert::AreEqual(2160u, mockRenderer.GetHeight());
+            Assert::AreEqual(1u, mockRenderer.GetResizeCallCount());
+        }
+
+        TEST_METHOD(MockVideoRenderer_Shutdown_ShouldResetState)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+            mockRenderer.Initialize(1920, 1080);
+
+            VideoFrame testFrame;
+            testFrame.width = 1920;
+            testFrame.height = 1080;
+            mockRenderer.RenderVideoFrame(testFrame);
+
+            // Act
+            mockRenderer.Shutdown();
+
+            // Assert
+            Assert::IsFalse(mockRenderer.IsInitialized());
+            Assert::AreEqual(0u, mockRenderer.GetWidth());
+            Assert::AreEqual(0u, mockRenderer.GetHeight());
+            Assert::AreEqual(0u, mockRenderer.GetTotalRenderedFrames());
+        }
+
+        TEST_METHOD(MockVideoRenderer_SetAspectFitMode_ShouldUpdateState)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+
+            // Act
+            mockRenderer.SetAspectFitMode(true);
+
+            // Assert
+            Assert::IsTrue(mockRenderer.GetAspectFitMode());
+
+            // Act
+            mockRenderer.SetAspectFitMode(false);
+
+            // Assert
+            Assert::IsFalse(mockRenderer.GetAspectFitMode());
+        }
+
+        TEST_METHOD(MockVideoRenderer_UpdateContainerSize_ShouldUpdateDimensions)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+
+            // Act
+            mockRenderer.UpdateContainerSize(1280, 720);
+
+            // Assert
+            Assert::AreEqual(1280u, mockRenderer.GetContainerWidth());
+            Assert::AreEqual(720u, mockRenderer.GetContainerHeight());
+        }
+
+        TEST_METHOD(MockVideoRenderer_SimulateFailures_ShouldBehaveCorrectly)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+
+            // Test initialization failure
+            mockRenderer.SimulateInitializationFailure(true);
+            HRESULT initResult = mockRenderer.Initialize(1920, 1080);
+            Assert::AreEqual(E_FAIL, initResult);
+            Assert::IsFalse(mockRenderer.IsInitialized());
+
+            // Reset and test rendering failure
+            mockRenderer.SimulateInitializationFailure(false);
+            mockRenderer.Initialize(1920, 1080);
+
+            mockRenderer.SimulateRenderingFailure(true);
+
+            VideoFrame testFrame;
+            testFrame.width = 1920;
+            testFrame.height = 1080;
+
+            // Act
+            HRESULT renderResult = mockRenderer.RenderVideoFrame(testFrame);
+            bool tryRenderResult = mockRenderer.TryRenderFrame(testFrame);
+
+            // Assert
+            Assert::AreEqual(E_FAIL, renderResult);
+            Assert::IsFalse(tryRenderResult);
+        }
+
+        TEST_METHOD(MockVideoRenderer_PerformanceSimulation_ShouldTrackTime)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+            mockRenderer.Initialize(1920, 1080);
+            mockRenderer.SetRenderDelay(10); // 10ms delay
+
+            VideoFrame testFrame;
+            testFrame.width = 1920;
+            testFrame.height = 1080;
+
+            // Act
+            auto startTime = std::chrono::high_resolution_clock::now();
+            mockRenderer.RenderVideoFrame(testFrame);
+            auto endTime = std::chrono::high_resolution_clock::now();
+
+            auto actualDuration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);
+
+            // Assert
+            Assert::IsTrue(actualDuration.count() >= 10); // Should take at least 10ms
+            Assert::IsTrue(mockRenderer.GetTotalRenderTime() >= 10); // Should track the time
+        }
+
+        TEST_METHOD(MockVideoRenderer_MultipleFrames_ShouldTrackAll)
+        {
+            // Arrange
+            MockVideoRenderer mockRenderer;
+            mockRenderer.Initialize(1920, 1080);
+
+            // Act - Render 5 frames
+            for (uint32_t i = 0; i < 5; ++i) {
+                VideoFrame testFrame;
+                testFrame.width = 1920;
+                testFrame.height = 1080;
+                testFrame.frame_index = i;
+                testFrame.timestamp_ns = i * 33333333; // ~30fps
+
+                mockRenderer.RenderVideoFrame(testFrame);
+            }
+
+            // Assert
+            Assert::AreEqual(5u, mockRenderer.GetRenderFrameCallCount());
+            Assert::AreEqual(5u, mockRenderer.GetTotalRenderedFrames());
+
+            const auto& renderedFrames = mockRenderer.GetRenderedFrames();
+            Assert::AreEqual(5u, static_cast<uint32_t>(renderedFrames.size()));
+
+            // Verify frame indices are correct
+            for (uint32_t i = 0; i < 5; ++i) {
+                Assert::AreEqual(static_cast<uint64_t>(i), renderedFrames[i].frame_index);
+            }
+        }
+    };
+}