container_test::SortedList_test Class Reference

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

#include <sortedlist_test.h>

Inheritance diagram for container_test::SortedList_test:

[legend]

Collaboration diagram for container_test::SortedList_test:

[legend]

List of all members.

Protected Member Functions
	SortedList_test ()
virtual	~SortedList_test ()
void	insertSorted (const Object::Info *type)
void	insertingAndRemoving (const Object::Info *type)
Protected Attributes
OrderedLinkedList	unsortedGroup
OrderedLinkedList	sortedGroup
Person *	joeSmith
Person *	janeSmith
Person *	fredHarris
Person *	joseGonzales
Person *	fernandaMijares
OrderedLinkedList	otherUnsortedGroup
OrderedLinkedList	otherSortedGroup
Person *	otherJoeSmith
Person *	otherJaneSmith
Person *	otherFredHarris
Person *	otherJoseGonzales
Person *	otherFernandaMijares

---

Detailed Description

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

There are no actual unit tests in SortedList_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 SortedLinkedList_test and SortedArrayList_test in order to re-use common unit test code.

---

Constructor & Destructor Documentation

container_test::SortedList_test::SortedList_test

(

)

[protected]

                                 {
   string joe = "Joe";
   string smith = "Smith";
   string jane = "Jane";
   string fred = "Fred";
   string harris = "Harris";
   string jose = "Jose";
   string gonzales = "Gonzales";
   string fernanda = "Fernanda";
   string mijares = "Mijares";
   joeSmith = new Person(joe, smith);
   janeSmith = new Person(jane, smith);
   fredHarris = new Person(fred, harris);
   joseGonzales = new Person(jose, gonzales);
   fernandaMijares = new Person(fernanda, mijares);

   unsortedGroup.add(joeSmith);
   unsortedGroup.add(janeSmith);
   unsortedGroup.add(fredHarris);
   unsortedGroup.add(joseGonzales);
   unsortedGroup.add(fernandaMijares);

   sortedGroup.add(joseGonzales);
   sortedGroup.add(fredHarris);
   sortedGroup.add(fernandaMijares);
   sortedGroup.add(janeSmith);
   sortedGroup.add(joeSmith);

   otherJoeSmith = new Person(joe, smith);
   otherJaneSmith = new Person(jane, smith);
   otherFredHarris = new Person(fred, harris);
   otherJoseGonzales = new Person(jose, gonzales);
   otherFernandaMijares = new Person(fernanda, mijares);

   otherUnsortedGroup.add(otherJoeSmith);
   otherUnsortedGroup.add(otherJaneSmith);
   otherUnsortedGroup.add(otherFredHarris);
   otherUnsortedGroup.add(otherJoseGonzales);
   otherUnsortedGroup.add(otherFernandaMijares);

   otherSortedGroup.add(otherJoseGonzales);
   otherSortedGroup.add(otherFredHarris);
   otherSortedGroup.add(otherFernandaMijares);
   otherSortedGroup.add(otherJaneSmith);
   otherSortedGroup.add(otherJoeSmith);
}

Here is the call graph for this function:

container_test::SortedList_test::~SortedList_test

(

)

[protected, virtual]

                                  {
   // You can do clean-up work that doesn't throw exceptions here.
   while (sortedGroup.toFirst()) {
      sortedGroup.extractCurrentEntity();
   }
   while (otherSortedGroup.toFirst()) {
      otherSortedGroup.extractCurrentEntity();
   }
}

Here is the call graph for this function:

---

Member Function Documentation

void container_test::SortedList_test::insertingAndRemoving

(

const Object::Info *

type

)

[protected]

                                                                 {
   SortedList* a = sortedListFactory(type);
   const int LIST_SIZE = 5;
   Entity ** data;
   generateDataAndPopulateList(data, a, LIST_SIZE, true);

   EXPECT_TRUE(a->toFirst());
   cout << "Iterating from first to last." << endl;
   for (int i = 0; !a->isTail(); i++ + a->toNext()) {
      cout << "  node[" << i << "] contains: " << *a->currentEntity() << endl;
      EXPECT_EQ(data[i], a->currentEntity());
      EXPECT_TRUE(data[i] == a->currentEntity());
      verifyNonEmptyStateCoherence_notTail(*a, LIST_SIZE);
   }
   verifyNonEmptyStateCoherence_tail(*a, LIST_SIZE);

   cout << "Iterating from last to first." << endl;
   for (int i = (LIST_SIZE - 1); a->toPrev(); i--) {
      cout << "  node[" << i << "] contains: " << *a->currentEntity() << endl;
      EXPECT_EQ(data[i], a->currentEntity());
      EXPECT_TRUE(data[i]->compareKeyTo(*a->currentEntity()) == 0);
      verifyNonEmptyStateCoherence_notTail(*a, LIST_SIZE);
   }
   EXPECT_TRUE(a->isFirst());
   verifyNonEmptyStateCoherence_notTail(*a, LIST_SIZE);

   cout << "Extracting from first to last." << endl;
   int index = 0;
   do {
      Entity *e = a->extractCurrentEntity();
      cout << "  extracted " << *e << endl;
      cout << "    " << a << endl;
      EXPECT_EQ(data[index], e);
      EXPECT_TRUE(data[index]->compareKeyTo(*e) == 0);
      if (index < (LIST_SIZE - 1)) {
         verifyNonEmptyStateCoherence_notTail(*a, LIST_SIZE - index - 1);
      } else {
         verifyEmptyStateCoherence(*a);
      }
      index++;
   } while (!a->isTail());

   cout << "Repopulating same list with extracted Entities" << endl;
   cout << "  " << a << endl;
   for (int i = 0; i < LIST_SIZE; i++) {
      a->insertSorted(data[i]);
      cout << "  After insertSorted() " << *data[i] << endl;
      cout << "    " << a << endl;
      verifyNonEmptyStateCoherence_tail(*a, i + 1);
   }

   cout << "Deleting from first to last." << endl;
   index = 0;
   a->toFirst();
   do {
      EXPECT_EQ(data[index], a->currentEntity());
      EXPECT_TRUE(a->deleteCurrent());
      cout << "  deleteCurrent()" << endl;
      cout << "    " << a << endl;
      if (index < (LIST_SIZE - 1)) {
         verifyNonEmptyStateCoherence_notTail(*a, LIST_SIZE - index - 1);
      } else {
         verifyEmptyStateCoherence(*a);
      }
      index++;
   } while (!a->isTail());

   delete a;
   delete data;
}

