container_test::QueueImpl_test Class Reference

Unit tests for QueueImpl. More...

Collaboration diagram for container_test::QueueImpl_test:

[legend]

List of all members.

Protected Member Functions
	QueueImpl_test ()
virtual	~QueueImpl_test ()
virtual void	SetUp ()
virtual void	TearDown ()
void	verifyQueueCoherence (Queue *q, const int count=0)
void	startingEmpty (Queue *q)
void	enqueueDequeueTest (Queue *q)
void	firstTenPresidents (Queue *q)
	Copy testData and add copy to q.
void	purgeContentsTest (Queue *q)
void	verifyEquivalence (Queue *orig, Queue *copy, bool deepCopy)
void	shallowVersusDeepTest (Queue *q)
Protected Attributes
OrderedList *	testData

---

Detailed Description

Unit tests for QueueImpl.

---

Constructor & Destructor Documentation

container_test::QueueImpl_test::QueueImpl_test

(

)

[inline, protected]

                    {
      // You can do set-up work for each test here.

      testData = new OrderedArrayList(10, 5);
      testData->append(new Person("George", "Washington"));
      testData->append(new Person("John", "Adams"));
      testData->append(new Person("Thomas", "Jefferson"));
      testData->append(new Person("James", "Madison"));
      testData->append(new Person("James", "Monroe"));
      testData->append(new Person("John Quincy", "Adams"));
      testData->append(new Person("Andrew", "Jackson"));
      testData->append(new Person("Marin", "Van Buren"));
      testData->append(new Person("William Henry", "Harrison"));
      testData->append(new Person("John", "Tyler"));
   }

Here is the call graph for this function:

virtual container_test::QueueImpl_test::~QueueImpl_test

(

)

[inline, protected, virtual]

                             {
      // You can do clean-up work that doesn't throw exceptions here.

      delete testData;
   }

---

Member Function Documentation

void container_test::QueueImpl_test::enqueueDequeueTest

(

Queue *

q

)

[inline, protected]

                                     {
      startingEmpty(q);

      for (int i = 0; i < testData->getCount(); i++) {
         cout << "  adding " << testData->entityAt(i) << endl;
         q->enqueue(testData->entityAt(i));
         cout << "    " << q << endl;
         verifyQueueCoherence(q, i + 1);
      }

      cout << "Dequeueing items one by one:" << endl;
      for (int i = 0; i < testData->getCount(); i++) {
         Entity* e = q->dequeue();
         EXPECT_EQ(testData->entityAt(i), e);
         cout << "   [" << i << "]expected " << testData->entityAt(i) << endl;
         cout << "        actual " << e << endl;
         verifyQueueCoherence(q, testData->getCount() - i - 1);
      }

      cout << "Ending with an empty queue:" << endl;
      cout << "    " << q << endl;

      delete q;
   }

Here is the call graph for this function:

void container_test::QueueImpl_test::firstTenPresidents

(

Queue *

q

)

[inline, protected]

Copy testData and add copy to q.

Helper method.

                                     {
      for (int i = 0; i < testData->getCount(); i++) {

         Entity* e = testData->entityAt(i);
         Person* p = dynamic_cast<Person*>(e);

         // use copy constructor
         Person* pCopy = new Person(*p);
         q->enqueue(pCopy);
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void container_test::QueueImpl_test::purgeContentsTest

(

Queue *

q

)

[inline, protected]

                                    {
      startingEmpty(q);

      cout << "Purging an empty queue:" << endl;
      int n = q->purgeContents();
      cout << "   deleted " << n << " items" << endl;
      EXPECT_EQ(0, n);
      verifyQueueCoherence(q, 0);

      cout << "Populating queue with first " << testData->getCount() <<
            " presidents:" << endl;
      firstTenPresidents(q);
      cout << "  " << q << endl;
      verifyQueueCoherence(q, testData->getCount());

      cout << "Purging:" << endl;
      n = q->purgeContents();
      cout << "    deleted " << n << " items" << endl;
      cout << "  " << q << endl;
      EXPECT_EQ(testData->getCount(), n);
      verifyQueueCoherence(q, 0);

      delete q;
   }

Here is the call graph for this function:

virtual void container_test::QueueImpl_test::SetUp

(

)

[inline, protected, virtual]

                        {
      // Code here will be called immediately after the constructor (right
      // before each test).
   }

void container_test::QueueImpl_test::shallowVersusDeepTest

(

Queue *

q

)

[inline, protected]

                                        {
      firstTenPresidents(q);
      cout << "Starting with " << testData->getCount() << " People:" << endl;
      cout << "    " << q << endl;
      verifyQueueCoherence(q, testData->getCount());
      cout << "Creating shallow copy:" << endl;
      Queue* qCopy = dynamic_cast<Queue*>(q->clone(false));
      cout << "    " << qCopy << endl;
      verifyQueueCoherence(qCopy, testData->getCount());
      verifyEquivalence(q, qCopy, false);

      while (!qCopy->isEmpty()) {
         qCopy->dequeue();
      }
      verifyQueueCoherence(qCopy, 0);
      delete qCopy;
      verifyQueueCoherence(q, testData->getCount());

      cout << "Creating deep copy:" << endl;
      qCopy = dynamic_cast<Queue*>(q->clone(true));
      cout << "    " << qCopy << endl;
      verifyQueueCoherence(qCopy, testData->getCount());
      verifyEquivalence(q, qCopy, true);

      delete q;
      verifyQueueCoherence(qCopy, testData->getCount());
      delete qCopy;
   }

Here is the call graph for this function:

void container_test::QueueImpl_test::startingEmpty

(

Queue *

q

)

[inline, protected]

                                {
      cout << "Starting with an empty queue:" << endl;
      cout << "    " << q << endl;
      EXPECT_EQ(0, q->getCount());
      verifyQueueCoherence(q, 0);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void container_test::QueueImpl_test::TearDown

(

)

[inline, protected, virtual]

                           {
      // Code here will be called immediately after each test (right
      // before the destructor).
   }

void container_test::QueueImpl_test::verifyEquivalence	(	Queue *	orig,
		Queue *	copy,
		bool	deepCopy
	)			[inline, protected]

                                                                   {
      cout << "  orig->typeInfo():" << endl;
      cout << "     original " << orig->typeInfo() << endl;
      cout << "         copy " << copy->typeInfo() << endl;
      EXPECT_EQ(orig->typeInfo(), copy->typeInfo());
      cout << "  getCount():" << endl;
      cout << "     original " << orig->getCount() << endl;
      cout << "         copy " << copy->getCount() << endl;
      EXPECT_EQ(orig->getCount(), copy->getCount());
      cout << "  isEmpty():" << endl;
      cout << "     original " << orig->isEmpty() << endl;
      cout << "         copy " << copy->isEmpty() << endl;
      EXPECT_EQ(orig->isEmpty(), copy->isEmpty());
      if (deepCopy) {
         cout << "  Deep copy should create new, independent People objects:" << endl;
      } else {
         cout << "  Shallow copy should share the same People objects:" << endl;
      }
      for (int i = 0; i < orig->getCount(); i++) {
         Person* op = dynamic_cast<Person*>(orig->dequeue());
         Person* cp = dynamic_cast<Person*>(copy->dequeue());
         orig->enqueue(op);
         copy->enqueue(cp);
         cout << "    [" << i << "]" << endl;
         cout << "        original pointer value " << ((void*)op) << endl;
         cout << "            copy pointer value " << ((void*)cp) << endl;
         op->setFirstName(op->getFirstName().append(" Albert"));
         if (deepCopy) {
            EXPECT_NE(op, cp);
            cout << "      Change to one won't affect the other:" << endl;
            EXPECT_NE(op->getFirstName(), cp->getFirstName());
         } else {
            EXPECT_EQ(op, cp);
            cout << "      Change to one will affect the other:" << endl;
            EXPECT_EQ(op->getFirstName(), cp->getFirstName());
         }
         cout << "       original " << op << endl;
         cout << "           copy " << cp << endl;
      }

   }

Here is the call graph for this function:

Here is the caller graph for this function:

void container_test::QueueImpl_test::verifyQueueCoherence	(	Queue *	q,
		const int	count = 0
	)			[inline, protected]

                                                            {
      EXPECT_TRUE(count >= 0);
      EXPECT_TRUE(q->getCount() >= 0);
      EXPECT_EQ(count, q->getCount());
      if (count == 0) {
         EXPECT_TRUE(q->isEmpty());
         EXPECT_TRUE(q->dequeue() == NULL);
      } else {
         EXPECT_FALSE(q->isEmpty());
      }

      OrderedList* list = new OrderedArrayList();
      int n = count;
      while (!q->isEmpty()) {
         Entity* e = q->dequeue();
         EXPECT_TRUE(e != NULL);
         list->append(e);
         n--;
         EXPECT_EQ(q->getCount(), n);
      }

      EXPECT_TRUE(q->getCount() == 0);
      EXPECT_TRUE(q->isEmpty());
      EXPECT_TRUE(q->dequeue() == NULL);

      for (int i = 0; i < list->getCount(); i++) {
         q->enqueue(list->entityAt(i));
      }

      EXPECT_EQ(q->getCount(), count);

      while (list->toFirst()) {
         list->extractCurrentEntity();
      }
      delete list;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

---

Member Data Documentation

OrderedList* container_test::QueueImpl_test::testData [protected]

---

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

• queueimpl_test.cpp