container_test::List_test Class Reference

Polymorphic code for testing concrete sub-classes of container::List. More...

#include <list_test.h>

Inheritance diagram for container_test::List_test:

[legend]

Collaboration diagram for container_test::List_test:

[legend]

List of all members.

Protected Member Functions
void	verifyEmptyStateCoherence (List *a)
void	verifyEmptyStateCoherence (List &a)
void	verifyNonEmptyStateCoherence_tail (List *a, int count)
void	verifyNonEmptyStateCoherence_tail (List &a, int count)
void	verifyNonEmptyStateCoherence_notTail (List *a, int count)
void	verifyNonEmptyStateCoherence_notTail (List &a, int count)
void	generateDataAndPopulateList (Entity **&data, List *list, const int listSize, bool print=false)
	Creates a new test data set.
void	defaultConstructor (const Object::Info *type)
void	cursorControl (const Object::Info *type)
void	purgeConents (const Object::Info *type)
void	locateEntity (const Object::Info *type)
void	entityAt (const Object::Info *type)
Static Protected Attributes
static const int	SOME_OTHER_KEY
static const int	ZERO_INDEX
static const int	NEGATIVE_INDEX
static const int	BIG_INDEX
static const int	SOME_OTHER_INDEX
static const int	INDEX_NOT_FOUND
static const int	KEY_4
static const string	KEY_4_AS_STRING

---

Detailed Description

Polymorphic code for testing concrete sub-classes of container::List.

There are no actual unit tests in List_test that the googletest framework will recognize and execute automatically. The googletest framework doesn't provide an elegant solution for testing the compliance of derived classes. This class is sub-classed by OrderedLinkedList_test and SortedLinkedList_test in order to re-use common unit test code.

---

Member Function Documentation

void container_test::List_test::cursorControl

(

const Object::Info *

type

)

