Skip to content

Commit

Permalink
Merge pull request #3876 from MikeLing/fix_the_leaking_unit_test
Browse files Browse the repository at this point in the history 
fix the leaking DynamicArray unittest
  • Loading branch information
@vigsterkr
vigsterkr committed Jun 30, 2017
2 parents a592dd9 + e240fba commit 5a56a77
Showing 1 changed file with 86 additions and 174 deletions.
260 changes: 86 additions & 174 deletions tests/unit/lib/DynamicArray_unittest.cc
View file
Expand Up @@ -8,265 +8,177 @@
using namespace shogun;

template <typename T>
class CDynamicArrayTest : public ::testing::Test
class CDynamicArrayFixture : public ::testing::Test
{
protected:
CDynamicArrayTest()
CDynamicArrayFixture()
{
}
virtual void SetUp()
{
default_array = new CDynamicArray<T>();
custom_array = new CDynamicArray<T>(5);
}
virtual void TearDown()
{
SG_FREE(default_array);
SG_FREE(custom_array);
}
virtual ~CDynamicArrayTest()
{
}
CDynamicArray<T>* default_array;
CDynamicArray<T>* custom_array;
};

class CDynamicArrayFixture : public ::testing::Test
{
protected:
CDynamicArrayFixture()
{
b_array = SG_MALLOC(bool, 5);
i_array = SG_MALLOC(int32_t, 5);
m_array = SG_MALLOC(T, 5);
for (int32_t i = 0; i < 5; i++)
{
b_array[i] = true;
}
for (int32_t i = 0; i < 5; i++)
{
i_array[i] = i;
m_array[i] = (T)i;
}
}
virtual void SetUp()
{
wrapper_array_b = new CDynamicArray<bool>(this->b_array, 5);
wrapper_array_i = new CDynamicArray<int32_t>(this->i_array, 5);
wrapper_array = new CDynamicArray<T>(m_array, 5);
SG_FREE(m_array);
}
virtual void TearDown()
{
SG_FREE(wrapper_array_b);
SG_FREE(wrapper_array_i);
SG_UNREF(wrapper_array);
}
virtual ~CDynamicArrayFixture()
{
SG_FREE(b_array);
SG_FREE(i_array);
}
CDynamicArray<bool>* wrapper_array_b;
CDynamicArray<int32_t>* wrapper_array_i;

bool* b_array;
int32_t* i_array;
CDynamicArray<T>* wrapper_array;
T* m_array;
};

typedef ::testing::Types<int32_t, bool> Implementations;

TYPED_TEST_CASE(CDynamicArrayTest, Implementations);
typedef ::testing::Types<bool, char, int8_t, uint8_t, int16_t, int32_t, int64_t,
float32_t, float64_t>
DynamicArrayTypes;
TYPED_TEST_CASE(CDynamicArrayFixture, DynamicArrayTypes);

TYPED_TEST(CDynamicArrayTest, default_array_ctor)
TYPED_TEST(CDynamicArrayFixture, array_ctor)
{
EXPECT_EQ(this->default_array->get_num_elements(), 0);
EXPECT_EQ(this->default_array->get_array_size(), 128);
}

TYPED_TEST(CDynamicArrayTest, custom_array_ctor)
{
EXPECT_EQ(this->custom_array->get_num_elements(), 0);
EXPECT_EQ(this->custom_array->get_array_size(), 5);
}

TEST_F(CDynamicArrayFixture, wrapper_array_ctor)
{
EXPECT_EQ(wrapper_array_b->get_num_elements(), 5);
EXPECT_EQ(wrapper_array_i->get_num_elements(), 5);
EXPECT_EQ(this->wrapper_array->get_num_elements(), 5);
EXPECT_EQ(this->wrapper_array->get_array_size(), 5);
for (index_t i = 0; i < 5; i++)
{
EXPECT_EQ(wrapper_array_b->get_element(i), true);
EXPECT_EQ(wrapper_array_i->get_element(i), i);
EXPECT_EQ(this->wrapper_array->get_element(i), (TypeParam)i);
}
}

TYPED_TEST(CDynamicArrayTest, resize_array)
TYPED_TEST(CDynamicArrayFixture, resize_array)
{
this->default_array->resize_array(10);
this->custom_array->resize_array(10);
EXPECT_EQ(this->default_array->get_array_size(), 128);
EXPECT_EQ(this->custom_array->get_array_size(), 15);
this->wrapper_array->resize_array(10);
EXPECT_EQ(this->wrapper_array->get_array_size(), 15);
}

