/home/palakars/workspace-inprogress/code-in-progress/aitools3/aitools3-aq-invertedindex-cpp/test/core/TestByteBuffer.cpp

Go to the documentation of this file.

#include <boost/test/unit_test.hpp>
#include "ByteBuffer.hpp"
#include <stdint.h>
#include <cstring>

using namespace aitools::invertedindex;

BOOST_AUTO_TEST_SUITE(byte_buffer);

BOOST_AUTO_TEST_CASE(explicit_ctor)
{
        ByteBuffer buffer_a;
        BOOST_CHECK(buffer_a.data() != NULL);
        ByteBuffer buffer_b(0);
        BOOST_CHECK(buffer_b.data() != NULL);
        ByteBuffer buffer_c(1);
        BOOST_CHECK(buffer_c.data() != NULL);
        BOOST_CHECK_THROW(ByteBuffer(UINT64_MAX), std::bad_alloc);
}

BOOST_AUTO_TEST_CASE(copy_ctor)
{
        ByteBuffer buffer(10);
        ByteBuffer copy(buffer);
        BOOST_CHECK(buffer.data() != copy.data());
        BOOST_CHECK_EQUAL(buffer.size(), copy.size());
}

BOOST_AUTO_TEST_CASE(clear)
{
        ByteBuffer buffer(10);
        buffer.clear();
        BOOST_CHECK_EQUAL(buffer.empty(), true);
        BOOST_CHECK_EQUAL(buffer.capacity(), 10);
        BOOST_CHECK_EQUAL(buffer.size(), 0);
}

BOOST_AUTO_TEST_CASE(free)
{
        ByteBuffer buffer(10);
        BOOST_CHECK_EQUAL(buffer.capacity(), 10);
        BOOST_CHECK_EQUAL(buffer.size(), 10);
        buffer.free();
        BOOST_CHECK_EQUAL(buffer.capacity(), 0);
        BOOST_CHECK_EQUAL(buffer.size(), 0);
        BOOST_CHECK(buffer.data() == NULL);
}

BOOST_AUTO_TEST_CASE(empty)
{
        ByteBuffer buffer_a;
        BOOST_CHECK_EQUAL(buffer_a.empty(), true);
        ByteBuffer buffer_b(0);
        BOOST_CHECK_EQUAL(buffer_b.empty(), true);
        ByteBuffer buffer_c(1);
        BOOST_CHECK_EQUAL(buffer_c.empty(), false);
}

BOOST_AUTO_TEST_CASE(assignment_operator)
{
        ByteBuffer buffer;
        ByteBuffer copy = buffer; // calls copy c'tor
        BOOST_CHECK(std::memcmp(buffer.data(), copy.data(), buffer.size()) == 0);

        buffer.resize(10);
        copy = buffer; // calls assignment operator
        BOOST_CHECK(std::memcmp(buffer.data(), copy.data(), buffer.size()) == 0);
}

BOOST_AUTO_TEST_CASE(resize)
{
        ByteBuffer buffer;
        buffer.resize(10);
        BOOST_CHECK_EQUAL(buffer.size(), 10);
        buffer.resize(20);
        BOOST_CHECK_EQUAL(buffer.size(), 20);
        BOOST_CHECK_THROW(buffer.resize(UINT64_MAX), std::bad_alloc);
}

BOOST_AUTO_TEST_CASE(size)
{
        ByteBuffer buffer_a;
        BOOST_CHECK_EQUAL(buffer_a.size(), 0);
        ByteBuffer buffer_b(1);
        BOOST_CHECK_EQUAL(buffer_b.size(), 1);
}

BOOST_AUTO_TEST_CASE(capacity)
{
        ByteBuffer buffer_a;
        BOOST_CHECK_EQUAL(buffer_a.capacity(), 0);
        ByteBuffer buffer_b(1);
        BOOST_CHECK_EQUAL(buffer_b.capacity(), 1);
        buffer_a.resize(10);
        BOOST_CHECK_EQUAL(buffer_a.capacity(), 10);
        buffer_a.resize(5);
        BOOST_CHECK_EQUAL(buffer_a.capacity(), 10);
        BOOST_CHECK_EQUAL(buffer_a.size(), 5);
}

BOOST_AUTO_TEST_SUITE_END();

---