[protected]

                                                    {

   List* a = listFactory(type);

   // Cursor manipulation with a empty list
   cout << "List a is empty" << endl;
   cout << "  " << a << endl;
   verifyEmptyStateCoherence(a);
   EXPECT_EQ(false, a->toFirst());
   verifyEmptyStateCoherence(a);
   EXPECT_EQ(false, a->toLast());
   verifyEmptyStateCoherence(a);
   EXPECT_EQ(false, a->toNext());
   verifyEmptyStateCoherence(a);
   EXPECT_EQ(false, a->toPrev());
   verifyEmptyStateCoherence(a);
   a->toTail();
   verifyEmptyStateCoherence(a);

   // Cursor manipulation with a list containing a single node
   Entity* e1 = new Entity();
   a->add(e1);
   cout << "List a has one item" << endl;
   cout << "  " << a << endl;
   EXPECT_EQ(true, a->toPrev());
   cout << "After toPrev()" << endl;
   cout << "  " << a << endl;
   verifyNonEmptyStateCoherence_notTail(a, 1);
   cout << "Current node contains: " << a->currentEntity() << endl;
   EXPECT_EQ(e1, a->currentEntity());
   EXPECT_FALSE(a->toPrev());
   verifyNonEmptyStateCoherence_notTail(a, 1);
   EXPECT_FALSE(a->toNext());
   cout << "After toNext()" << endl;
   cout << "  " << a << endl;
   verifyNonEmptyStateCoherence_tail(a, 1);
   EXPECT_TRUE(a->toFirst());
   cout << "After toFirst()" << endl;
   cout << "  " << a << endl;
   verifyNonEmptyStateCoherence_notTail(a, 1);
   a->toTail();
   cout << "After toTail()" << endl;
   cout << "  " << a << endl;
   verifyNonEmptyStateCoherence_tail(a, 1);
   EXPECT_TRUE(a->toLast());
   cout << "After toLast()" << endl;
   cout << "  " << a << endl;
   verifyNonEmptyStateCoherence_notTail(a, 1);

   //Cursor manipulation with a list containing 2 nodes
   EXPECT_TRUE(a->toFirst());
   cout << "After toFirst(), (cursor shouldn't have moved)" << endl;
   cout << "  " << a << endl;
   EXPECT_TRUE(a->isLast());
   cout << "Adding a 2nd item using default add method" << endl;
   Entity* e2 = new Entity();
   a->add(e2);
   cout << "After add(e2), cursor should still point to e1." << endl;
   cout << "  " << a << endl;
   EXPECT_EQ(e1, a->currentEntity());
   EXPECT_TRUE(e1->compareKeyTo(*a->currentEntity()) == 0);

   int indexResult;
   Entity key = *e1;
   Entity* entityResult;
   a->locateEntity(key, indexResult, entityResult);
   EXPECT_EQ(e1, entityResult);
   EXPECT_NE(INDEX_NOT_FOUND, indexResult);

   // Where method add(Entity*) puts the new items is up to the implementing
   // class. Therefore, this generic test cannot know, at compile time,
   // whether the second entity was added first or last.
   if (indexResult == 0) {
      EXPECT_FALSE(a->isLast());
      EXPECT_TRUE(a->isFirst());
   } else {
      EXPECT_TRUE(a->isLast());
      EXPECT_FALSE(a->isFirst());
   }

   List_test::verifyNonEmptyStateCoherence_notTail(a, 2);
   if (indexResult == 0) {
      EXPECT_TRUE(a->toNext());
      cout << "After toNext()" << endl;
      cout << "  " << a << endl;
      verifyNonEmptyStateCoherence_notTail(a, 2);
      EXPECT_FALSE(a->toNext());
      cout << "After 2nd call toNext()" << endl;
      cout << "  " << a << endl;
      verifyNonEmptyStateCoherence_tail(a, 2);
      EXPECT_TRUE(a->toPrev());
      cout << "Last node contains: " << a->currentEntity() << endl;
      EXPECT_EQ(e2, a->currentEntity());
      EXPECT_TRUE(a->toPrev());
      EXPECT_TRUE(a->isFirst());
      cout << "After toPrev()" << endl;
      cout << "  " << a << endl;
      verifyNonEmptyStateCoherence_notTail(a, 2);
      cout << "First node contains: " << a->currentEntity() << endl;
      EXPECT_EQ(e1, a->currentEntity());
      EXPECT_FALSE(a->toPrev());
      cout << "After toPrev()" << endl;
      cout << "  " << a << endl;
      verifyNonEmptyStateCoherence_notTail(a, 2);
   } else {
      EXPECT_TRUE(a->toPrev());
      cout << "After toPrev()" << endl;
      cout << "  " << a << endl;
      EXPECT_FALSE(a->toPrev());
      cout << "After 2nd call toPrev(), (cursor shouldn't have moved)" << endl;
      cout << "  " << a << endl;
      EXPECT_TRUE(a->isFirst());
      verifyNonEmptyStateCoherence_notTail(a, 2);
      cout << "First node contains: " << a->currentEntity() << endl;
      EXPECT_EQ(e2, a->currentEntity());
      EXPECT_TRUE(a->toNext());
      EXPECT_TRUE(a->isLast());
      cout << "After toNext()" << endl;
      cout << "  " << a << endl;
      verifyNonEmptyStateCoherence_notTail(a, 2);
      cout << "Last node contains: " << a->currentEntity() << endl;
      EXPECT_EQ(e1, a->currentEntity());
      EXPECT_FALSE(a->toNext());
      cout << "After toNext()" << endl;
      cout << "  " << a << endl;
      verifyNonEmptyStateCoherence_tail(a, 2);
   }

   delete a;
}

Here is the call graph for this function:

void container_test::List_test::defaultConstructor

(

const Object::Info *

type

)

