data_structures_test.cpp

#include <catch.hpp>

#include <pls/internal/base/system_details.h>

#include <pls/internal/data_structures/aligned_stack.h>
#include <pls/internal/data_structures/deque.h>

#include <vector>
#include <mutex>

using namespace pls::internal::data_structures;
using namespace pls::internal::base;
using namespace std;


TEST_CASE( "aligned stack stores objects correctly", "[internal/data_structures/aligned_stack.h]") {
    constexpr long data_size = 1024;
    char data[data_size];
    aligned_stack stack{data, data_size};

    SECTION( "stack correctly pushes sub linesize objects" ) {
        std::array<char, 5> small_data_one{'a', 'b', 'c', 'd', 'e'};
        std::array<char, 64> small_data_two{};
        std::array<char, 1> small_data_three{'A'};

        auto pointer_one = stack.push(small_data_one);
        auto pointer_two = stack.push(small_data_two);
        auto pointer_three = stack.push(small_data_three);

        REQUIRE(reinterpret_cast<std::uintptr_t>(pointer_one) % CACHE_LINE_SIZE == 0);
        REQUIRE(reinterpret_cast<std::uintptr_t>(pointer_two) % CACHE_LINE_SIZE == 0);
        REQUIRE(reinterpret_cast<std::uintptr_t>(pointer_three) % CACHE_LINE_SIZE == 0);
    }

    SECTION( "stack correctly pushes above linesize objects" ) {
        std::array<char, 5> small_data_one{'a', 'b', 'c', 'd', 'e'};
        std::array<char, CACHE_LINE_SIZE + 10> big_data_one{};

        auto big_pointer_one = stack.push(big_data_one);
        auto small_pointer_one = stack.push(small_data_one);

        REQUIRE(reinterpret_cast<std::uintptr_t>(big_pointer_one) % CACHE_LINE_SIZE == 0);
        REQUIRE(reinterpret_cast<std::uintptr_t>(small_pointer_one) % CACHE_LINE_SIZE == 0);
    }

    SECTION( "stack correctly stores and retrieves objects" ) {
        std::array<char, 5> data_one{'a', 'b', 'c', 'd', 'e'};

        stack.push(data_one);
        auto retrieved_data = stack.pop<std::array<char, 5>>();

        REQUIRE(retrieved_data == std::array<char, 5>{'a', 'b', 'c', 'd', 'e'});
    }

    SECTION( "stack can push and pop multiple times with correct alignment" ) {
        std::array<char, 5> small_data_one{'a', 'b', 'c', 'd', 'e'};
        std::array<char, 64> small_data_two{};
        std::array<char, 1> small_data_three{'A'};

        auto pointer_one = stack.push(small_data_one);
        auto pointer_two = stack.push(small_data_two);
        auto pointer_three = stack.push(small_data_three);
        stack.pop<typeof(small_data_three)>();
        stack.pop<typeof(small_data_two)>();
        auto pointer_four = stack.push(small_data_two);
        auto pointer_five = stack.push(small_data_three);

        REQUIRE(reinterpret_cast<std::uintptr_t>(pointer_one) % CACHE_LINE_SIZE == 0);
        REQUIRE(reinterpret_cast<std::uintptr_t>(pointer_two) % CACHE_LINE_SIZE == 0);
        REQUIRE(reinterpret_cast<std::uintptr_t>(pointer_three) % CACHE_LINE_SIZE == 0);
        REQUIRE(reinterpret_cast<std::uintptr_t>(pointer_four) % CACHE_LINE_SIZE == 0);
        REQUIRE(reinterpret_cast<std::uintptr_t>(pointer_five) % CACHE_LINE_SIZE == 0);

        REQUIRE(pointer_four == pointer_two);
        REQUIRE(pointer_five == pointer_three);
    }
}

TEST_CASE( "deque stores objects correctly", "[internal/data_structures/deque.h]") {
    class my_item: public deque_item {

    };

    deque<my_item> deque;
    my_item one, two, three;

    SECTION( "add and remove items form the tail" ) {
        deque.push_tail(&one);
        deque.push_tail(&two);
        deque.push_tail(&three);

        REQUIRE(deque.pop_tail() == &three);
        REQUIRE(deque.pop_tail() == &two);
        REQUIRE(deque.pop_tail() == &one);
    }

    SECTION( "handles getting empty by popping the tail correctly" ) {
        deque.push_tail(&one);
        REQUIRE(deque.pop_tail() == &one);

        deque.push_tail(&two);
        REQUIRE(deque.pop_tail() == &two);
    }

    SECTION( "remove items form the head" ) {
        deque.push_tail(&one);
        deque.push_tail(&two);
        deque.push_tail(&three);

        REQUIRE(deque.pop_head() == &one);
        REQUIRE(deque.pop_head() == &two);
        REQUIRE(deque.pop_head() == &three);
    }

    SECTION( "handles getting empty by popping the head correctly" ) {
        deque.push_tail(&one);
        REQUIRE(deque.pop_head() == &one);

        deque.push_tail(&two);
        REQUIRE(deque.pop_head() == &two);
    }

    SECTION( "handles getting empty by popping the head and tail correctly" ) {
        deque.push_tail(&one);
        REQUIRE(deque.pop_tail() == &one);

        deque.push_tail(&two);
        REQUIRE(deque.pop_head() == &two);

        deque.push_tail(&three);
        REQUIRE(deque.pop_tail() == &three);
    }
}