video-v1/vav2/Vav2Player/Vav2UnitTest/tests/WebMFileReaderTest.cpp

#include "pch.h"
#include "MockWebMFileReader.h"
#include "../../VavCore/src/FileIO/WebMFileReader.h"

using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace Vav2PlayerUnitTests;

namespace Vav2PlayerUnitTests
{
    TEST_CLASS(WebMFileReaderTest)
    {
    public:
        TEST_METHOD(MockWebMFileReader_OpenFile_Success_ShouldReturnTrue)
        {
            // Arrange
            MockWebMFileReader mockReader;
            std::string testFile = "test_video.webm";

            // Act
            bool result = mockReader.OpenFile(testFile);

            // Assert
            Assert::IsTrue(result);
            Assert::IsTrue(mockReader.IsFileOpen());
            Assert::AreEqual(testFile, mockReader.GetFilePath());
            Assert::AreEqual(1u, mockReader.GetOpenFileCallCount());
        }

        TEST_METHOD(MockWebMFileReader_OpenFile_Failure_ShouldReturnFalse)
        {
            // Arrange
            MockWebMFileReader mockReader;
            mockReader.SetOpenFileResult(false);
            std::string testFile = "nonexistent.webm";

            // Act
            bool result = mockReader.OpenFile(testFile);

            // Assert
            Assert::IsFalse(result);
            Assert::IsFalse(mockReader.IsFileOpen());
            Assert::AreEqual(WebMErrorCode::FileNotFound, mockReader.GetLastError());
        }

        TEST_METHOD(MockWebMFileReader_GetVideoTracks_ShouldReturnDefaultTrack)
        {
            // Arrange
            MockWebMFileReader mockReader;
            mockReader.OpenFile("test.webm");

            // Act
            auto tracks = mockReader.GetVideoTracks();

            // Assert
            Assert::AreEqual(1u, static_cast<uint32_t>(tracks.size()));
            Assert::AreEqual(1u, static_cast<uint32_t>(tracks[0].track_number));
            Assert::AreEqual(VideoCodecType::AV1, tracks[0].codec_type);
            Assert::AreEqual(1920u, tracks[0].width);
            Assert::AreEqual(1080u, tracks[0].height);
        }

        TEST_METHOD(MockWebMFileReader_SelectVideoTrack_ValidTrack_ShouldReturnTrue)
        {
            // Arrange
            MockWebMFileReader mockReader;
            mockReader.OpenFile("test.webm");

            // Act
            bool result = mockReader.SelectVideoTrack(1);

            // Assert
            Assert::IsTrue(result);
            Assert::AreEqual(1u, static_cast<uint32_t>(mockReader.GetSelectedTrackNumber()));
        }

        TEST_METHOD(MockWebMFileReader_SelectVideoTrack_InvalidTrack_ShouldReturnFalse)
        {
            // Arrange
            MockWebMFileReader mockReader;
            mockReader.OpenFile("test.webm");

            // Act
            bool result = mockReader.SelectVideoTrack(999);

            // Assert
            Assert::IsFalse(result);
            Assert::AreEqual(WebMErrorCode::InvalidTrack, mockReader.GetLastError());
        }

        TEST_METHOD(MockWebMFileReader_ReadNextPacket_ShouldReturnValidPackets)
        {
            // Arrange
            MockWebMFileReader mockReader;
            mockReader.OpenFile("test.webm");
            mockReader.SelectVideoTrack(1);

            // Act
            VideoPacket packet;
            bool result = mockReader.ReadNextPacket(packet);

            // Assert
            Assert::IsTrue(result);
            Assert::IsNotNull(packet.data.get());
            Assert::IsTrue(packet.size > 0);
            Assert::AreEqual(0u, static_cast<uint32_t>(packet.frame_index));
            // Note: track_number field doesn't exist in VideoPacket, skipping this assertion
            Assert::AreEqual(1u, mockReader.GetReadPacketCallCount());
        }

        TEST_METHOD(MockWebMFileReader_ReadMultiplePackets_ShouldIncrementFrameIndex)
        {
            // Arrange
            MockWebMFileReader mockReader;
            mockReader.OpenFile("test.webm");
            mockReader.SelectVideoTrack(1);

            // Act & Assert
            for (uint64_t i = 0; i < 5; ++i) {
                VideoPacket packet;
                bool result = mockReader.ReadNextPacket(packet);

                Assert::IsTrue(result);
                Assert::AreEqual(i, packet.frame_index);
                Assert::AreEqual(i + 1, mockReader.GetCurrentFrameIndex());
            }

            Assert::AreEqual(5u, mockReader.GetReadPacketCallCount());
        }

        TEST_METHOD(MockWebMFileReader_SeekToFrame_ValidFrame_ShouldUpdatePosition)
        {
            // Arrange
            MockWebMFileReader mockReader;
            mockReader.OpenFile("test.webm");
            mockReader.SelectVideoTrack(1);

            // Act
            bool result = mockReader.SeekToFrame(50);

            // Assert
            Assert::IsTrue(result);
            Assert::AreEqual(50u, static_cast<uint32_t>(mockReader.GetCurrentFrameIndex()));
        }

        TEST_METHOD(MockWebMFileReader_SeekToTime_ValidTime_ShouldUpdatePosition)
        {
            // Arrange
            MockWebMFileReader mockReader;
            mockReader.OpenFile("test.webm");
            mockReader.SelectVideoTrack(1);

            // Act (Seek to 1 second = frame 30 at 30fps)
            bool result = mockReader.SeekToTime(1.0);

            // Assert
            Assert::IsTrue(result);
            Assert::AreEqual(30u, static_cast<uint32_t>(mockReader.GetCurrentFrameIndex()));
        }

        TEST_METHOD(MockWebMFileReader_Reset_ShouldReturnToBeginning)
        {
            // Arrange
            MockWebMFileReader mockReader;
            mockReader.OpenFile("test.webm");
            mockReader.SelectVideoTrack(1);
            mockReader.SeekToFrame(50);

            // Act
            bool result = mockReader.Reset();

            // Assert
            Assert::IsTrue(result);
            Assert::AreEqual(0u, static_cast<uint32_t>(mockReader.GetCurrentFrameIndex()));
        }

        TEST_METHOD(MockWebMFileReader_GetVideoMetadata_ShouldReturnValidData)
        {
            // Arrange
            MockWebMFileReader mockReader;
            mockReader.OpenFile("test.webm");

            // Act
            const VideoMetadata& metadata = mockReader.GetVideoMetadata();

            // Assert
            Assert::AreEqual(1920u, metadata.width);
            Assert::AreEqual(1080u, metadata.height);
            Assert::AreEqual(30.0, metadata.frame_rate, 0.01);
            Assert::AreEqual(VideoCodecType::AV1, metadata.codec_type);
            Assert::AreEqual(ColorSpace::BT709, metadata.color_space);
            Assert::AreEqual(100u, static_cast<uint32_t>(metadata.total_frames));
        }

        TEST_METHOD(MockWebMFileReader_EndOfFile_ShouldDetectCorrectly)
        {
            // Arrange
            MockWebMFileReader mockReader;
            mockReader.SetEndOfFileAtFrame(3); // Set EOF at frame 3
            mockReader.OpenFile("test.webm");
            mockReader.SelectVideoTrack(1);

            // Act & Assert
            for (int i = 0; i < 3; ++i) {
                VideoPacket packet;
                bool result = mockReader.ReadNextPacket(packet);
                Assert::IsTrue(result);
                Assert::IsFalse(mockReader.IsEndOfFile());
            }

            // Should now be at EOF
            Assert::IsTrue(mockReader.IsEndOfFile());

            // Next read should fail
            VideoPacket packet;
            bool result = mockReader.ReadNextPacket(packet);
            Assert::IsFalse(result);
        }
    };
}