#include <cstdio>
#include <gtest/gtest.h>

extern "C"
{
#include <port_adapter_mapping.h>
}

unsigned int g_logger_to_stdout = 1;
unsigned int g_logger_level = LOG_DEBUG;

class TestPortAdapterMapping : public ::testing::Test
{
  protected:
    static void SetUpTestCase()
    {
        port_adapter_mapping_init();
    }

    static void TearDownTestCase()
    {
        port_adapter_mapping_deinit();
    }
};

/* Insert one test */
TEST_F(TestPortAdapterMapping, InsertOne)
{
    ASSERT_EQ(port_adapter_mapping_insert(0, ADAPTER_TYPE_EF), 0);
    ASSERT_EQ(port_adapter_mapping_match(0), ADAPTER_TYPE_EF);

    ASSERT_EQ(port_adapter_mapping_insert(1, ADAPTER_TYPE_VWIRE), 0);
    ASSERT_EQ(port_adapter_mapping_match(1), ADAPTER_TYPE_VWIRE);

    ASSERT_EQ(port_adapter_mapping_insert(2, ADAPTER_TYPE_TERA), 0);
    ASSERT_EQ(port_adapter_mapping_match(2), ADAPTER_TYPE_TERA);
}

/* Insert match and remove */
TEST_F(TestPortAdapterMapping, InsertMatchAndRemove)
{
    port_adapter_mapping_clear();

    uint16_t free_capacity = port_adapter_mapping_capacity_get();
    for (uint16_t i = 0; i < free_capacity; i++)
    {
        enum adapter_type type;
        if (i % 3 == 0)
        {
            type = ADAPTER_TYPE_EF;
        }
        else if (i % 3 == 1)
        {
            type = ADAPTER_TYPE_VWIRE;
        }
        else
        {
            type = ADAPTER_TYPE_TERA;
        }

        ASSERT_EQ(port_adapter_mapping_insert(i, type), 0);
    }

    ASSERT_EQ(port_adapter_mapping_capacity_get(), 0);
    port_adapter_mapping_dump();

    for (uint16_t i = 0; i < free_capacity; i++)
    {
        enum adapter_type type;
        if (i % 3 == 0)
        {
            type = ADAPTER_TYPE_EF;
        }
        else if (i % 3 == 1)
        {
            type = ADAPTER_TYPE_VWIRE;
        }
        else
        {
            type = ADAPTER_TYPE_TERA;
        }

        ASSERT_EQ(port_adapter_mapping_match(i), type);
    }

    for (uint16_t i = 0; i < free_capacity; i++)
    {
        ASSERT_EQ(port_adapter_mapping_remove(i), 0);
    }

    ASSERT_NE(port_adapter_mapping_capacity_get(), 0);
}

/* Insert out of max */
TEST_F(TestPortAdapterMapping, InsertOutOfMax)
{
    port_adapter_mapping_clear();

    uint16_t free_capacity = port_adapter_mapping_capacity_get();
    for (uint16_t i = 0; i < free_capacity; i++)
    {
        ASSERT_EQ(port_adapter_mapping_insert(i, ADAPTER_TYPE_EF), 0);
    }

    ASSERT_DEATH(port_adapter_mapping_insert(free_capacity, ADAPTER_TYPE_EF), "./*");
}

/* Reinitialization */
TEST_F(TestPortAdapterMapping, Reinitialization)
{
    ASSERT_DEATH(port_adapter_mapping_init(), "./*");
    printf("free_capacity:%u\n", port_adapter_mapping_capacity_get());
}

/* Main func */
int main(int argc, char * argv[])
{
    /* generate eal parameters */
    const char * eal_args[] = {"unittest", "-c", "0x1", "-n", "4", "--proc-type", "auto", "--no-huge", "-m", "2048"};
    if (rte_eal_init(RTE_DIM(eal_args), (char **)eal_args) < 0)
    {
        return -1;
    }

    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}