//
// Copyright 2025 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Unit tests for ANGLE's MemoryBuffer class.
//

#include "common/MemoryBuffer.h"

#include <array>

#include "common/span.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

using namespace angle;

namespace
{

// Test usage of MemoryBuffer with multiple resizes
TEST(MemoryBuffer, MultipleResizes)
{
    MemoryBuffer buffer;

    ASSERT_TRUE(buffer.resize(100));
    ASSERT_EQ(buffer.size(), 100u);
    buffer.assertTotalAllocatedBytes(100u);
    buffer.assertTotalCopiedBytes(0u);

    ASSERT_TRUE(buffer.resize(300));
    ASSERT_EQ(buffer.size(), 300u);
    buffer.assertTotalAllocatedBytes(400u);
    buffer.assertTotalCopiedBytes(100u);

    ASSERT_TRUE(buffer.resize(100));
    ASSERT_EQ(buffer.size(), 100u);
    buffer.assertTotalAllocatedBytes(400u);
    buffer.assertTotalCopiedBytes(100u);

    ASSERT_TRUE(buffer.resize(400));
    ASSERT_EQ(buffer.size(), 400u);
    buffer.assertTotalAllocatedBytes(800u);
    buffer.assertTotalCopiedBytes(200u);
}

// Test usage of MemoryBuffer with reserve and then multiple resizes
TEST(MemoryBuffer, ReserveThenResize)
{
    MemoryBuffer buffer;

    ASSERT_TRUE(buffer.reserve(300));
    ASSERT_EQ(buffer.size(), 0u);

    ASSERT_TRUE(buffer.resize(100));
    ASSERT_EQ(buffer.size(), 100u);
    buffer.assertTotalAllocatedBytes(300u);
    buffer.assertTotalCopiedBytes(0u);

    ASSERT_TRUE(buffer.resize(300));
    ASSERT_EQ(buffer.size(), 300u);
    buffer.assertTotalAllocatedBytes(300u);
    buffer.assertTotalCopiedBytes(0u);

    ASSERT_TRUE(buffer.resize(100));
    ASSERT_EQ(buffer.size(), 100u);
    buffer.assertTotalAllocatedBytes(300u);
    buffer.assertTotalCopiedBytes(0u);

    ASSERT_TRUE(buffer.resize(400));
    ASSERT_EQ(buffer.size(), 400u);
    buffer.assertTotalAllocatedBytes(700u);
    buffer.assertTotalCopiedBytes(100u);
}

// Test that clear() of a memory buffer retains the buffer.
TEST(MemoryBuffer, Clear)
{
    MemoryBuffer buffer;
    ASSERT_TRUE(buffer.resize(100));
    ASSERT_EQ(buffer.size(), 100u);
    ASSERT_NE(buffer.data(), nullptr);
    buffer.assertTotalAllocatedBytes(100u);
    buffer.assertTotalCopiedBytes(0u);

    uint8_t *oldPtr = buffer.data();

    buffer.clear();
    EXPECT_EQ(buffer.size(), 0u);
    EXPECT_EQ(buffer.data(), oldPtr);
    buffer.assertTotalAllocatedBytes(100u);
    buffer.assertTotalCopiedBytes(0u);

    ASSERT_TRUE(buffer.resize(100));
    ASSERT_EQ(buffer.size(), 100u);
    EXPECT_EQ(buffer.data(), oldPtr);
    buffer.assertTotalAllocatedBytes(100u);
    buffer.assertTotalCopiedBytes(0u);
}

// Test that destroy() of a memory buffer does not retain the buffer.
// Test destroying MemoryBuffer
TEST(MemoryBuffer, Destroy)
{
    MemoryBuffer buffer;
    ASSERT_TRUE(buffer.resize(100));
    ASSERT_EQ(buffer.size(), 100u);
    ASSERT_NE(buffer.data(), nullptr);
    buffer.assertTotalAllocatedBytes(100u);
    buffer.assertTotalCopiedBytes(0u);

    buffer.destroy();
    EXPECT_EQ(buffer.size(), 0u);
    buffer.assertDataBufferFreed();
    buffer.assertTotalAllocatedBytes(0u);
    buffer.assertTotalCopiedBytes(0u);

    ASSERT_TRUE(buffer.resize(100));
    ASSERT_EQ(buffer.size(), 100u);
    ASSERT_NE(buffer.data(), nullptr);
    buffer.assertTotalAllocatedBytes(100u);
    buffer.assertTotalCopiedBytes(0u);
}

// Test usage of MemoryBuffer with clearAndReserve() and then multiple resizes.
TEST(MemoryBuffer, ClearAndReserve)
{
    MemoryBuffer buffer;
    ASSERT_TRUE(buffer.resize(200));
    ASSERT_EQ(buffer.size(), 200u);
    ASSERT_NE(buffer.data(), nullptr);
    buffer.assertTotalAllocatedBytes(200u);
    buffer.assertTotalCopiedBytes(0u);

    uint8_t *oldPtr = buffer.data();

    ASSERT_TRUE(buffer.clearAndReserve(100));
    ASSERT_EQ(buffer.size(), 0u);
    EXPECT_EQ(buffer.data(), oldPtr);
    buffer.assertTotalAllocatedBytes(200u);
    buffer.assertTotalCopiedBytes(0u);

    ASSERT_TRUE(buffer.resize(200));
    ASSERT_EQ(buffer.size(), 200u);
    EXPECT_EQ(buffer.data(), oldPtr);
    buffer.assertTotalAllocatedBytes(200u);
    buffer.assertTotalCopiedBytes(0u);

    ASSERT_TRUE(buffer.resize(300));
    ASSERT_EQ(buffer.size(), 300u);
    EXPECT_NE(buffer.data(), oldPtr);
    buffer.assertTotalAllocatedBytes(500u);
    buffer.assertTotalCopiedBytes(200u);
}

// Test that the span() method returns entire buffer.
TEST(MemoryBuffer, Span)
{
    MemoryBuffer buf;
    {
        Span<uint8_t> s = buf.span();
        EXPECT_EQ(s.size(), 0u);
        EXPECT_EQ(s.data(), nullptr);
    }
    ASSERT_TRUE(buf.resize(2u));
    {
        Span<uint8_t> s = buf.span();
        EXPECT_EQ(s.size(), 2u);
        EXPECT_EQ(s.data(), buf.data());
    }
}

// Test that the subspan() method returns correct portion of buffer.
TEST(MemoryBuffer, Subspan)
{
    MemoryBuffer buf;
    {
        Span<uint8_t> s = buf.subspan(0);
        EXPECT_EQ(s.size(), 0u);
        EXPECT_EQ(s.data(), nullptr);
    }
    {
        Span<uint8_t> s = buf.subspan(0, 0);
        EXPECT_EQ(s.size(), 0u);
        EXPECT_EQ(s.data(), nullptr);
    }
    ASSERT_TRUE(buf.resize(4u));
    for (size_t i = 0; i < buf.size(); ++i)
    {
        buf[i] = i;
    }
    {
        Span<uint8_t> s = buf.subspan(0, 0);
        EXPECT_EQ(s.size(), 0u);
    }
    {
        Span<uint8_t> s = buf.subspan(2, 0);
        EXPECT_THAT(s.size(), 0u);
    }
    {
        Span<uint8_t> s = buf.subspan(0, 1);
        EXPECT_THAT(s, testing::ElementsAre(0u));
    }
    {
        Span<uint8_t> s = buf.subspan(1, 2);
        EXPECT_THAT(s, testing::ElementsAre(1u, 2u));
    }
    {
        Span<uint8_t> s = buf.subspan(3);
        EXPECT_THAT(s, testing::ElementsAre(3u));
    }
    {
        Span<uint8_t> s = buf.subspan(4);
        EXPECT_THAT(s.size(), 0u);
    }
}

// Test that the first() method returns correct portion of buffer.
TEST(MemoryBuffer, First)
{
    MemoryBuffer buf;
    {
        Span<uint8_t> s = buf.first(0);
        EXPECT_EQ(s.size(), 0u);
        EXPECT_EQ(s.data(), nullptr);
    }
    ASSERT_TRUE(buf.resize(4u));
    for (size_t i = 0; i < buf.size(); ++i)
    {
        buf[i] = i;
    }
    {
        Span<uint8_t> s = buf.first(0);
        EXPECT_EQ(s.size(), 0u);
    }
    {
        Span<uint8_t> s = buf.first(2u);
        EXPECT_THAT(s, testing::ElementsAre(0u, 1u));
    }
}

// Test that the last() method returns correct portion of buffer.
TEST(MemoryBuffer, Last)
{
    MemoryBuffer buf;
    {
        Span<uint8_t> s = buf.last(0);
        EXPECT_EQ(s.size(), 0u);
        EXPECT_EQ(s.data(), nullptr);
    }
    ASSERT_TRUE(buf.resize(4u));
    for (size_t i = 0; i < buf.size(); ++i)
    {
        buf[i] = i;
    }
    {
        Span<uint8_t> s = buf.last(0);
        EXPECT_EQ(s.size(), 0u);
    }
    {
        Span<uint8_t> s = buf.last(2u);
        EXPECT_THAT(s, testing::ElementsAre(2u, 3u));
    }
}

// Test that filling a memory buffer writes the expected value.
TEST(MemoryBuffer, Fill)
{
    MemoryBuffer buf;

    // Test fill is a no-op on an empty buffer.
    buf.fill(0x41);
    EXPECT_TRUE(buf.empty());

    ASSERT_TRUE(buf.resize(2));
    buf.fill(0x41);
    EXPECT_EQ(0x41u, buf[0]);
    EXPECT_EQ(0x41u, buf[1]);
}

// Demonstrate current behavior of ScratchBuffer lifetime mechanism
TEST(ScratchBuffer, Lifetime)
{
    ScratchBuffer scratch(2);  // Live for two ticks.
    MemoryBuffer *out;

    ASSERT_TRUE(scratch.get(100u, &out));
    ASSERT_NE(out, nullptr);
    ASSERT_NE(out->data(), nullptr);

    uint8_t *oldPtr = out->data();

    scratch.tick();
    EXPECT_EQ(out->data(), oldPtr);

    scratch.tick();
    out->assertDataBufferFreed();

    scratch.tick();
    out->assertDataBufferFreed();
}

// Test that an initial lifetime of zero means it never expires.
TEST(ScratchBuffer, EternalLifetime)
{
    ScratchBuffer scratch(0);
    MemoryBuffer *out;

    ASSERT_TRUE(scratch.get(100u, &out));
    ASSERT_NE(out, nullptr);
    ASSERT_NE(out->data(), nullptr);

    uint8_t *oldPtr = out->data();

    scratch.tick();
    EXPECT_EQ(out->data(), oldPtr);

    scratch.tick();
    EXPECT_EQ(out->data(), oldPtr);

    scratch.tick();
    EXPECT_EQ(out->data(), oldPtr);

    scratch.tick();
    EXPECT_EQ(out->data(), oldPtr);
}

}  // namespace