#include "catch.hpp"

#include "monotonic_allocator.hh"

#include <algorithm>

#include <bit>

#include <span>

[[nodiscard]] static char* alloc(monotonic_allocator& a, size_t size, size_t alignment)

{

	auto* result = static_cast<char*>(a.allocate(size, alignment));

	CHECK(result != nullptr);

	CHECK((std::bit_cast<uintptr_t>(result) & (alignment - 1)) == 0);

	std::ranges::fill(std::span{result, size}, 0xab); // this shouldn't crash

	return result;

}

TEST_CASE("monotonic_allocator")

{

	SECTION("default") {

		monotonic_allocator a;

		char* p1 = alloc(a, 300, 4);

		char* p2 = alloc(a, 600, 4);

		CHECK(p1 + 300 == p2); // adjacent

		char* p3 = alloc(a, 600, 4);

		CHECK(p2 + 600 != p3); // not adjacent, doesn't fit in initial 1kB block

		char* p4 = alloc(a, 600, 4);

		CHECK(p3 + 600 == p4); // adjacent again because 2nd block is 2kB

		char* p5 = alloc(a, 10'000, 4);

		CHECK(p4 + 600 != p5); // not adjacent

	}

	SECTION("initial size") {

		monotonic_allocator a(100);

		char* p1 = alloc(a, 32, 4);

		char* p2 = alloc(a, 32, 4);

		CHECK(p1 + 32 == p2); // adjacent

		char* p3 = alloc(a, 32, 4);

		CHECK(p1 + 64 == p3); // adjacent

		char* p4 = alloc(a, 32, 4);

		CHECK(p1 + 96 != p4); // not adjacent

	}

	SECTION("initial buffer") {

		std::array<char, 100> buf;

		monotonic_allocator a(buf.data(), buf.size());

		char* p1 = alloc(a, 40, 1);

		CHECK(p1 == buf.data());

		char* p2 = alloc(a, 40, 1);

		CHECK(p2 == &buf[40]);

		char* p3 = alloc(a, 40, 1);

		CHECK(p3 != &buf[80]);

		char* p4 = alloc(a, 40, 1);

		CHECK(p4 == p3 + 40);

		char* p5 = alloc(a, 40, 1);

		CHECK(p5 == p3 + 80);

	}

	SECTION("alignment") {

		monotonic_allocator a;

		char* p1 = alloc(a, 13, 1);

		char* p2 = alloc(a, 4, 4);

		CHECK(p2 == p1 + 16);

		char* p3 = alloc(a, 3, 2);

		CHECK(p3 == p2 + 4);

		char* p4 = alloc(a, 3, 2);

		CHECK(p4 == p3 + 4);

	}

}