508 lines
13 KiB
C++
508 lines
13 KiB
C++
/* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
|
|
|
// First include (the generated) my_config.h, to get correct platform defines.
|
|
#include "my_config.h"
|
|
#include <gtest/gtest.h>
|
|
#include <algorithm>
|
|
|
|
#include "prealloced_array.h"
|
|
#include "sql_alloc.h"
|
|
|
|
namespace prealloced_array_unittest {
|
|
|
|
class PreallocedArrayTest : public ::testing::Test
|
|
{
|
|
public:
|
|
PreallocedArrayTest()
|
|
: int_10(PSI_NOT_INSTRUMENTED)
|
|
{}
|
|
|
|
protected:
|
|
Prealloced_array<int, 10> int_10;
|
|
int some_integer;
|
|
};
|
|
|
|
|
|
TEST_F(PreallocedArrayTest, Empty)
|
|
{
|
|
EXPECT_EQ(10U, int_10.capacity());
|
|
EXPECT_EQ(sizeof(int), int_10.element_size());
|
|
EXPECT_TRUE(int_10.empty());
|
|
EXPECT_EQ(0U, int_10.size());
|
|
}
|
|
|
|
#if !defined(DBUG_OFF)
|
|
// Google Test recommends DeathTest suffix for classes used in death tests.
|
|
typedef PreallocedArrayTest PreallocedArrayDeathTest;
|
|
|
|
TEST_F(PreallocedArrayDeathTest, OutOfBoundsRead)
|
|
{
|
|
::testing::FLAGS_gtest_death_test_style = "threadsafe";
|
|
EXPECT_DEATH_IF_SUPPORTED(some_integer= int_10[5],
|
|
".*Assertion .*n < size.*");
|
|
}
|
|
|
|
TEST_F(PreallocedArrayDeathTest, OutOfBoundsWrite)
|
|
{
|
|
::testing::FLAGS_gtest_death_test_style = "threadsafe";
|
|
EXPECT_DEATH_IF_SUPPORTED(int_10[5] = some_integer,
|
|
".*Assertion .*n < size.*");
|
|
}
|
|
|
|
TEST_F(PreallocedArrayDeathTest, EmptyBack)
|
|
{
|
|
::testing::FLAGS_gtest_death_test_style = "threadsafe";
|
|
EXPECT_DEATH_IF_SUPPORTED(int_10.back() = 42,
|
|
".*Assertion .*n < size.*");
|
|
}
|
|
|
|
TEST_F(PreallocedArrayDeathTest, EmptyPopBack)
|
|
{
|
|
::testing::FLAGS_gtest_death_test_style = "threadsafe";
|
|
EXPECT_DEATH_IF_SUPPORTED(int_10.pop_back(),
|
|
".*Assertion .*!empty.*");
|
|
}
|
|
|
|
TEST_F(PreallocedArrayDeathTest, EmptyErase)
|
|
{
|
|
::testing::FLAGS_gtest_death_test_style = "threadsafe";
|
|
size_t ix= 0;
|
|
EXPECT_DEATH_IF_SUPPORTED(int_10.erase(ix),
|
|
".*Assertion .*ix < size.*");
|
|
}
|
|
|
|
#endif // DBUG_OFF
|
|
|
|
TEST_F(PreallocedArrayTest, Insert5)
|
|
{
|
|
for (int ix= 0; ix < 5; ++ix)
|
|
int_10.push_back(ix);
|
|
for (int ix= 0; ix < 5; ++ix)
|
|
EXPECT_EQ(ix, int_10[ix]);
|
|
for (int ix= 0; ix < 5; ++ix)
|
|
int_10[ix]= ix;
|
|
EXPECT_EQ(5U, int_10.size());
|
|
EXPECT_EQ(10U, int_10.capacity());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, Insert15)
|
|
{
|
|
for (int ix= 0; ix < 15; ++ix)
|
|
int_10.push_back(ix);
|
|
for (int ix= 0; ix < 15; ++ix)
|
|
EXPECT_EQ(ix, int_10[ix]);
|
|
for (int ix= 0; ix < 15; ++ix)
|
|
int_10[ix]= ix;
|
|
EXPECT_EQ(15U, int_10.size());
|
|
EXPECT_LE(15U, int_10.capacity());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, Sort)
|
|
{
|
|
for (int ix= 20; ix >= 0; --ix)
|
|
int_10.push_back(ix);
|
|
std::sort(int_10.begin(), int_10.end());
|
|
for (int ix= 0; ix <= 20; ++ix)
|
|
EXPECT_EQ(ix, int_10[ix]);
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, Back)
|
|
{
|
|
for (int ix= 0; ix <= 15; ++ix)
|
|
int_10.push_back(ix);
|
|
EXPECT_EQ(15, int_10.back());
|
|
int_10.back()= 42;
|
|
EXPECT_EQ(42, int_10.back());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, PopBack)
|
|
{
|
|
for (int ix= 0; ix <= 15; ++ix)
|
|
int_10.push_back(ix);
|
|
for (int ix= 15; ix >= 0; --ix)
|
|
{
|
|
EXPECT_EQ(ix, int_10.back());
|
|
int_10.pop_back();
|
|
}
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, EraseFirst)
|
|
{
|
|
for (int ix= 0; ix <= 15; ++ix)
|
|
int_10.push_back(ix);
|
|
EXPECT_EQ(0, int_10[0]);
|
|
EXPECT_EQ(16U, int_10.size());
|
|
int_10.erase(int_10.begin());
|
|
EXPECT_EQ(15U, int_10.size());
|
|
for (int ix= 0; ix < static_cast<int>(int_10.size()); ++ix)
|
|
{
|
|
EXPECT_EQ(ix + 1, int_10[ix]);
|
|
}
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, EraseLast)
|
|
{
|
|
for (int ix= 0; ix <= 15; ++ix)
|
|
int_10.push_back(ix);
|
|
EXPECT_EQ(15, int_10.back());
|
|
EXPECT_EQ(15, int_10.at(15));
|
|
int_10.erase(15);
|
|
EXPECT_EQ(14, int_10.back());
|
|
EXPECT_EQ(14, int_10.at(14));
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, EraseMiddle)
|
|
{
|
|
for (int ix= 0; ix <= 15; ++ix)
|
|
int_10.push_back(ix);
|
|
EXPECT_EQ(6, int_10[6]);
|
|
EXPECT_EQ(7, int_10[7]);
|
|
EXPECT_EQ(16U, int_10.size());
|
|
int_10.erase(7);
|
|
EXPECT_EQ(6, int_10[6]);
|
|
EXPECT_EQ(8, int_10[7]);
|
|
EXPECT_EQ(9, int_10[8]);
|
|
EXPECT_EQ(15U, int_10.size());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, ResizeSame)
|
|
{
|
|
for (int ix= 0; ix <= 15; ++ix)
|
|
int_10.push_back(ix);
|
|
EXPECT_EQ(16U, int_10.size());
|
|
int_10.resize(16U);
|
|
EXPECT_EQ(16U, int_10.size());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, ResizeGrow)
|
|
{
|
|
int_10.push_back(1);
|
|
int_10.resize(20);
|
|
EXPECT_EQ(1, int_10[0]);
|
|
EXPECT_EQ(0, int_10[1]);
|
|
EXPECT_EQ(20U, int_10.size());
|
|
EXPECT_GE(int_10.capacity(), 20U);
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, ResizeGrowVal)
|
|
{
|
|
int_10.resize(20, 42);
|
|
EXPECT_EQ(42, int_10[0]);
|
|
EXPECT_EQ(42, int_10[19]);
|
|
EXPECT_EQ(20U, int_10.size());
|
|
EXPECT_GE(int_10.capacity(), 20U);
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, ResizeShrink)
|
|
{
|
|
for (int ix= 0; ix <= 15; ++ix)
|
|
int_10.push_back(ix);
|
|
EXPECT_EQ(16U, int_10.size());
|
|
int_10.resize(10);
|
|
EXPECT_EQ(10U, int_10.size());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, InsertUnique)
|
|
{
|
|
for (int ix= 0; ix < 10; ++ix)
|
|
{
|
|
int_10.push_back(ix);
|
|
int_10.push_back(ix);
|
|
}
|
|
std::random_shuffle(int_10.begin(), int_10.end());
|
|
Prealloced_array<int, 1> unique_arr(PSI_NOT_INSTRUMENTED);
|
|
for (int *pi= int_10.begin(); pi != int_10.end(); ++pi)
|
|
{
|
|
unique_arr.insert_unique(*pi);
|
|
EXPECT_EQ(1U, unique_arr.count_unique(*pi));
|
|
}
|
|
EXPECT_EQ(10U, unique_arr.size());
|
|
// Duplicates should have been ignored, and the result should be sorted.
|
|
for (int ix= 0; ix < static_cast<int>(unique_arr.size()); ++ix)
|
|
{
|
|
EXPECT_EQ(ix, unique_arr[ix]);
|
|
}
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, EraseUnique)
|
|
{
|
|
for (int ix= 0; ix < 20; ++ix)
|
|
int_10.push_back(ix);
|
|
|
|
// The array should be sorted by default.
|
|
for (int ix= 0; ix < 20; ++ix)
|
|
EXPECT_EQ(ix, int_10[ix]);
|
|
|
|
// Now remove all even numbers.
|
|
for (int ix= 0; ix < 10; ++ix)
|
|
EXPECT_EQ(1U, int_10.erase_unique(2 * ix));
|
|
|
|
// 10 numbers should remain.
|
|
EXPECT_EQ(10U, int_10.size());
|
|
|
|
// Removing non-existing numbers should return 0.
|
|
for (int ix= 0; ix < 10; ++ix)
|
|
{
|
|
EXPECT_EQ(0U, int_10.count_unique(2 * ix));
|
|
EXPECT_EQ(0U, int_10.erase_unique(2 * ix));
|
|
}
|
|
|
|
// 10 numbers should still remain.
|
|
EXPECT_EQ(10U, int_10.size());
|
|
|
|
// The array should still be sorted and contain odd numbers.
|
|
for (int ix= 0; ix < 10; ++ix)
|
|
EXPECT_EQ(2 * ix + 1, int_10[ix]);
|
|
}
|
|
|
|
/*
|
|
A simple class for testing that object copying and destruction is done
|
|
properly when we have to expand the array a few times,
|
|
and has_trivial_destructor == false.
|
|
*/
|
|
class IntWrap
|
|
{
|
|
public:
|
|
IntWrap()
|
|
{
|
|
m_int= new int(0);
|
|
}
|
|
explicit IntWrap(int arg)
|
|
{
|
|
m_int= new int(arg);
|
|
}
|
|
IntWrap(const IntWrap &other)
|
|
{
|
|
m_int= new int(other.getval());
|
|
}
|
|
~IntWrap()
|
|
{
|
|
delete m_int;
|
|
}
|
|
IntWrap &operator=(const IntWrap &rhs)
|
|
{
|
|
*m_int= rhs.getval();
|
|
return *this;
|
|
}
|
|
|
|
int getval() const { return *m_int; }
|
|
private:
|
|
int *m_int;
|
|
};
|
|
|
|
/*
|
|
To verify that there are no leaks, do:
|
|
valgrind ./prealloced_array-t --gtest_filter="-*DeathTest*"
|
|
*/
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksPushing)
|
|
{
|
|
Prealloced_array<IntWrap, 1, false> array(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array.push_back(IntWrap(ix));
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
EXPECT_EQ(ix, array[ix].getval());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksPopping)
|
|
{
|
|
Prealloced_array<IntWrap, 1, false> array(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array.push_back(IntWrap(ix));
|
|
while (!array.empty())
|
|
array.pop_back();
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksErasing)
|
|
{
|
|
Prealloced_array<IntWrap, 1, false> array(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array.push_back(IntWrap(ix));
|
|
for (int ix= 0; !array.empty(); ++ix)
|
|
{
|
|
EXPECT_EQ(ix, array[0].getval());
|
|
array.erase(array.begin());
|
|
}
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksClearing)
|
|
{
|
|
Prealloced_array<IntWrap, 1, false> array(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array.push_back(IntWrap(ix));
|
|
array.clear();
|
|
EXPECT_EQ(0U, array.size());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksResizing)
|
|
{
|
|
Prealloced_array<IntWrap, 1, false> array(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array.push_back(IntWrap(ix));
|
|
array.resize(0);
|
|
EXPECT_EQ(0U, array.size());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksAssigning)
|
|
{
|
|
Prealloced_array<IntWrap, 1, false> array1(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array1.push_back(IntWrap(ix));
|
|
Prealloced_array<IntWrap, 1, false> array2(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 10; ++ix)
|
|
array2.push_back(IntWrap(ix + 100));
|
|
array2= array1;
|
|
EXPECT_EQ(array1.size(), array2.size());
|
|
for (size_t ix= 0; ix < array1.size(); ++ix)
|
|
EXPECT_EQ(array1[ix].getval(), array2[ix].getval());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksEraseAll)
|
|
{
|
|
Prealloced_array<IntWrap, 1, false> array(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array.push_back(IntWrap(ix));
|
|
array.erase(array.begin(), array.end());
|
|
EXPECT_EQ(0U, array.size());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksEraseMiddle)
|
|
{
|
|
Prealloced_array<IntWrap, 1, false> array(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array.push_back(IntWrap(ix));
|
|
array.erase(array.begin() + 1, array.end() - 1);
|
|
EXPECT_EQ(2U, array.size());
|
|
EXPECT_EQ(0, array[0].getval());
|
|
EXPECT_EQ(41, array[1].getval());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksEraseSwap)
|
|
{
|
|
Prealloced_array<IntWrap, 1, false> array1(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array1.push_back(IntWrap(ix));
|
|
Prealloced_array<IntWrap, 1, false> array2(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 10; ++ix)
|
|
array2.push_back(IntWrap(ix + 100));
|
|
array1.swap(array2);
|
|
EXPECT_EQ(10U, array1.size());
|
|
EXPECT_EQ(42U, array2.size());
|
|
Prealloced_array<IntWrap, 1, false>(PSI_NOT_INSTRUMENTED).swap(array1);
|
|
EXPECT_EQ(0U, array1.size());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksMySwap)
|
|
{
|
|
Prealloced_array<IntWrap, 2, false> array1(PSI_NOT_INSTRUMENTED);
|
|
Prealloced_array<IntWrap, 2, false> array2(PSI_NOT_INSTRUMENTED);
|
|
array1.push_back(IntWrap(1));
|
|
array2.push_back(IntWrap(2));
|
|
array2.push_back(IntWrap(22));
|
|
array1.swap(array2);
|
|
EXPECT_EQ(2U, array1.size());
|
|
EXPECT_EQ(1U, array2.size());
|
|
EXPECT_EQ(2, array1[0].getval());
|
|
EXPECT_EQ(22, array1[1].getval());
|
|
EXPECT_EQ(1, array2[0].getval());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksStdSwap)
|
|
{
|
|
Prealloced_array<IntWrap, 1, false> array1(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array1.push_back(IntWrap(ix));
|
|
Prealloced_array<IntWrap, 1, false>
|
|
array2(PSI_NOT_INSTRUMENTED, array1.begin(), array1.begin() + 10);
|
|
EXPECT_EQ(10U, array2.size());
|
|
IntWrap *p1= array1.begin();
|
|
IntWrap *p2= array2.begin();
|
|
array1.swap(array2);
|
|
EXPECT_EQ(10U, array1.size());
|
|
EXPECT_EQ(42U, array2.size());
|
|
// We expect a buffer swap here.
|
|
EXPECT_EQ(p1, array2.begin());
|
|
EXPECT_EQ(p2, array1.begin());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksShrinkToFitMalloc)
|
|
{
|
|
Prealloced_array<IntWrap, 1, false> array1(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array1.push_back(IntWrap(ix));
|
|
IntWrap *p1= array1.begin();
|
|
array1.shrink_to_fit();
|
|
EXPECT_EQ(42U, array1.size());
|
|
EXPECT_EQ(42U, array1.capacity());
|
|
EXPECT_NE(p1, array1.begin());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksShrinkToFitSameSize)
|
|
{
|
|
Prealloced_array<IntWrap, 10, false> array1(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array1.push_back(IntWrap(ix));
|
|
for (int ix= 0; array1.size() != array1.capacity(); ++ix)
|
|
array1.push_back(IntWrap(ix));
|
|
IntWrap *p1= array1.begin();
|
|
array1.shrink_to_fit();
|
|
EXPECT_EQ(p1, array1.begin());
|
|
}
|
|
|
|
TEST_F(PreallocedArrayTest, NoMemLeaksShrinkToFitPrealloc)
|
|
{
|
|
Prealloced_array<IntWrap, 100, false> array1(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array1.push_back(IntWrap(ix));
|
|
IntWrap *p1= array1.begin();
|
|
array1.shrink_to_fit();
|
|
EXPECT_EQ(42U, array1.size());
|
|
EXPECT_EQ(100U, array1.capacity());
|
|
EXPECT_EQ(p1, array1.begin());
|
|
}
|
|
|
|
/*
|
|
A simple class to verify that Prealloced_array also works for
|
|
classes which have their own operator new/delete.
|
|
*/
|
|
class TestAlloc : public Sql_alloc
|
|
{
|
|
public:
|
|
explicit TestAlloc(int val)
|
|
: m_int(val)
|
|
{}
|
|
|
|
int getval() const { return m_int; }
|
|
private:
|
|
int m_int;
|
|
};
|
|
|
|
|
|
/*
|
|
There is no THD and no mem-root available for the execution of this test.
|
|
This shows that the memory management of Prealloced_array works OK for
|
|
classes inheriting from Sql_alloc.
|
|
*/
|
|
TEST_F(PreallocedArrayTest, SqlAlloc)
|
|
{
|
|
Prealloced_array<TestAlloc, 1, false> array(PSI_NOT_INSTRUMENTED);
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
array.push_back(TestAlloc(ix));
|
|
for (int ix= 0; ix < 42; ++ix)
|
|
EXPECT_EQ(ix, array[ix].getval());
|
|
}
|
|
|
|
}
|