src/common/MemoryBuffer_unittest.cpp - angle/angle.git - Git at Google

 //
 // 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
	//
	// 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