/*!a Test case to verify insertAt(size_t, UtlContainable*) for a
* list that is not empty.
* The test data for this test are
* a) Insert any UtlContainable to the 0th location,
* b) Insert a UtlInt to a 'mid' location,
* c) Insert any UtlString object to a 'mid' location
* d) Insert any UtlContainable object to the last location
*/
void testInsertAt_NonEmptyList()
{
const int testCount = 4 ;
const char* prefix = "Test insert(n, Collectable*) for a list that is not empty; "\
"where Collectable is " ;
const char* Msgs[] = { \
"a UtlContainableXXX and n = 0", \
"a UtlString and n > 0 && n < size", \
"a UtlInt and n > 0 && n < size", \
"a UtlContainableXXX where n = size-1" \
};
const char* suffix1 = " :- Verify return value" ;
const char* suffix2 = " :- Verify value is appended" ;
const char* suffix3 = " :- Verify new list size" ;
UtlString testFirst("First Entry") ;
UtlInt testInt(102) ;
UtlString testString("Test String") ;
UtlInt testLast(99999) ;
UtlContainable* itemToAdd[] = { &testFirst, &testInt, &testString, &testLast } ;
UtlContainable* expectedValue[] = { &testFirst, &testInt, &testString, &testLast} ;
int insertLocation[] = { 0, 2, 3, commonEntriesCount+3} ;
int tmpCount = commonEntriesCount ;
int expectedEntries[] = {++tmpCount, ++tmpCount, ++tmpCount, ++tmpCount} ;
for (int i = 0 ; i < testCount ; i++)
{
UtlContainable* uActual ;
string msg ;
// comment out for now. Uncomment if implementation returns Collectable
uActual = commonList.insertAt(insertLocation[i], itemToAdd[i]);
//verify that the right value is returned.
TestUtilities::createMessage(3, &msg, prefix, Msgs[i], suffix1) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), expectedValue[i], uActual) ;
//`commonList.insertAt(insertLocation[i], itemToAdd[i]);
// verify that the value is inserted
TestUtilities::createMessage(3, &msg, prefix, Msgs[i], suffix2) ;
uActual = commonList.at(insertLocation[i]) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), expectedValue[i], uActual) ;
//verify that the total number of entries has incremented by one.
TestUtilities::createMessage(3, &msg, prefix, Msgs[i], suffix3) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), expectedEntries[i], \
(int)commonList.entries()) ;
}
}//testInsertAt_NonEmptyList()
/*a! This test is more of a sanity check to verify that
* the basic append(), entries() and at() methods work as expected.
* All future tests will depend heavily on the at() method
* and the most common way of having something in the list is
* by means of the append() method.
*
*/
void checkSanity_Append_Entries_And_At()
{
for (int i = 0 ; i < commonEntriesCount; i++)
{
UtlContainable* ucExpected = commonContainables[i] ;
UtlContainable* ucActual = commonList.at(i) ;
string msg ;
char strItr[33] ;
sprintf(strItr, "%d", i);
TestUtilities::createMessage(3, &msg, "Verify that the at(n) method, where n = ", \
strItr, " ;") ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), ucExpected, ucActual) ;
}
CPPUNIT_ASSERT_EQUAL_MESSAGE("Verify that the entries() for an empty list returns 0", \
(int)emptyList.entries(), 0) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE("Verify the entries() method for a list", \
(int)commonList.entries(), commonEntriesCount) ;
}// checkSanity_Append_And_At()
/*!a! Test case to verify insertAt(size_t, UtlContainable*) for an
* empty list.
* The test data for this test are
* a) Insert a UtlString to the 0th location,
* b) Insert a UtlInt to the 0th location,
* c) Insert any UtlContainable object to a 'non-zero' location
*/
void testInsertAt_EmptyList()
{
const int testCount = 3 ;
const char* prefix = "Test insert(n, Collectable*) for an empty list; "\
"where Collectable is " ;
const char* Msgs[] = { \
"a UtlString and n = 0", \
"a UtlInt and n = 0", \
"a UtlContainableXXX and n > 0" \
};
const char* suffix1 = " :- Verify return value" ;
const char* suffix2 = " :- Verify value is appended" ;
UtlInt testInt(102) ;
UtlString testString("Test String") ;
UtlString testNegative("This should not get added") ;
UtlContainable* itemToAdd[] = { &testString, &testInt, &testNegative } ;
UtlContainable* expectedValue[] = { &testString, &testInt, NULL} ;
int insertLocation[] = { 0, 0, 1} ;
for (int i = 0 ; i < testCount ; i++)
{
UtlDList testList ;
string msg ;
// insertAt now returns void. Retain this block of comment in case
// we (I think we should return a Collectable / bool) decide to return
// a collectable.
UtlContainable* result = testList.insertAt(insertLocation[i], itemToAdd[i]);
//verify that the right value is returned.
TestUtilities::createMessage(3, &msg, prefix, Msgs[i], suffix1) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), expectedValue[i], result) ;
testList.insertAt(insertLocation[i], itemToAdd[i]) ;
// verify that the value is inserted
TestUtilities::createMessage(3, &msg, prefix, Msgs[i], suffix2) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), expectedValue[i], testList.at(0)) ;
}
}//testInsertAt_EmptyList
void utlTestAppend_Insert(TestInsertOrAppend type)
{
int testCount = 2 ;
const char* prefix = "";
UtlInt testInt(1234) ;
UtlString testString("Test String") ;
if (type == TEST_APPEND)
{
commonList.append(&testInt) ;
commonList.append(&testString) ;
prefix = "Test the append(UtlContainable*) method for a non empty list" ;
}
else if (type == TEST_INSERT)
{
commonList.insert(&testInt) ;
commonList.insert(&testString) ;
prefix = "Test the insert(UtlContainable*) method for a non empty list" ;
}
int expectedCount = commonEntriesCount + testCount ;
UtlContainable* uActual ;
UtlContainable* uExpected ;
string msg ;
// Verify that the number of entries has increased accordingly
TestUtilities::createMessage(2, &msg, prefix, " :- Verify the number of entries") ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), expectedCount, \
(int)commonList.entries()) ;
// Verify that the first entry has still not changed.
uActual = commonList.at(0) ;
uExpected = commonContainables[0] ;
TestUtilities::createMessage(2, &msg, prefix, \
" :- Verify that the first entry is not changed") ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), uActual, uExpected) ;
// Verify the entry at the previous last position
TestUtilities::createMessage(2, &msg, prefix, \
" :- Verify that the previous last entry is intact") ;
// Verify that the number of entries has increased accordingly
TestUtilities::createMessage(2, &msg, prefix, \
" :- Verify the number of entries") ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), expectedCount, \
(int)commonList.entries()) ;
// Verify that the first entry has still not changed.
uActual = commonList.at(0) ;
uExpected = commonContainables[0] ;
TestUtilities::createMessage(2, &msg, prefix, \
" :- Verify that the first entry is not changed") ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), uActual, uExpected) ;
// Verify the entry at the previous last position
TestUtilities::createMessage(2, &msg, prefix, \
" :- Verify that the previous last entry is intact") ;
uActual = commonList.at(commonEntriesCount-1) ;
uExpected = commonContainables[commonEntriesCount-1] ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), uActual, uExpected) ;
// Verify that the two new entries are added.
TestUtilities::createMessage(2, &msg, prefix, \
" :- Verify that the Collectable Integer has been added") ;
uActual = commonList.at(commonEntriesCount) ;
uExpected = &testInt ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), uActual, uExpected) ;
TestUtilities::createMessage(2, &msg, prefix, \
" :- Verify that the Collectable String has been added") ;
uActual = commonList.at(commonEntriesCount + 1) ;
uExpected = &testString ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(msg.data(), uActual, uExpected) ;
} //testAppend
