539 lines
20 KiB
C++
539 lines
20 KiB
C++
/***************************************************************************************************
|
|
|
|
Zyan Core Library (Zycore-C)
|
|
|
|
Original Author : Florian Bernd
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
|
|
***************************************************************************************************/
|
|
|
|
/**
|
|
* @file
|
|
* @brief Tests the `ZyanVector` implementation.
|
|
*/
|
|
|
|
#include <time.h>
|
|
#include <gtest/gtest.h>
|
|
#include <Zycore/Comparison.h>
|
|
#include <Zycore/Vector.h>
|
|
|
|
/* ============================================================================================== */
|
|
/* Fixtures */
|
|
/* ============================================================================================== */
|
|
|
|
/* ---------------------------------------------------------------------------------------------- */
|
|
/* VectorTestBase */
|
|
/* ---------------------------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Implements a fixture-class that provides an initialized `ZyanVector` instance for
|
|
* `ZyanU64` values.
|
|
*/
|
|
class VectorTestBase : public ::testing::TestWithParam<bool>
|
|
{
|
|
protected:
|
|
static const ZyanUSize m_test_size = 100;
|
|
ZyanBool m_has_fixed_capacity;
|
|
ZyanVector m_vector;
|
|
std::vector<ZyanU64> m_buffer;
|
|
protected:
|
|
void SetUp() override
|
|
{
|
|
m_has_fixed_capacity = GetParam();
|
|
|
|
if (!m_has_fixed_capacity)
|
|
{
|
|
ASSERT_EQ(ZyanVectorInit(&m_vector, sizeof(ZyanU64), m_test_size,
|
|
reinterpret_cast<ZyanMemberProcedure>(ZYAN_NULL)), ZYAN_STATUS_SUCCESS);
|
|
} else
|
|
{
|
|
m_buffer.reserve(m_test_size);
|
|
ASSERT_EQ(ZyanVectorInitCustomBuffer(&m_vector, sizeof(ZyanU64), m_buffer.data(),
|
|
m_test_size, reinterpret_cast<ZyanMemberProcedure>(ZYAN_NULL)),
|
|
ZYAN_STATUS_SUCCESS);
|
|
}
|
|
}
|
|
|
|
void TearDown() override
|
|
{
|
|
EXPECT_EQ(ZyanVectorDestroy(&m_vector), ZYAN_STATUS_SUCCESS);
|
|
}
|
|
};
|
|
|
|
/* ---------------------------------------------------------------------------------------------- */
|
|
/* VectorTestFilled */
|
|
/* ---------------------------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @brief Implements a fixture-class that provides an initialized `ZyanVector` instance which
|
|
* is filled with `ZyanU64` values from 0..100.
|
|
*/
|
|
class VectorTestFilled : public VectorTestBase
|
|
{
|
|
protected:
|
|
void SetUp() override
|
|
{
|
|
VectorTestBase::SetUp();
|
|
|
|
if (m_has_fixed_capacity)
|
|
{
|
|
m_buffer.resize(m_test_size);
|
|
}
|
|
for (ZyanU64 i = 0; i < m_test_size; ++i)
|
|
{
|
|
ASSERT_EQ(ZyanVectorPushBack(&m_vector, &i), ZYAN_STATUS_SUCCESS);
|
|
}
|
|
}
|
|
};
|
|
|
|
/* ---------------------------------------------------------------------------------------------- */
|
|
|
|
/* ============================================================================================== */
|
|
/* Helper functions */
|
|
/* ============================================================================================== */
|
|
|
|
/**
|
|
* @brief A dummy constructor for `ZyanU64` objects.
|
|
*
|
|
* @param object A pointer to the object.
|
|
*
|
|
* @return A zyan status code.
|
|
*/
|
|
static ZyanStatus InitZyanU64(ZyanU64* object)
|
|
{
|
|
*object = 1337;
|
|
return ZYAN_STATUS_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* @brief A dummy destructor for `ZyanU16` objects.
|
|
*
|
|
* @param object A pointer to the object.
|
|
*
|
|
* @return A zyan status code.
|
|
*/
|
|
static ZyanStatus FreeZyanU16(ZyanU16* object)
|
|
{
|
|
*object = 0;
|
|
return ZYAN_STATUS_SUCCESS;
|
|
}
|
|
|
|
/* ============================================================================================== */
|
|
/* Tests */
|
|
/* ============================================================================================== */
|
|
|
|
TEST(VectorTest, InitBasic)
|
|
{
|
|
ZyanVector vector;
|
|
|
|
ASSERT_EQ(ZyanVectorInit(&vector, sizeof(ZyanU64), 0,
|
|
reinterpret_cast<ZyanMemberProcedure>(ZYAN_NULL)), ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(vector.allocator, ZyanAllocatorDefault());
|
|
EXPECT_EQ(vector.growth_factor, ZYAN_VECTOR_DEFAULT_GROWTH_FACTOR);
|
|
EXPECT_EQ(vector.shrink_threshold, ZYAN_VECTOR_DEFAULT_SHRINK_THRESHOLD);
|
|
EXPECT_EQ(vector.size, static_cast<ZyanUSize>(0));
|
|
EXPECT_EQ(vector.capacity, static_cast<ZyanUSize>(ZYAN_VECTOR_MIN_CAPACITY));
|
|
EXPECT_EQ(vector.element_size, sizeof(ZyanU64));
|
|
EXPECT_NE(vector.data, ZYAN_NULL);
|
|
EXPECT_EQ(ZyanVectorDestroy(&vector), ZYAN_STATUS_SUCCESS);
|
|
|
|
// Custom capacity
|
|
EXPECT_EQ(ZyanVectorInit(&vector, sizeof(ZyanU16), 10,
|
|
reinterpret_cast<ZyanMemberProcedure>(ZYAN_NULL)), ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(vector.capacity, static_cast<ZyanUSize>(ZYAN_MAX(ZYAN_VECTOR_MIN_CAPACITY, 10)));
|
|
EXPECT_EQ(ZyanVectorDestroy(&vector), ZYAN_STATUS_SUCCESS);
|
|
}
|
|
|
|
TEST(VectorTest, InitAdvanced)
|
|
{
|
|
ZyanVector vector;
|
|
|
|
ASSERT_EQ(ZyanVectorInitEx(&vector, sizeof(ZyanU16), 0,
|
|
reinterpret_cast<ZyanMemberProcedure>(ZYAN_NULL), ZyanAllocatorDefault(), 1, 0),
|
|
ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(vector.allocator, ZyanAllocatorDefault());
|
|
EXPECT_EQ(vector.growth_factor, 1);
|
|
EXPECT_EQ(vector.shrink_threshold, 0);
|
|
EXPECT_EQ(vector.size, static_cast<ZyanUSize>(0));
|
|
EXPECT_EQ(vector.capacity, static_cast<ZyanUSize>(ZYAN_VECTOR_MIN_CAPACITY));
|
|
EXPECT_EQ(vector.element_size, sizeof(ZyanU16));
|
|
EXPECT_NE(vector.data, ZYAN_NULL);
|
|
EXPECT_EQ(ZyanVectorDestroy(&vector), ZYAN_STATUS_SUCCESS);
|
|
|
|
// Custom capacity
|
|
EXPECT_EQ(ZyanVectorInitEx(&vector, sizeof(ZyanU16), 10,
|
|
reinterpret_cast<ZyanMemberProcedure>(ZYAN_NULL), ZyanAllocatorDefault(), 1, 0),
|
|
ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(vector.capacity, static_cast<ZyanUSize>(ZYAN_MAX(ZYAN_VECTOR_MIN_CAPACITY, 10)));
|
|
EXPECT_EQ(ZyanVectorDestroy(&vector), ZYAN_STATUS_SUCCESS);
|
|
}
|
|
|
|
TEST(VectorTest, InitCustomBuffer)
|
|
{
|
|
ZyanVector vector;
|
|
|
|
ZyanU16 buffer[32];
|
|
EXPECT_EQ(ZyanVectorInitCustomBuffer(&vector, sizeof(ZyanU16), &buffer, 0,
|
|
reinterpret_cast<ZyanMemberProcedure>(ZYAN_NULL)), ZYAN_STATUS_INVALID_ARGUMENT);
|
|
ASSERT_EQ(ZyanVectorInitCustomBuffer(&vector, sizeof(ZyanU16), &buffer,
|
|
ZYAN_ARRAY_LENGTH(buffer), reinterpret_cast<ZyanMemberProcedure>(ZYAN_NULL)),
|
|
ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(vector.allocator, ZYAN_NULL);
|
|
EXPECT_EQ(vector.growth_factor, 1);
|
|
EXPECT_EQ(vector.shrink_threshold, 0);
|
|
EXPECT_EQ(vector.size, static_cast<ZyanUSize>(0));
|
|
EXPECT_EQ(vector.capacity, ZYAN_ARRAY_LENGTH(buffer));
|
|
EXPECT_EQ(vector.element_size, sizeof(ZyanU16));
|
|
EXPECT_EQ(vector.data, &buffer);
|
|
EXPECT_EQ(ZyanVectorDestroy(&vector), ZYAN_STATUS_SUCCESS);
|
|
}
|
|
|
|
TEST(VectorTest, Destructor)
|
|
{
|
|
ZyanVector vector;
|
|
|
|
ZyanU16 buffer[16];
|
|
ASSERT_EQ(ZyanVectorInitCustomBuffer(&vector, sizeof(ZyanU16), &buffer,
|
|
ZYAN_ARRAY_LENGTH(buffer), reinterpret_cast<ZyanMemberProcedure>(&FreeZyanU16)),
|
|
ZYAN_STATUS_SUCCESS);
|
|
|
|
for (ZyanUSize i = 0; i < ZYAN_ARRAY_LENGTH(buffer); ++i)
|
|
{
|
|
const auto element = static_cast<ZyanU16>(i) + 0;
|
|
ASSERT_EQ(ZyanVectorPushBack(&vector, &element), ZYAN_STATUS_SUCCESS);
|
|
ASSERT_EQ(buffer[i], element);
|
|
}
|
|
|
|
ASSERT_EQ(ZyanVectorPopBack(&vector), ZYAN_STATUS_SUCCESS);
|
|
ASSERT_EQ(buffer[15], 0);
|
|
|
|
ASSERT_EQ(ZyanVectorDeleteRange(&vector, 12, 3), ZYAN_STATUS_SUCCESS);
|
|
ASSERT_EQ(buffer[12], 0);
|
|
ASSERT_EQ(buffer[13], 0);
|
|
ASSERT_EQ(buffer[14], 0);
|
|
|
|
ASSERT_EQ(ZyanVectorClear(&vector), ZYAN_STATUS_SUCCESS);
|
|
for (ZyanUSize i : buffer)
|
|
{
|
|
ASSERT_EQ(i, 0);
|
|
}
|
|
|
|
for (ZyanUSize i = 0; i < ZYAN_ARRAY_LENGTH(buffer); ++i)
|
|
{
|
|
const auto element = static_cast<ZyanU16>(i) + 1;
|
|
ASSERT_EQ(ZyanVectorPushBack(&vector, &element), ZYAN_STATUS_SUCCESS);
|
|
ASSERT_EQ(buffer[i], element);
|
|
}
|
|
|
|
EXPECT_EQ(ZyanVectorDestroy(&vector), ZYAN_STATUS_SUCCESS);
|
|
for (ZyanUSize i : buffer)
|
|
{
|
|
ASSERT_EQ(i, 0);
|
|
}
|
|
}
|
|
|
|
TEST(VectorTest, TestGrowingAndShrinking)
|
|
{
|
|
ZyanVector vector;
|
|
|
|
ASSERT_EQ(ZyanVectorInit(&vector, sizeof(ZyanU64), 0,
|
|
reinterpret_cast<ZyanMemberProcedure>(ZYAN_NULL)), ZYAN_STATUS_SUCCESS);
|
|
|
|
for (ZyanU64 i = 0; i < 100; ++i)
|
|
{
|
|
ZyanUSize expected_capacity = vector.capacity;
|
|
if (expected_capacity < (i + 1))
|
|
{
|
|
expected_capacity = (expected_capacity + 1) * vector.growth_factor;
|
|
}
|
|
ASSERT_EQ(ZyanVectorPushBack(&vector, &i), ZYAN_STATUS_SUCCESS);
|
|
ASSERT_EQ(vector.capacity, expected_capacity);
|
|
}
|
|
|
|
for (ZyanU64 i = 100; i > 0; --i)
|
|
{
|
|
const auto index = static_cast<ZyanUSize>(i - 1);
|
|
|
|
ZyanUSize expected_capacity = vector.capacity;
|
|
if ((vector.shrink_threshold != 0) && (index * vector.shrink_threshold < vector.capacity))
|
|
{
|
|
expected_capacity = ZYAN_MAX(1, (ZyanUSize)(index * vector.growth_factor));
|
|
}
|
|
ASSERT_EQ(ZyanVectorDelete(&vector, index), ZYAN_STATUS_SUCCESS);
|
|
ASSERT_EQ(vector.capacity, expected_capacity);
|
|
}
|
|
|
|
EXPECT_EQ(ZyanVectorDestroy(&vector), ZYAN_STATUS_SUCCESS);
|
|
}
|
|
|
|
TEST_P(VectorTestFilled, ElementAccess)
|
|
{
|
|
static const ZyanU64 element_in = 1337;
|
|
const ZyanU64* element_dummy;
|
|
ZyanU64* element_out_mut;
|
|
|
|
EXPECT_EQ(ZyanVectorSet(&m_vector, m_vector.size, &element_in),
|
|
ZYAN_STATUS_OUT_OF_RANGE);
|
|
EXPECT_EQ(ZyanVectorSet(&m_vector, m_vector.size - 1, &element_in),
|
|
ZYAN_STATUS_SUCCESS);
|
|
|
|
EXPECT_EQ(ZyanVectorGetPointer(&m_vector, m_vector.size,
|
|
reinterpret_cast<const void**>(&element_dummy)), ZYAN_STATUS_OUT_OF_RANGE);
|
|
EXPECT_EQ(ZYAN_VECTOR_GET(ZyanU64, &m_vector, m_vector.size - 1), element_in);
|
|
|
|
EXPECT_EQ(ZyanVectorGetPointerMutable(&m_vector, m_vector.size,
|
|
reinterpret_cast<void**>(&element_out_mut)), ZYAN_STATUS_OUT_OF_RANGE);
|
|
EXPECT_EQ(ZyanVectorGetPointerMutable(&m_vector, m_vector.size - 1,
|
|
reinterpret_cast<void**>(&element_out_mut)), ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(*element_out_mut, element_in);
|
|
*element_out_mut = 42;
|
|
EXPECT_EQ(ZYAN_VECTOR_GET(ZyanU64, &m_vector, m_vector.size - 1), 42);
|
|
|
|
if (m_has_fixed_capacity)
|
|
{
|
|
EXPECT_EQ(ZYAN_VECTOR_GET(ZyanU64, &m_vector, m_vector.size - 1),
|
|
m_buffer[m_vector.size - 1]);
|
|
}
|
|
}
|
|
|
|
TEST_P(VectorTestFilled, PushPop)
|
|
{
|
|
static const ZyanU64 element_in = 1337;
|
|
const ZyanUSize size = m_vector.size;
|
|
|
|
if (!m_has_fixed_capacity)
|
|
{
|
|
EXPECT_EQ(ZyanVectorPushBack(&m_vector, &element_in), ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(m_vector.size, size + 1);
|
|
EXPECT_EQ(ZYAN_VECTOR_GET(ZyanU64, &m_vector, size), element_in);
|
|
EXPECT_EQ(ZyanVectorPopBack(&m_vector), ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(m_vector.size, size);
|
|
} else
|
|
{
|
|
EXPECT_EQ(ZyanVectorPushBack(&m_vector, &element_in), ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE);
|
|
EXPECT_EQ(m_vector.size, size);
|
|
EXPECT_EQ(ZyanVectorPopBack(&m_vector), ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(m_vector.size, size - 1);
|
|
EXPECT_EQ(ZyanVectorPushBack(&m_vector, &element_in), ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(m_vector.size, size);
|
|
EXPECT_EQ(ZYAN_VECTOR_GET(ZyanU64, &m_vector, size - 1), element_in);
|
|
}
|
|
}
|
|
|
|
TEST_P(VectorTestFilled, Insert)
|
|
{
|
|
static const ZyanU64 elements[4] =
|
|
{
|
|
1337, 1338, 1339, 1340
|
|
};
|
|
const ZyanUSize count = ZYAN_ARRAY_LENGTH(elements);
|
|
|
|
if (m_has_fixed_capacity)
|
|
{
|
|
const ZyanUSize size_temp = m_vector.size;
|
|
EXPECT_EQ(ZyanVectorInsertRange(&m_vector, size_temp / 2, &elements, count),
|
|
ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE);
|
|
EXPECT_EQ(ZyanVectorResize(&m_vector, size_temp - count), ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(m_vector.size, size_temp - count);
|
|
}
|
|
|
|
const ZyanUSize size = m_vector.size;
|
|
const ZyanUSize half = (size / 2);
|
|
|
|
EXPECT_EQ(ZyanVectorInsertRange(&m_vector, half, &elements, ZYAN_ARRAY_LENGTH(elements)),
|
|
ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(m_vector.size, size + count);
|
|
for (ZyanUSize i = 0; i < m_vector.size; ++i)
|
|
{
|
|
const ZyanU64 element_out = ZYAN_VECTOR_GET(ZyanU64, &m_vector, i);
|
|
|
|
if ((i >= half) && (i < half + count))
|
|
{
|
|
EXPECT_EQ(element_out, elements[i - half]);
|
|
} else
|
|
if (i < half)
|
|
{
|
|
EXPECT_EQ(element_out, i);
|
|
} else
|
|
{
|
|
EXPECT_EQ(element_out, i - count);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_P(VectorTestFilled, Delete)
|
|
{
|
|
EXPECT_EQ(ZyanVectorDeleteRange(&m_vector, m_vector.size, 1), ZYAN_STATUS_OUT_OF_RANGE);
|
|
EXPECT_EQ(ZyanVectorDeleteRange(&m_vector, 1, m_vector.size), ZYAN_STATUS_OUT_OF_RANGE);
|
|
|
|
const ZyanUSize size = m_vector.size;
|
|
const ZyanUSize half = (size / 2);
|
|
const ZyanUSize count = (half / 2);
|
|
|
|
EXPECT_EQ(ZyanVectorDeleteRange(&m_vector, half, count), ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(m_vector.size, size - count);
|
|
for (ZyanUSize i = 0; i < m_vector.size; ++i)
|
|
{
|
|
const ZyanU64 element_out = ZYAN_VECTOR_GET(ZyanU64, &m_vector, i);
|
|
|
|
if ((i >= half) && (i < half + count))
|
|
{
|
|
EXPECT_EQ(element_out, i + count);
|
|
} else
|
|
if (i < half)
|
|
{
|
|
EXPECT_EQ(element_out, i);
|
|
} else
|
|
{
|
|
EXPECT_EQ(element_out, i - count);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_P(VectorTestFilled, Find)
|
|
{
|
|
ZyanISize index;
|
|
ZyanU64 element_in = m_vector.size / 2;
|
|
EXPECT_EQ(ZyanVectorFind(&m_vector, &element_in, &index,
|
|
reinterpret_cast<ZyanEqualityComparison>(&ZyanEqualsNumeric64)), ZYAN_STATUS_TRUE);
|
|
EXPECT_EQ(static_cast<ZyanU64>(index), element_in);
|
|
|
|
element_in = 1337;
|
|
EXPECT_EQ(ZyanVectorFind(&m_vector, &element_in, &index,
|
|
reinterpret_cast<ZyanEqualityComparison>(&ZyanEqualsNumeric64)), ZYAN_STATUS_FALSE);
|
|
EXPECT_EQ(index, -1);
|
|
|
|
// Edge cases
|
|
EXPECT_EQ(ZyanVectorFindEx(&m_vector, &element_in, &index,
|
|
reinterpret_cast<ZyanEqualityComparison>(&ZyanEqualsNumeric64), 0, 0),
|
|
ZYAN_STATUS_FALSE);
|
|
EXPECT_EQ(ZyanVectorFindEx(&m_vector, &element_in, &index,
|
|
reinterpret_cast<ZyanEqualityComparison>(&ZyanEqualsNumeric64), 0, m_vector.size + 1),
|
|
ZYAN_STATUS_OUT_OF_RANGE);
|
|
EXPECT_EQ(ZyanVectorFindEx(&m_vector, &element_in, &index,
|
|
reinterpret_cast<ZyanEqualityComparison>(&ZyanEqualsNumeric64), 1, m_vector.size),
|
|
ZYAN_STATUS_OUT_OF_RANGE);
|
|
}
|
|
|
|
TEST_P(VectorTestBase, BinarySearch)
|
|
{
|
|
EXPECT_EQ(ZyanVectorReserve(&m_vector, 100), ZYAN_STATUS_SUCCESS);
|
|
for (ZyanUSize i = 0; i < 100; ++i)
|
|
{
|
|
const ZyanU64 element = rand() % 100;
|
|
|
|
ZyanUSize index;
|
|
const ZyanStatus status = ZyanVectorBinarySearch(&m_vector, &element, &index,
|
|
reinterpret_cast<ZyanComparison>(&ZyanCompareNumeric64));
|
|
EXPECT_EQ(ZYAN_SUCCESS(status), ZYAN_TRUE);
|
|
EXPECT_EQ(ZyanVectorInsert(&m_vector, index, &element), ZYAN_STATUS_SUCCESS);
|
|
}
|
|
EXPECT_EQ(m_vector.size, static_cast<ZyanUSize>(100));
|
|
|
|
ZyanU64 element_out = ZYAN_VECTOR_GET(ZyanU64, &m_vector, 0);
|
|
for (ZyanUSize i = 1; i < m_vector.size; ++i)
|
|
{
|
|
const ZyanU64 value = element_out;
|
|
element_out = ZYAN_VECTOR_GET(ZyanU64, &m_vector, i);
|
|
EXPECT_GE(element_out, value);
|
|
}
|
|
|
|
// Edge cases
|
|
const ZyanU64 element_in = 1337;
|
|
ZyanUSize index;
|
|
EXPECT_EQ(ZyanVectorBinarySearchEx(&m_vector, &element_in, &index,
|
|
reinterpret_cast<ZyanComparison>(&ZyanCompareNumeric64), 0, 101),
|
|
ZYAN_STATUS_OUT_OF_RANGE);
|
|
EXPECT_EQ(ZyanVectorBinarySearchEx(&m_vector, &element_in, &index,
|
|
reinterpret_cast<ZyanComparison>(&ZyanCompareNumeric64), 1, 100),
|
|
ZYAN_STATUS_OUT_OF_RANGE);
|
|
}
|
|
|
|
TEST_P(VectorTestBase, Emplace)
|
|
{
|
|
ZyanU64* element_new;
|
|
|
|
for (ZyanUSize i = 0; i < 10; ++i)
|
|
{
|
|
EXPECT_EQ(ZyanVectorEmplace(&m_vector, reinterpret_cast<void**>(&element_new),
|
|
reinterpret_cast<ZyanMemberFunction>(ZYAN_NULL)), ZYAN_STATUS_SUCCESS);
|
|
*element_new = i;
|
|
}
|
|
EXPECT_EQ(m_vector.size, static_cast<ZyanUSize>(10));
|
|
|
|
for (ZyanUSize i = 0; i < m_vector.size; ++i)
|
|
{
|
|
EXPECT_EQ(ZYAN_VECTOR_GET(ZyanU64, &m_vector, i), i);
|
|
}
|
|
|
|
EXPECT_EQ(ZyanVectorEmplaceEx(&m_vector, 5, reinterpret_cast<void**>(&element_new),
|
|
reinterpret_cast<ZyanMemberFunction>(&InitZyanU64)), ZYAN_STATUS_SUCCESS);
|
|
EXPECT_EQ(*element_new, 1337);
|
|
EXPECT_EQ(ZYAN_VECTOR_GET(ZyanU64, &m_vector, 5), 1337);
|
|
}
|
|
|
|
TEST_P(VectorTestFilled, SwapElements)
|
|
{
|
|
EXPECT_EQ(m_vector.capacity, m_vector.size);
|
|
|
|
// Edge cases
|
|
EXPECT_EQ(ZyanVectorSwapElements(&m_vector, 0, m_vector.size), ZYAN_STATUS_OUT_OF_RANGE);
|
|
EXPECT_EQ(ZyanVectorSwapElements(&m_vector, m_vector.size, 0), ZYAN_STATUS_OUT_OF_RANGE);
|
|
EXPECT_EQ(ZyanVectorSwapElements(&m_vector, 0, m_vector.size - 1),
|
|
ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE);
|
|
|
|
// Free space for the temporary element
|
|
EXPECT_EQ(ZyanVectorPopBack(&m_vector), ZYAN_STATUS_SUCCESS);
|
|
|
|
// Retrieve element pointers
|
|
const ZyanU64* element_first;
|
|
EXPECT_EQ(ZyanVectorGetPointer(&m_vector, 0, reinterpret_cast<const void**>(&element_first)),
|
|
ZYAN_STATUS_SUCCESS);
|
|
const ZyanU64* element_second;
|
|
EXPECT_EQ(ZyanVectorGetPointer(&m_vector, m_vector.size - 1,
|
|
reinterpret_cast<const void**>(&element_second)), ZYAN_STATUS_SUCCESS);
|
|
|
|
const ZyanU64 values_before[2] = { *element_first, *element_second };
|
|
EXPECT_EQ(ZyanVectorSwapElements(&m_vector, 0, m_vector.size - 1), ZYAN_STATUS_SUCCESS);
|
|
const ZyanU64 values_after [2] = { *element_first, *element_second };
|
|
|
|
EXPECT_EQ(values_before[0], values_after[1]);
|
|
EXPECT_EQ(values_before[1], values_after[0]);
|
|
}
|
|
|
|
INSTANTIATE_TEST_SUITE_P(Param, VectorTestBase, ::testing::Values(false, true));
|
|
INSTANTIATE_TEST_SUITE_P(Param, VectorTestFilled, ::testing::Values(false, true));
|
|
|
|
/* ---------------------------------------------------------------------------------------------- */
|
|
|
|
/* ============================================================================================== */
|
|
/* Entry point */
|
|
/* ============================================================================================== */
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
time_t t;
|
|
srand(static_cast<unsigned>(time(&t)));
|
|
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|
|
|
|
/* ============================================================================================== */
|