container_test Namespace Reference

Unit tests for the container namespace based on the googletest framework. More...

Classes
class	Entity_test
	Unit tests for Entity. More...
class	List_test
	Polymorphic code for testing concrete sub-classes of container::List. More...
class	OrderedArrayList_test
	Test cases for concrete class container::OrderedArrayList. More...
class	OrderedLinkedList_test
	Test cases for concrete class container::OrderedLinkedList. More...
class	OrderedList_test
	Polymorphic code for testing concrete sub-classes of container::OrderedList. More...
class	Person
	A type of Entity that represents a person. More...
class	QueueImpl_test
	Unit tests for QueueImpl. More...
class	SortedArrayList_test
	Unit tests for SortedArrayList. More...
class	SortedLinkedList_test
	Unit tests for SortedLinkedList. More...
class	SortedList_test
	Polymorphic code for testing concrete sub-classes of container::SortedList. More...
class	StackImpl_test
	Unit tests for StackImpl. More...
Functions
	TEST_F (Entity_test, DefaultConstructor)
	TEST_F (Entity_test, AssignmentOperator)
	TEST_F (Entity_test, CopyConstructor)
	TEST_F (OrderedArrayList_test, DefaultConstructor)
	TEST_F (OrderedArrayList_test, append)
	TEST_F (OrderedArrayList_test, cursorControl)
	TEST_F (OrderedArrayList_test, insertingAndRemoving)
	TEST_F (OrderedArrayList_test, purgeConents)
	TEST_F (OrderedArrayList_test, locateEntity)
	TEST_F (OrderedArrayList_test, entityAt)
	TEST_F (OrderedLinkedList_test, DefaultConstructor)
	TEST_F (OrderedLinkedList_test, append)
	TEST_F (OrderedLinkedList_test, cursorControl)
	TEST_F (OrderedLinkedList_test, insertingAndRemoving)
	TEST_F (OrderedLinkedList_test, purgeConents)
	TEST_F (OrderedLinkedList_test, locateEntity)
	TEST_F (OrderedLinkedList_test, entityAt)
	TEST_F (QueueImpl_test, factories)
	TEST_F (QueueImpl_test, enqueueDequeueLinked)
	TEST_F (QueueImpl_test, enqueueDequeueArray)
	TEST_F (QueueImpl_test, purgeContentsLinked)
	TEST_F (QueueImpl_test, purgeContentsArray)
	TEST_F (QueueImpl_test, shallowVersusDeepArray)
	TEST_F (SortedArrayList_test, DefaultConstructor)
	TEST_F (SortedArrayList_test, cursorControl)
	TEST_F (SortedArrayList_test, insertSorted)
	TEST_F (SortedArrayList_test, insertingAndRemoving)
	TEST_F (SortedArrayList_test, purgeConents)
	TEST_F (SortedArrayList_test, locateEntity)
	TEST_F (SortedArrayList_test, entityAt)
	TEST_F (SortedLinkedList_test, DefaultConstructor)
	TEST_F (SortedLinkedList_test, cursorControl)
	TEST_F (SortedLinkedList_test, insertSorted)
	TEST_F (SortedLinkedList_test, insertingAndRemoving)
	TEST_F (SortedLinkedList_test, purgeConents)
	TEST_F (SortedLinkedList_test, locateEntity)
	TEST_F (SortedLinkedList_test, entityAt)
	TEST_F (StackImpl_test, factories)
	TEST_F (StackImpl_test, pushPopLinked)
	TEST_F (StackImpl_test, pushPopArray)
	TEST_F (StackImpl_test, purgeContentsLinked)
	TEST_F (StackImpl_test, purgeContentsArray)
List *	listFactory (const Object::Info *type)
	Create one of the known concrete classes ultimately derived from container::List.
OrderedList *	orderedListFactory (const Object::Info *type)
	Create one of the known concrete classes derived from container::OrderedList.
SortedList *	sortedListFactory (const Object::Info *type)
	Create one of the known concrete classes derived from container::SortedList.

---

Detailed Description

Unit tests for the container namespace based on the googletest framework.

---

Function Documentation

List * container_test::listFactory

(

const Object::Info *

type

)

Create one of the known concrete classes ultimately derived from container::List.

                                          {
   List *list = orderedListFactory(type);
   if (list != NULL) {
      return list;
   }

   return sortedListFactory(type);
}

Here is the call graph for this function:

Here is the caller graph for this function:

OrderedList * container_test::orderedListFactory

(

const Object::Info *

type

)

Create one of the known concrete classes derived from container::OrderedList.

                                                        {
   if (type == OrderedLinkedList::TYPE_INFO) {
      return new OrderedLinkedList();
   } else if (type == OrderedArrayList::TYPE_INFO) {
      return new OrderedArrayList();
   } else {
      return NULL;
   }
}

Here is the caller graph for this function:

SortedList * container_test::sortedListFactory

(

const Object::Info *

type

)