TEST_F(CDynamicArrayFixture, set_array)
TYPED_TEST(CDynamicArrayFixture, set_array)
{
bool* b_array_n = SG_MALLOC(bool, 5);
int32_t* i_array_n = SG_MALLOC(int32_t, 5);
this->wrapper_array->reset_array();
EXPECT_EQ(this->wrapper_array->get_num_elements(), 0);
TypeParam* array = SG_MALLOC(TypeParam, 5);
for (int32_t i = 0; i < 5; i++)
{
i_array_n[i] = CMath::random(1, 10);
array[i] = (TypeParam)CMath::random(1, 10);
}
for (int32_t i = 0; i < 5; i++)
{
b_array_n[i] = CMath::random(0, 1);
}
wrapper_array_i->set_array(i_array_n, 5, 5);
wrapper_array_b->set_array(b_array_n, 5, 5);
this->wrapper_array->set_array(array, 5);

EXPECT_EQ(wrapper_array_i->get_num_elements(), 5);
EXPECT_EQ(this->wrapper_array->get_num_elements(), 5);
for (index_t i = 0; i < 5; i++)
{
EXPECT_EQ(wrapper_array_i->get_element(i), i_array_n[i]);
EXPECT_EQ(wrapper_array_b->get_element(i), b_array_n[i]);
EXPECT_EQ(this->wrapper_array->get_element(i), array[i]);
}

SG_FREE(b_array_n);
SG_FREE(i_array_n);
SG_FREE(array);
}

TEST_F(CDynamicArrayFixture, const_set_array)
TYPED_TEST(CDynamicArrayFixture, const_set_array)
{
const bool* b_array_n = b_array;
const int32_t* i_array_n = i_array;

wrapper_array_i->reset_array();
wrapper_array_b->reset_array();
TypeParam* array = SG_MALLOC(TypeParam, 5);
for (int32_t i = 0; i < 5; i++)
{
array[i] = (TypeParam)CMath::random(1, 10);
}
const TypeParam* const_array = array;
this->wrapper_array->reset_array();

// make sure array been reset
EXPECT_EQ(wrapper_array_i->get_num_elements(), 0);
EXPECT_EQ(wrapper_array_b->get_num_elements(), 0);
EXPECT_EQ(this->wrapper_array->get_num_elements(), 0);

wrapper_array_i->set_array(i_array_n, 5);
wrapper_array_b->set_array(b_array_n, 5);
this->wrapper_array->set_array(const_array, 5);
for (index_t i = 0; i < 5; i++)
{
EXPECT_EQ(wrapper_array_i->get_element(i), i_array_n[i]);
EXPECT_EQ(wrapper_array_b->get_element(i), b_array_n[i]);
EXPECT_EQ(this->wrapper_array->get_element(i), const_array[i]);
}
SG_FREE(array);
}

TEST_F(CDynamicArrayFixture, get_array)
TYPED_TEST(CDynamicArrayFixture, get_array)
{
bool* b_array_n = wrapper_array_b->get_array();
int32_t* i_array_n = wrapper_array_i->get_array();
TypeParam* array = this->wrapper_array->get_array();

for (index_t i = 0; i < 5; i++)
{
EXPECT_EQ(wrapper_array_i->get_element(i), i_array_n[i]);
EXPECT_EQ(wrapper_array_b->get_element(i), b_array_n[i]);
EXPECT_EQ(this->wrapper_array->get_element(i), (TypeParam)array[i]);
}

delete b_array_n;
delete i_array_n;
}

TEST_F(CDynamicArrayFixture, push_array_int)
TYPED_TEST(CDynamicArrayFixture, push_array)
{
wrapper_array_i->reset_array();
EXPECT_EQ(wrapper_array_i->get_num_elements(), 0);
wrapper_array_i->push_back(0);
wrapper_array_i->push_back(1);
wrapper_array_i->push_back(2);
EXPECT_EQ(wrapper_array_i->get_num_elements(), 3);
this->wrapper_array->reset_array();
EXPECT_EQ(this->wrapper_array->get_num_elements(), 0);
this->wrapper_array->push_back((TypeParam)0);
this->wrapper_array->push_back((TypeParam)1);
this->wrapper_array->push_back((TypeParam)2);
EXPECT_EQ(this->wrapper_array->get_num_elements(), 3);
for (int32_t i = 0; i < 3; i++)
{
EXPECT_EQ(wrapper_array_i->get_element(i), i);
EXPECT_EQ(this->wrapper_array->get_element(i), (TypeParam)i);
}
}

TEST_F(CDynamicArrayFixture, push_array_bool)
TYPED_TEST(CDynamicArrayFixture, append_array)
{
wrapper_array_b->reset_array();
EXPECT_EQ(wrapper_array_b->get_num_elements(), 0);
wrapper_array_b->push_back(true);
wrapper_array_b->push_back(false);
wrapper_array_b->push_back(true);
EXPECT_EQ(wrapper_array_b->get_num_elements(), 3);
EXPECT_EQ(wrapper_array_b->get_element(0), true);
EXPECT_EQ(wrapper_array_b->get_element(1), false);
EXPECT_EQ(wrapper_array_b->get_element(2), true);
}