[protected]

                                                         {

   // Null check, probably not necessary, but I'm just trying to figure
   // out this new framework.
   List* a = listFactory(type);
   List* n = NULL;
   EXPECT_NE(n, a);

   // I'm relearning the language. Just making sure I understand what's
   // going on. a and b should be pointing to two different places.
   List* b = listFactory(type);
   EXPECT_NE(a, b);

   cout << a->typeInfo()->typeName <<
         " default constructor should create empty lists." << endl;
   cout << " a " << *a << endl;
   EXPECT_TRUE(a->isEmpty());
   EXPECT_EQ(0, a->getCount());
   cout << " b " << *b << endl;
   EXPECT_TRUE(b->isEmpty());
   EXPECT_EQ(0, b->getCount());

   cout << "Adding node to " << a->typeInfo()->typeName << " b" << endl;
   b->add(new Entity());
   cout << " b " << *b << endl;
   EXPECT_FALSE(b->isEmpty());
   EXPECT_EQ(1, b->getCount());
   // isFirst is always false when empty
   EXPECT_FALSE(a->isFirst());
   // adding a node should not have changed the cursor possition
   EXPECT_FALSE(b->isFirst());

   // isLast is always false when empty
   EXPECT_FALSE(a->isLast());
   // adding a node should not have changed the cursor possition
   EXPECT_FALSE(b->isFirst());

   // isLast is always false when empty
   EXPECT_TRUE(a->isTail());
   // adding a node should not have changed the cursor possition
   EXPECT_TRUE(b->isTail());

   delete a;
   delete b;
}

Here is the call graph for this function:

void container_test::List_test::entityAt

(

const Object::Info *

type

)

[protected]

                                               {
   List* emptyList = listFactory(type);
   cout << "Calling entityAt(" << ZERO_INDEX << ") on an empty " <<
         emptyList->typeInfo()->typeName << '.' << endl;
   Entity *entity = new Entity();
   Entity *entity2 = entity;
   EXPECT_EQ(entity, entity2);
   entity = emptyList->entityAt(ZERO_INDEX);
   verifyEmptyStateCoherence(emptyList);
   EXPECT_TRUE(NULL == entity);
   EXPECT_NE(entity2, entity);
   cout << "  returned entity(" << entity << ")" << endl;

   List *list = listFactory(type);
   Entity *entity3 = new Entity();
   list->add(entity3);
   EXPECT_TRUE(list->toFirst());
   cout << "Calling entityAt(" << ZERO_INDEX << ") on a  " <<
         list->typeInfo()->typeName << " with one item." << endl;
   cout << "  " << *list << endl;
   entity = NULL;
   verifyNonEmptyStateCoherence_notTail(*list, 1);
   entity = list->entityAt(ZERO_INDEX);
   verifyNonEmptyStateCoherence_notTail(*list, 1);
   EXPECT_EQ(entity3, entity);
   EXPECT_FALSE(entity3 == NULL);
   cout << "  returned entity(" << *entity << ")" << endl;

   cout << "Calling entityAt(" << NEGATIVE_INDEX << ") on the same " <<
         list->typeInfo()->typeName << '.' << endl;
   cout << "  " << *list << endl;
   entity = entity2;
   verifyNonEmptyStateCoherence_notTail(*list, 1);
   entity = list->entityAt(NEGATIVE_INDEX);
   verifyNonEmptyStateCoherence_notTail(*list, 1);
   EXPECT_TRUE(NULL == entity);
   EXPECT_NE(entity2, entity);
   cout << "  returned entity(" << entity << ")" << endl;

   cout << "Calling entityAt(" << BIG_INDEX << ") on the same " <<
         list->typeInfo()->typeName << '.' << endl;
   cout << "  " << *list << endl;
   entity = entity2;
   verifyNonEmptyStateCoherence_notTail(*list, 1);
   entity = list->entityAt(BIG_INDEX);
   verifyNonEmptyStateCoherence_notTail(*list, 1);
   EXPECT_TRUE(NULL == entity);
   EXPECT_NE(entity2, entity);
   cout << "  returned entity(" << entity << ")" << endl;

   cout << "Calling entityAt(" << list->getCount() << ") on the same " <<
         list->typeInfo()->typeName << '.' << endl;
   cout << "  " << *list << endl;
   entity = entity2;
   verifyNonEmptyStateCoherence_notTail(*list, 1);
   entity = list->entityAt(list->getCount());
   verifyNonEmptyStateCoherence_notTail(*list, 1);
   EXPECT_TRUE(NULL == entity);
   EXPECT_NE(entity2, entity);
   cout << "  returned entity(" << entity << ")" << endl;

   delete emptyList;
   delete list;
}

Here is the call graph for this function:

void container_test::List_test::generateDataAndPopulateList	(	Entity **&	data,
		List *	list,
		const int	listSize,
		bool	print = false
	)			[protected]