Create one of the known concrete classes derived from container::SortedList.

                                                      {
   if (type == SortedLinkedList::TYPE_INFO) {
      return new SortedLinkedList();
   } else if (type == SortedArrayList::TYPE_INFO) {
      return new SortedArrayList();
   } else {
      return NULL;
   }
}

Here is the caller graph for this function:

container_test::TEST_F	(	StackImpl_test	,
		purgeContentsArray
	)

                                           {
   purgeContentsTest(StackImpl::factoryArrayComposition());
}

container_test::TEST_F	(	StackImpl_test	,
		purgeContentsLinked
	)

                                            {
   purgeContentsTest(StackImpl::factoryLinkedComposition());
}

container_test::TEST_F	(	StackImpl_test	,
		pushPopArray
	)

                                     {
   pushPopTest(StackImpl::factoryArrayComposition());
}

container_test::TEST_F	(	StackImpl_test	,
		pushPopLinked
	)

                                      {
   pushPopTest(StackImpl::factoryLinkedComposition());
}

container_test::TEST_F	(	StackImpl_test	,
		factories
	)

                                  {

   cout << "Factory creation of a stack composed with an underlying linked list" << endl;
   Stack* sLinked = StackImpl::factoryLinkedComposition();
   EXPECT_EQ(StackImpl::TYPE_INFO, sLinked->typeInfo());
   cout << "   " << sLinked << endl;

   cout << "Factory creation of a stack composed with an underlying array list" << endl;
   Stack* sArray = StackImpl::factoryArrayComposition();
   EXPECT_EQ(StackImpl::TYPE_INFO, sArray->typeInfo());
   cout << "   " << sArray << endl;

   verifyStackCoherence(sLinked);
   verifyStackCoherence(sArray);

   Person* p = new Person("Leo", "Tolstoy");

   sLinked->push(p);
   sArray->push(p);

   cout << "Both stacks loaded with the same Person object" << endl;
   cout << "   " << sLinked << endl;
   cout << "   " << sArray << endl;

   verifyStackCoherence(sLinked, 1);
   verifyStackCoherence(sArray, 1);

   Entity* p2 = sLinked->pop();
   Entity* p3 = sArray->pop();

   EXPECT_EQ(p, p2);
   EXPECT_EQ(p, p3);

   cout << "Both with the Person popped" << endl;
   cout << "   " << sLinked << endl;
   cout << "   " << sArray << endl;

   verifyStackCoherence(sLinked);
   verifyStackCoherence(sArray);

   delete p;
   delete sLinked;
   delete sArray;
}

Here is the call graph for this function:

container_test::TEST_F	(	SortedLinkedList_test	,
		entityAt
	)

                                        {
   locateEntity(SortedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	SortedLinkedList_test	,
		locateEntity
	)

                                            {
   locateEntity(SortedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	SortedLinkedList_test	,
		purgeConents
	)

                                            {
   purgeConents(SortedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	SortedLinkedList_test	,
		insertingAndRemoving
	)

                                                    {
   insertingAndRemoving(SortedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	SortedLinkedList_test	,
		insertSorted
	)

                                            {
   insertSorted(SortedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	SortedLinkedList_test	,
		cursorControl
	)

                                             {
   cursorControl(SortedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	SortedLinkedList_test	,
		DefaultConstructor
	)

                                                  {
   defaultConstructor(SortedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	SortedArrayList_test	,
		entityAt
	)

                                       {
   locateEntity(SortedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	SortedArrayList_test	,
		locateEntity
	)

                                           {
   locateEntity(SortedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	SortedArrayList_test	,
		purgeConents
	)

                                           {
   purgeConents(SortedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	SortedArrayList_test	,
		insertingAndRemoving
	)

                                                   {
   insertingAndRemoving(SortedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	SortedArrayList_test	,
		insertSorted
	)

                                           {
   insertSorted(SortedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	SortedArrayList_test	,
		cursorControl
	)

                                            {
   cursorControl(SortedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	SortedArrayList_test	,
		DefaultConstructor
	)

                                                 {
   defaultConstructor(SortedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	QueueImpl_test	,
		shallowVersusDeepArray
	)

                                               {
   shallowVersusDeepTest(QueueImpl::factoryArrayComposition());
}

container_test::TEST_F	(	QueueImpl_test	,
		purgeContentsArray
	)

                                           {
   purgeContentsTest(QueueImpl::factoryArrayComposition());
}

container_test::TEST_F	(	QueueImpl_test	,
		purgeContentsLinked
	)

                                            {
   purgeContentsTest(QueueImpl::factoryLinkedComposition());
}

container_test::TEST_F	(	QueueImpl_test	,
		enqueueDequeueArray
	)

                                            {
   enqueueDequeueTest(QueueImpl::factoryArrayComposition());
}

container_test::TEST_F	(	QueueImpl_test	,
		enqueueDequeueLinked
	)

                                             {
   enqueueDequeueTest(QueueImpl::factoryLinkedComposition());
}

container_test::TEST_F	(	QueueImpl_test	,
		factories
	)

                                  {

   cout << "Factory creation of a queue composed with an underlying linked list" << endl;
   Queue* qLinked = QueueImpl::factoryLinkedComposition();
   EXPECT_EQ(QueueImpl::TYPE_INFO, qLinked->typeInfo());
   cout << "   " << qLinked << endl;

   cout << "Factory creation of a queue composed with an underlying array list" << endl;
   Queue* qArray = QueueImpl::factoryArrayComposition();
   EXPECT_EQ(QueueImpl::TYPE_INFO, qArray->typeInfo());
   cout << "   " << qArray << endl;

   verifyQueueCoherence(qLinked);
   verifyQueueCoherence(qArray);

   Person* p = new Person("Herman", "Melville");

   qLinked->enqueue(p);
   qArray->enqueue(p);

   cout << "Both queues loaded with the same Person object" << endl;
   cout << "   " << qLinked << endl;
   cout << "   " << qArray << endl;

   verifyQueueCoherence(qLinked, 1);
   verifyQueueCoherence(qArray, 1);

   Entity* p2 = qLinked->dequeue();
   Entity* p3 = qArray->dequeue();

   EXPECT_EQ(p, p2);
   EXPECT_EQ(p, p3);

   cout << "Both with the Person dequeued" << endl;
   cout << "   " << qLinked << endl;
   cout << "   " << qArray << endl;

   verifyQueueCoherence(qLinked);
   verifyQueueCoherence(qArray);

   delete p;
   delete qLinked;
   delete qArray;
}

Here is the call graph for this function:

container_test::TEST_F	(	OrderedLinkedList_test	,
		entityAt
	)

                                         {
   locateEntity(OrderedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedLinkedList_test	,
		locateEntity
	)

                                             {
   locateEntity(OrderedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedLinkedList_test	,
		purgeConents
	)

                                             {
   purgeConents(OrderedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedLinkedList_test	,
		insertingAndRemoving
	)

                                                     {
   insertingAndRemoving(OrderedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedLinkedList_test	,
		cursorControl
	)

                                              {
   cursorControl(OrderedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedLinkedList_test	,
		append
	)

                                       {
   append(OrderedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedLinkedList_test	,
		DefaultConstructor
	)

                                                   {
   defaultConstructor(OrderedLinkedList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedArrayList_test	,
		entityAt
	)

                                        {
   locateEntity(OrderedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedArrayList_test	,
		locateEntity
	)

                                            {
   locateEntity(OrderedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedArrayList_test	,
		purgeConents
	)

                                            {
   purgeConents(OrderedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedArrayList_test	,
		insertingAndRemoving
	)

                                                    {
   insertingAndRemoving(OrderedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedArrayList_test	,
		cursorControl
	)

                                             {
   cursorControl(OrderedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedArrayList_test	,
		append
	)

                                      {
   append(OrderedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	OrderedArrayList_test	,
		DefaultConstructor
	)

                                                  {
   defaultConstructor(OrderedArrayList::TYPE_INFO);
}

container_test::TEST_F	(	Entity_test	,
		CopyConstructor
	)

                                     {
   Entity b;
   copyConstructorTestCore(b);

   Entity c;
   c.getKeyAsString(); // force member keyAsString to lazy initialize
   copyConstructorTestCore(c);
}

Here is the call graph for this function:

container_test::TEST_F	(	Entity_test	,
		AssignmentOperator
	)

                                        {
   Entity a;
   Entity b;
   assignmentOperatorTestCore(a, b);

   Entity c;
   Entity d;
   c.getKeyAsString(); // force member keyAsString to lazy initialize
   assignmentOperatorTestCore(c, d);

   Entity e;
   Entity f;
   f.getKeyAsString(); // force member keyAsString to lazy initialize
   assignmentOperatorTestCore(e, f);

   Entity g;
   Entity h;
   g.getKeyAsString(); // force member keyAsString to lazy initialize
   h.getKeyAsString(); // force member keyAsString to lazy initialize
   assignmentOperatorTestCore(g, h);
}

Here is the call graph for this function:

container_test::TEST_F	(	Entity_test	,
		DefaultConstructor
	)

                                        {

   // Null check, probably not necessary, but I'm just trying to figure
   // out this new framework.
   Entity* a = new Entity();
   Entity* 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.
   Entity* b = new Entity();
   EXPECT_NE(a, b);

   // A real test. Each Entity should have a unique key.
   cout << "Constructor should assign a unique key automatically" << endl;
   cout << "a " << *a << endl;
   cout << "b " << *b << endl;
   EXPECT_FALSE(a->compareKeyTo(*b) == 0);

   Entity c;
   Entity d;

   // Testing my understanding if C++ again. I think the default constructor
   // is called automatically for c an d.
   cout << "c " << c << endl;
   cout << "d " << d << endl;
   EXPECT_FALSE(c.compareKeyTo(d) == 0);

   delete a;
   delete b;
}

Here is the call graph for this function: