TEST(CollectionUtilsTest, vecContainsPtr) {
typedef std::vector<int*> TestVec;
TestVec vec;
vec.push_back(new int(10));
vec.push_back(new int(4));
vec.push_back(new int(-232));
vec.push_back(new int(11111));
const int* i10 = new int(10);
const int* i4 = new int(4);
const int* i232 = new int(-232);
const int* i11111 = new int(11111);
const int* i11 = new int(11);
const int* i0 = new int(0);
const int* i110 = new int(110);
ASSERT_TRUE(VectorUtils::contains(vec, i10));
ASSERT_TRUE(VectorUtils::contains(vec, i4));
ASSERT_TRUE(VectorUtils::contains(vec, i232));
ASSERT_TRUE(VectorUtils::contains(vec, i11111));
ASSERT_FALSE(VectorUtils::contains(vec, i11));
ASSERT_FALSE(VectorUtils::contains(vec, i0));
ASSERT_FALSE(VectorUtils::contains(vec, i110));
VectorUtils::clearAndDelete(vec);
delete i10;
delete i4;
delete i232;
delete i11111;
delete i11;
delete i0;
delete i110;
}
TEST(CollectionUtilsTest, vecRemoveAndDelete) {
typedef std::vector<TestObject*> TestVec;
static const size_t count = 4;
TestVec vec;
bool deleted[count];
for (size_t i = 0; i < count; i++)
vec.push_back(new TestObject(deleted[i]));
VectorUtils::removeAndDelete(vec, vec[2]);
ASSERT_EQ(count - 1, vec.size());
ASSERT_TRUE(deleted[2]);
VectorUtils::clearAndDelete(vec);
}
TEST(CollectionUtilsTest, vecEraseAndDelete1InRange) {
typedef std::vector<TestObject*> TestVec;
static const size_t count = 3;
TestVec vec;
bool deleted[count];
for (size_t i = 0; i < count; i++)
vec.push_back(new TestObject(deleted[i]));
VectorUtils::eraseAndDelete(vec, vec.begin() + 1, vec.end() - 1);
ASSERT_EQ(2u, vec.size());
ASSERT_FALSE(deleted[0]);
ASSERT_TRUE(deleted[1]);
ASSERT_FALSE(deleted[2]);
VectorUtils::clearAndDelete(vec);
}
TEST_F(MultipleOperationsTest, doubleElemsAndThenFilterDivisibleByFour)
{
TestVec tmpVec;
std::transform(oneToTen_.begin(), oneToTen_.end(), std::back_inserter(tmpVec),
multiplyByTwo);
TestVec expected;
std::copy_if(tmpVec.begin(), tmpVec.end(), std::back_inserter(expected),
isDivisibleByFour);
TestVec result;
make_seq(oneToTen_)
.map(multiplyByTwo)
.filter(isDivisibleByFour)
.writeTo(std::back_inserter(result));
EXPECT_EQ(expected, result);
}
TEST(CollectionUtilsTest, vecContains) {
typedef std::vector<int> TestVec;
TestVec vec;
vec.push_back(10);
vec.push_back(4);
vec.push_back(-232);
vec.push_back(11111);
ASSERT_TRUE(VectorUtils::contains(vec, 10));
ASSERT_TRUE(VectorUtils::contains(vec, 4));
ASSERT_TRUE(VectorUtils::contains(vec, -232));
ASSERT_TRUE(VectorUtils::contains(vec, 11111));
ASSERT_FALSE(VectorUtils::contains(vec, 11));
ASSERT_FALSE(VectorUtils::contains(vec, 0));
ASSERT_FALSE(VectorUtils::contains(vec, 110));
}
/**
****************************************************************************************************
* @run MojList is similar to standard C++ template library list.
MojList uses double linked list to store the data.
MojList provides facilities to access data from both front and back of the list.
MojList provides additional functionalities like contains() which checks for the
object in the list. This testcase verifies all list operations for inserting,
retrieving of data using const, non const iterators.
List functionalities tested:
* Populating list using 'push' utility and checking for empty test.
* Adding data to the list using pushBack() utility.
* Using const and non-const iterators to ensure integrity of data.
* Erasing data using erase().
* popBack() and popFront() to retrieve data from front and back of the list.
* Deleting the entire list using clear() utility.
* @param : None
* @retval : MojErr
****************************************************************************************************
**/
MojErr MojListTest::run()
{
// create a bunch of TestItems
typedef MojVector<MojRefCountedPtr<TestItem> > TestVec;
TestVec vec;
for (int i = 0; i < 100; ++i) {
MojErr err = vec.push(new TestItem(i));
MojTestErrCheck(err);
}
// empty test
MojList<TestItem, &TestItem::m_entry1> list1;
MojTestAssert(list1.empty());
MojTestAssert(list1.size() == 0);
TestItem item1(0);
MojTestAssert(!list1.contains(&item1));
MojTestAssert(list1.begin() == list1.end());
const MojList<TestItem, &TestItem::m_entry1>& clist1 = list1;
MojTestAssert(clist1.begin() == clist1.end());
// push back
TestVec::Iterator vecIter;
MojErr err = vec.begin(vecIter);
MojTestErrCheck(err);
for (; vecIter != vec.end(); ++vecIter) {
MojTestAssert(list1.size() == (MojSize) (*vecIter)->m_val);
list1.pushBack(vecIter->get());
MojTestAssert(!list1.empty());
MojTestAssert(list1.contains(vecIter->get()));
MojTestAssert(list1.back() == vecIter->get());
MojTestAssert(list1.front() == clist1.front());
MojTestAssert(list1.back() == clist1.back());
if (list1.size() == 1)
MojTestAssert(list1.front() == vecIter->get());
}
// const iterator
int count = 0;
for (MojList<TestItem, &TestItem::m_entry1>::ConstIterator i = list1.begin();
i != list1.end();
++i, ++count) {
MojAssert((*i)->m_val == count);
}
MojAssert(count == 100);
// non-const iterator
for (MojList<TestItem, &TestItem::m_entry1>::Iterator i = list1.begin();
i != list1.end();
++i) {
(*i)->m_val = -(*i)->m_val;
}
// iterator erase
count = 0;
MojList<TestItem, &TestItem::m_entry1>::Iterator listIter = list1.begin();
while (listIter != list1.end()) {
if (count++ % 2 == 0) {
(listIter++).erase();
} else {
listIter++;
}
}
MojTestAssert(list1.size() == 50);
count = -1;
listIter = list1.begin();
for (MojList<TestItem, &TestItem::m_entry1>::ConstIterator i = list1.begin();
i != list1.end();
++i) {
MojTestAssert((*i)->m_val == count);
count -=2;
}
MojTestAssert(count == -101);
// list erase
listIter = list1.begin();
while (listIter != list1.end()) {
list1.erase(*(listIter++));
}
MojTestAssert(list1.size() == 0);
MojTestAssert(list1.empty());
// add to two lists (front and back)
MojList<TestItem, &TestItem::m_entry2> list2;
err = vec.begin(vecIter);
MojTestErrCheck(err);
count = 0;
for (; vecIter != vec.end(); ++vecIter) {
(*vecIter)->m_val = count++;
list1.pushBack(vecIter->get());
list2.pushFront(vecIter->get());
}
// verify order
count = 0;
listIter = list1.begin();
MojList<TestItem, &TestItem::m_entry2>::Iterator listIter2 = list2.begin();
while (listIter != list1.end() && listIter2 != list2.end()) {
int val1 = (*listIter)->m_val;
int val2 = (*listIter2)->m_val;
MojTestAssert(val1 == count);
MojTestAssert(val2 == 99 - count);
++count;
++listIter;
++listIter2;
}
MojTestAssert(count == 100);
// popFront/popBack
count = 0;
while (!list1.empty() && !list2.empty()) {
TestItem* item1 = list1.popFront();
TestItem* item2 = list2.popBack();
MojTestAssert(item1 == item2);
++count;
}
MojTestAssert(count == 100);
MojTestAssert(list1.empty() && list2.empty());
// assignment
MojList<TestItem, &TestItem::m_entry1> list3(list1);
MojTestAssert(list1.begin() == list1.end() && list3.begin() == list3.end());
list1.swap(list3);
MojTestAssert(list1.begin() == list1.end() && list3.begin() == list3.end());
list3 = list1;
MojTestAssert(list1.begin() == list1.end() && list3.begin() == list3.end());
MojList<TestItem, &TestItem::m_entry1> list4(list1);
MojTestAssert(list1.begin() == list1.end() && list4.begin() == list4.end());
err = vec.begin(vecIter);
MojTestErrCheck(err);
for (; vecIter != vec.end(); ++vecIter) {
list1.pushBack(vecIter->get());
};
MojTestAssert(list1.size() == 100);
MojList<TestItem, &TestItem::m_entry1> list5(list1);
MojTestAssert(list1.size() == 0 && list5.size() == 100);
MojTestAssert(list1.begin() == list1.end());
count = 0;
for (MojList<TestItem, &TestItem::m_entry1>::ConstIterator i = list5.begin();
i != list5.end();
++i) {
MojTestAssert((*i)->m_val == count);
++count;
}
MojTestAssert(count == 100);
list5 = list5;
MojTestAssert(list5.size() == 100);
list1 = list5;
MojTestAssert(list5.empty() && list1.size() == 100);
count = 0;
for (MojList<TestItem, &TestItem::m_entry1>::ConstIterator i = list1.begin();
i != list1.end();
++i) {
MojTestAssert((*i)->m_val == count);
++count;
}
MojTestAssert(count == 100);
list5.swap(list1);
MojTestAssert(list1.empty() && list5.size() == 100);
TestItem* item = list5.popFront();
list1.pushBack(item);
MojTestAssert(list1.size() == 1 && list5.size() == 99);
list1 = list5;
MojTestAssert(list1.size() == 99 && list5.size() == 0);
item = list1.popFront();
list5.pushBack(item);
MojTestAssert(list1.size() == 98 && list5.size() == 1);
list5.swap(list1);
MojTestAssert(list1.size() == 1 && list5.size() == 98);
// clear
list5.clear();
return MojErrNone;
}