Here is the call graph for this function:

void container_test::SortedList_test::insertSorted

(

const Object::Info *

type

)

[protected]

                                                         {
   SortedList *a = sortedListFactory(type);
   cout << "Starting with an empty " << type->typeName << ":" << endl;
   cout << "  " << a << endl;
   int i = 0;
   for (unsortedGroup.toFirst(); !unsortedGroup.isTail(); unsortedGroup.toNext()) {
      cout << "  Adding " << unsortedGroup.currentEntity()->getKeyAsString();
      EXPECT_TRUE(a->insertSorted(unsortedGroup.currentEntity()));
      i++;
      cout << "; result: " << a << endl;
      verifyNonEmptyStateCoherence_tail(a, i);

      // Verify that all added Person objects can be located and that ones
      // yet to be added cannot be located.
      for (int j = 0; j < unsortedGroup.getCount(); j++) {
         Entity* e1 = unsortedGroup.entityAt(j);
         Entity* oe1 = otherUnsortedGroup.entityAt(j);
         // The content of otherUnsortedGroup should match unsortedGroup but
         // should contain unique instances.
         EXPECT_NE(e1, oe1);
         EXPECT_EQ(e1->getKeyAsString(), oe1->getKeyAsString());
         EXPECT_TRUE(e1->compareKeyTo(*oe1) == 0);

         int index;
         Entity* e2;
         if ((i % 2) == 0) {
            // locate by the same Entity instance
            a->locateEntity(*e1, index, e2);
         } else {
            // locate by a different Entity instance with matching key
            a->locateEntity(*oe1, index, e2);
         }
         if (j < i) {
            EXPECT_NE(List::NO_MATCHING_ENTITY_INDEX_FLAG, index);
            EXPECT_EQ(e1, e2);
            EXPECT_NE(e1, oe1);
            EXPECT_TRUE(e1->compareKeyTo(*e2) == 0);
            EXPECT_TRUE(oe1->compareKeyTo(*e2) == 0);
            EXPECT_EQ(e1, a->entityAt(index));

            // verify that duplicates are rejected
            cout << "    Attempting to add duplicate e1 " << e1->getKeyAsString() << endl;
            cout << "      a->insertSorted(e1) returns: " << (a->insertSorted(e1) ? "true" : "false") << endl;
            cout << "      a->getCount() returns: " << a->getCount() << endl;
            EXPECT_FALSE(a->insertSorted(e1));
            verifyNonEmptyStateCoherence_tail(a, i);
            EXPECT_FALSE(a->insertSorted(oe1));
            verifyNonEmptyStateCoherence_tail(a, i);
         } else {
            EXPECT_EQ(List::NO_MATCHING_ENTITY_INDEX_FLAG, index);
            EXPECT_TRUE(e2 == NULL);
         }
      }
   }

   cout << "Checking for expected sorted order." << endl;
   i = 0;
   for (a->toFirst(); !a->isTail(); a->toNext()) {
      Entity* e1 = sortedGroup.entityAt(i);
      Entity* oe1 = otherSortedGroup.entityAt(i);
      Entity* e2 = a->currentEntity();
      cout << "   [" << i << "]expected: " << e1 << endl;
      cout << "        actual: " << e2 << endl;
      EXPECT_EQ(e1, e2);
      EXPECT_NE(e1, oe1);
      EXPECT_TRUE(e1->compareKeyTo(*e2) == 0);
      EXPECT_TRUE(oe1->compareKeyTo(*e2) == 0);
      i++;
   }

   while (a->toFirst()) {
      a->extractCurrentEntity();
   }

   delete a;
}

Here is the call graph for this function:

---

Member Data Documentation

Person* container_test::SortedList_test::fernandaMijares [protected]

Person* container_test::SortedList_test::fredHarris [protected]

Person* container_test::SortedList_test::janeSmith [protected]

Person* container_test::SortedList_test::joeSmith [protected]

Person* container_test::SortedList_test::joseGonzales [protected]

Person* container_test::SortedList_test::otherFernandaMijares [protected]

Person* container_test::SortedList_test::otherFredHarris [protected]

Person* container_test::SortedList_test::otherJaneSmith [protected]

Person* container_test::SortedList_test::otherJoeSmith [protected]

Person* container_test::SortedList_test::otherJoseGonzales [protected]

OrderedLinkedList container_test::SortedList_test::otherSortedGroup [protected]

OrderedLinkedList container_test::SortedList_test::otherUnsortedGroup [protected]

OrderedLinkedList container_test::SortedList_test::sortedGroup [protected]

OrderedLinkedList container_test::SortedList_test::unsortedGroup [protected]

---

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

• sortedlist_test.h
• sortedlist_test.cpp