TEST_F(CDynamicArrayFixture, append_array_int)
{
wrapper_array_i->reset_array();
EXPECT_EQ(wrapper_array_i->get_num_elements(), 0);
wrapper_array_i->append_element(0);
wrapper_array_i->append_element(1);
wrapper_array_i->append_element(2);
EXPECT_EQ(wrapper_array_i->get_num_elements(), 3);
this->wrapper_array->reset_array();
EXPECT_EQ(this->wrapper_array->get_num_elements(), 0);
this->wrapper_array->append_element((TypeParam)0);
this->wrapper_array->append_element((TypeParam)1);
this->wrapper_array->append_element((TypeParam)2);
EXPECT_EQ(this->wrapper_array->get_num_elements(), 3);
for (int32_t i = 0; i < 3; i++)
{
EXPECT_EQ(wrapper_array_i->get_element(i), i);
EXPECT_EQ(this->wrapper_array->get_element(i), (TypeParam)i);
}
}

TEST_F(CDynamicArrayFixture, back_operation)
TYPED_TEST(CDynamicArrayFixture, back_operation)
{
// test if can achieve the last element
EXPECT_EQ(wrapper_array_i->back(), 4);
EXPECT_EQ(wrapper_array_b->back(), true);
EXPECT_EQ(this->wrapper_array->back(), (TypeParam)4);
}

TEST_F(CDynamicArrayFixture, set_operation)
TYPED_TEST(CDynamicArrayFixture, set_operation)
{
// test if can set array
wrapper_array_i->set_element(1, 4);
wrapper_array_b->set_element(false, 4);
EXPECT_EQ(wrapper_array_i->get_element(4), 1);
EXPECT_EQ(wrapper_array_b->get_element(4), false);
this->wrapper_array->set_element(1, (TypeParam)4);
EXPECT_EQ(this->wrapper_array->get_element(4), (TypeParam)1);
}

TEST_F(CDynamicArrayFixture, pop_operation)
TYPED_TEST(CDynamicArrayFixture, pop_operation)
{
// test if can set array
wrapper_array_i->pop_back();
wrapper_array_b->pop_back();
EXPECT_EQ(wrapper_array_i->back(), 3);
EXPECT_EQ(wrapper_array_b->back(), true);
this->wrapper_array->pop_back();
EXPECT_EQ(this->wrapper_array->back(), (TypeParam)3);
}

TEST_F(CDynamicArrayFixture, insert_operation)
TYPED_TEST(CDynamicArrayFixture, insert_operation)
{
// test if can set array
wrapper_array_i->insert_element(8, 2);
wrapper_array_b->insert_element(false, 2);
EXPECT_EQ(wrapper_array_i->get_element(2), 8);
EXPECT_EQ(wrapper_array_b->get_element(2), false);
this->wrapper_array->insert_element((TypeParam)10, 2);
EXPECT_EQ(this->wrapper_array->get_element(2), (TypeParam)10);
}

TEST_F(CDynamicArrayFixture, append_array_bool)
TYPED_TEST(CDynamicArrayFixture, append_array_bool)
{
wrapper_array_b->reset_array();
EXPECT_EQ(wrapper_array_b->get_num_elements(), 0);
wrapper_array_b->append_element(true);
wrapper_array_b->append_element(false);
wrapper_array_b->append_element(true);
EXPECT_EQ(wrapper_array_b->get_num_elements(), 3);
EXPECT_EQ(wrapper_array_b->get_element(0), true);
EXPECT_EQ(wrapper_array_b->get_element(1), false);
EXPECT_EQ(wrapper_array_b->get_element(2), true);
this->wrapper_array->reset_array();
EXPECT_EQ(this->wrapper_array->get_num_elements(), 0);
this->wrapper_array->append_element((TypeParam)1);
this->wrapper_array->append_element((TypeParam)0);
this->wrapper_array->append_element((TypeParam)1);
EXPECT_EQ(this->wrapper_array->get_num_elements(), 3);
EXPECT_EQ(this->wrapper_array->get_element(0), (TypeParam)1);
EXPECT_EQ(this->wrapper_array->get_element(1), (TypeParam)0);
EXPECT_EQ(this->wrapper_array->get_element(2), (TypeParam)1);
}

TYPED_TEST(CDynamicArrayTest, save_serializable)
TYPED_TEST(CDynamicArrayFixture, save_serializable)
{
for (int32_t i = 0; i < 5; i++)
{
this->custom_array->push_back((TypeParam)CMath::random(0, 1));
}

/* generate file name */
char filename[] = "serialization-asciiCDynamicArray.XXXXXX";
generate_temp_filename(filename);

CSerializableAsciiFile* file = new CSerializableAsciiFile(filename, 'w');
this->custom_array->save_serializable(file);
this->wrapper_array->save_serializable(file);
file->close();
SG_UNREF(file);

Expand All @@ -276,11 +188,11 @@ TYPED_TEST(CDynamicArrayTest, save_serializable)
file->close();
SG_UNREF(file);

ASSERT(this->custom_array->get_num_elements() == 5)
for (int32_t i = 0; i < this->custom_array->get_num_elements(); i++)
ASSERT(this->wrapper_array->get_num_elements() == 5)
for (int32_t i = 0; i < this->wrapper_array->get_num_elements(); i++)
{
EXPECT_EQ(
this->custom_array->get_element(i), new_array->get_element(i));
this->wrapper_array->get_element(i), new_array->get_element(i));
}

SG_UNREF(new_array);
Expand Down

0 comments on commit 5a56a77

Please sign in to comment.