dynarmic/tests/Vector.cpp
Alexandre Bouvier cd2ede593a Squashed 'externals/zycore/' changes from 0c372cde..1401fb85
1401fb85 Fix `a label can only be part of a statement` warning (#61)
5f650a18 CMake: Enable `CMAKE_MSVC_RUNTIME_LIBRARY` (MSVC)
6c958cfe Fix no-libc build on "other" platforms (#58)
59819206 Bump version to v1.4.0
4bc563f6 Fix build-system to better work with vcpkg (#56)
4a8b5e2a CMake: rename target `doc` -> `ZycoreDoc`
a754e112 Bump version to 1.3.0
3e95307d Add support for ppc(64) and riscv64 (#52)
8f39333a build: only enable CXX if needed
7bd75696 build: add doc target
7c33e13e Fix `ZYAN_TRUE`/`ZYAN_FALSE` signedness
a0feec7f Fix warning `C4668`
bdbd3ff4 Bump version to v1.2
60b6ef1c Fix for dynamic libraries too
310f362c Adding ARCHIVE DESTINATION to fix CMake error
b01063b8 Improved logic for enabling LTO
c58d7fb5 Don't enable C11 for MSVC
ee784564 Switch minimum C standard supported to C11
5c341bf1 Implement an initial set of cross-compiler atomic operations
b4949ccc Minor fixes
9a305f6a Add CI workflow
dd2211a0 Get rid of CMake export headers
f0fb3f78 Fix `ZYAN_VECTOR_FOREACH_MUTABLE` macro
3f263290 format: handle encoding on wasm
95d7fb6c format: handle hex encoding on wasm
0d37fc54 defines: add wasm/wasi detection
8983325b build: use -pthread when possible
3de49d41 build: use system GTest when available
8d46cb58 test: make tests runnable with ctest
636bb299 Remove `float`s from the project (kernel mode compatibility) (#36)
e2b37b10 Assert to ensure sane growth factors
94185407 Added limits for integer types
767719d9 build(cmake): export and install zyan_* functions (#33)
6c93d9a3 build(cmake): add version and soversion to the library
fc2798d4 build(cmake): fix PUBLIC include dir of installed lib
22ce9c2d Add `ZYAN_FORCE_ASSERTS` CMake option
9a301424 Remove disabling source files in no-libc mode in CMake
3be54fca Thread.c: add missing SDK prototypes for old versions of Windows
d7fc85fd Exclude API/Memory.c and API/Process.c from compilation in no-libc mode
8da0001a Add back #ifdef guards to "API" headers/sources for no-libc mode
f6a48866 Fix cmake config files (#27)
4f3746fa Merge pull request #26 from Tsn0w/master
a9bb54ad Replace fallthrough attribute to __fallthrough__
99a74acb Add `ZYDIS_NOINLINE` macro

git-subtree-dir: externals/zycore
git-subtree-split: 1401fb85ac313f6605ec795c52bf99ea3f292a69
2022-11-20 21:49:18 +01:00

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();
}
/* ============================================================================================== */