Creates a new test data set.

A new data array is created and a new List. Both are populated with the same list of Entities. It is the responsibility of the caller to release all objects created: the array of Entity pointers, the List, and all the Entity objects.

Postcondition:

A new array of Entity pointers is created.

A new Linked List is created.

SIZE number if Entity objects are created.

The data array and the List will both be populated with pointers to the newly created Entity objects.

The order will be the same in both the data array and the List.

                                                        {
   data = new Entity*[listSize];
   if (print) cout << "Populating " << list->typeInfo()->typeName <<
         " with " << listSize << " entities:" << endl;
   if (print) cout << "  " << list << endl;
   for (int i = 0; i < listSize; i++) {
      data[i] = new Entity();
      list->add(data[i]);
      if (print) cout << "After add() " << *data[i] << endl;
      if (print) cout << "  " << list << endl;
      verifyNonEmptyStateCoherence_tail(list, i + 1);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void container_test::List_test::locateEntity

(

const Object::Info *

type

)

[protected]

                                                   {
   List* emptyList = listFactory(type);
   cout << "Calling locateEntity on an emtpy " << emptyList->typeInfo()->typeName
         << "." << endl;
   Entity key(KEY_4);
   int index(SOME_OTHER_INDEX);
   EXPECT_EQ(SOME_OTHER_INDEX, index);
   EXPECT_EQ(KEY_4_AS_STRING, key.getKeyAsString());
   Entity *entity = new Entity();
   Entity *entity2 = entity;
   EXPECT_EQ(entity, entity2);
   emptyList->locateEntity(key, index, entity);
   verifyEmptyStateCoherence(emptyList);
   EXPECT_EQ(INDEX_NOT_FOUND, index);
   EXPECT_TRUE(NULL == entity);
   EXPECT_NE(entity2, entity);
   cout << "  returned index(" << index << ") entity(" << entity << ")" << endl;

   List *list = listFactory(type);
   Entity *entity3 = new Entity();
   list->add(entity3);
   const Entity key2 = *entity3;
   cout << "Calling locateEntity on a " << list->typeInfo()->typeName <<
         " with a single item." << endl;
   cout << "  " << *list << ")" << endl;
   cout << "  locating Entity with key(" << key2.getKeyAsString() << ")" << endl;
   index = SOME_OTHER_INDEX;
   entity = NULL;
   verifyNonEmptyStateCoherence_tail(*list, 1);
   list->locateEntity(key2, index, entity);
   verifyNonEmptyStateCoherence_tail(*list, 1);
   EXPECT_EQ(ZERO_INDEX, index);
   EXPECT_EQ(entity3, entity);
   EXPECT_FALSE(entity3 == NULL);
   cout << "  returned index(" << index << ") entity(" << *entity << ")" << endl;

   cout << "Calling locateEntity on the same " << list->typeInfo()->typeName <<
         '.' << endl;
   cout << "  " << *list << ")" << endl;
   cout << "  locating Entity with key(" << SOME_OTHER_KEY << ")" << endl;
   const Entity someOtherKey(SOME_OTHER_KEY);
   index = SOME_OTHER_INDEX;
   entity = entity2;
   verifyNonEmptyStateCoherence_tail(*list, 1);
   list->locateEntity(someOtherKey, index, entity);
   verifyNonEmptyStateCoherence_tail(*list, 1);
   EXPECT_EQ(INDEX_NOT_FOUND, index);
   EXPECT_TRUE(NULL == entity);
   EXPECT_NE(entity2, entity);
   cout << "  returned index(" << index << ") entity(" << entity << ")" << endl;

   delete emptyList;
   delete list;
}

Here is the call graph for this function:

void container_test::List_test::purgeConents

(

const Object::Info *

type

)

[protected]

                                                   {
   const int LIST_SIZE = 100;
   Entity ** data;
   List* a = listFactory(type);
   generateDataAndPopulateList(data, a, LIST_SIZE);
   verifyNonEmptyStateCoherence_tail(a, LIST_SIZE);

   const int SAMPLE_MOD = 10;
   cout << "Created a " << a->typeInfo()->typeName << " with " << LIST_SIZE <<
         " items." << endl;
   cout << "  count(" << a->getCount() << ")" << endl;
   cout << "Vefifying all items. Printing a sample every " <<
         SAMPLE_MOD << " items:" << endl;
   cout << "      Expected Entity                    Container Entity" << endl;
   a->toFirst();
   int index = 0;
   do {
      if ((index % SAMPLE_MOD) == 0) {
         cout << "  [" << index << "] " << data[index] << " == " << a->currentEntity() << endl;
      }
      EXPECT_EQ(data[index], a->currentEntity());
      a->toNext();
      index++;
   } while (!a->isTail());
   EXPECT_EQ(LIST_SIZE, index);
   EXPECT_EQ(LIST_SIZE, a->purgeContents());
   verifyEmptyStateCoherence(a);
   cout << "Called purgeContents()" << endl;
   cout << "  " << a << endl;

   index = 0;
   while (a->toPrev()) index++;
   EXPECT_EQ(0, index);

   Entity e;
   a->add(&e);
   EXPECT_TRUE(a->toPrev());
   verifyNonEmptyStateCoherence_notTail(*a, 1);
   EXPECT_EQ(&e, a->currentEntity());
   EXPECT_TRUE(e.compareKeyTo(*a->extractCurrentEntity()) == 0);
   verifyEmptyStateCoherence(a);

   delete a;
   delete data;
}

Here is the call graph for this function:

void container_test::List_test::verifyEmptyStateCoherence

(

List &

a

)

[protected]

                                                 {
   EXPECT_TRUE(a.isEmpty());
   EXPECT_EQ(0, a.getCount());
   EXPECT_FALSE(a.isFirst());
   EXPECT_FALSE(a.isLast());
   EXPECT_TRUE(a.isTail());
}

Here is the call graph for this function:

void container_test::List_test::verifyEmptyStateCoherence

(

List *

a

)

[protected]

                                                 {
   verifyEmptyStateCoherence(*a);
}

Here is the caller graph for this function:

void container_test::List_test::verifyNonEmptyStateCoherence_notTail	(	List &	a,
		int	count
	)			[protected]

                                                                       {
   EXPECT_FALSE(a.isEmpty());
   EXPECT_EQ(count, a.getCount());
   if (count == 1) {
      EXPECT_TRUE(a.isFirst());
      EXPECT_TRUE(a.isLast());
   } else if (count > 1) {
      if (a.isFirst()) EXPECT_FALSE(a.isLast());
      if (a.isLast()) EXPECT_FALSE(a.isFirst());
   }
   EXPECT_FALSE(a.isTail());
}

Here is the call graph for this function:

void container_test::List_test::verifyNonEmptyStateCoherence_notTail	(	List *	a,
		int	count
	)			[protected]

                                                                       {
   verifyNonEmptyStateCoherence_notTail(*a, count);
}

Here is the caller graph for this function:

void container_test::List_test::verifyNonEmptyStateCoherence_tail	(	List &	a,
		int	count
	)			[protected]

                                                                    {
   EXPECT_FALSE(a.isEmpty());
   EXPECT_EQ(count, a.getCount());
   EXPECT_FALSE(a.isFirst());
   EXPECT_FALSE(a.isLast());
   EXPECT_TRUE(a.isTail());
}

Here is the call graph for this function:

void container_test::List_test::verifyNonEmptyStateCoherence_tail	(	List *	a,
		int	count
	)			[protected]

                                                                    {
   verifyNonEmptyStateCoherence_tail(*a, count);
}

Here is the caller graph for this function:

---

Member Data Documentation

const int container_test::List_test::BIG_INDEX [static, protected]

const int container_test::List_test::INDEX_NOT_FOUND [static, protected]

const int container_test::List_test::KEY_4 [static, protected]

const string container_test::List_test::KEY_4_AS_STRING [static, protected]

const int container_test::List_test::NEGATIVE_INDEX [static, protected]

const int container_test::List_test::SOME_OTHER_INDEX [static, protected]

const int container_test::List_test::SOME_OTHER_KEY [static, protected]

const int container_test::List_test::ZERO_INDEX [static, protected]

---

The documentation for this class was generated from the following files:

• list_test.h
• list_test.cpp