// ================================================================================
// This program stress tests the templated MultiLL container class
int main() {
// The test data (stored in STL lists)
std::list<std::string> songs;
songs.push_back("hound dog");
songs.push_back("poker face");
songs.push_back("brown eyed girl");
songs.push_back("let it be");
songs.push_back("walk like an egyptian");
songs.push_back("man in the mirror");
songs.push_back("stairway to heaven");
songs.push_back("dancing in the street");
songs.push_back("every breath you take");
songs.push_back("hotel california");
// the same data, sorted!
std::list<std::string> sorted_songs(songs);
sorted_songs.sort();
// create an empty multi-linked list and fill it with the test data
MultiLL<std::string> my_list;
for (std::list<std::string>::iterator itr = songs.begin(); itr != songs.end(); itr++) {
my_list.add(*itr);
my_print(my_list);
}
assert (songs.size() == my_list.size());
// -------------------
// iterator tests
// test the chronological iterator (forwards)
std::cout << "chronological order" << std::endl;
std::list<std::string> chrono_order;
MultiLL<std::string>::iterator itr = my_list.begin_chronological();
while (itr != my_list.end_chronological()) {
std::cout << " " << *itr << std::endl;
chrono_order.push_back(*itr);
itr++;
}
std::cout << std::endl;
assert (same(songs,chrono_order));
// test the sorted order iterator (forwards)
std::cout << "sorted order" << std::endl;
std::list<std::string> sorted_order;
itr = my_list.begin_sorted();
while (itr != my_list.end_sorted()) {
std::cout << " " << *itr << std::endl;
sorted_order.push_back(*itr);
itr++;
}
std::cout << std::endl;
assert (same(sorted_songs,sorted_order));
// test the random order iterator
std::cout << "random order" << std::endl;
std::list<std::string> random_order;
itr = my_list.begin_random();
for (int i = 0; i < my_list.size(); i++,itr++) {
std::cout << " " << *itr << std::endl;
random_order.push_back(*itr);
}
std::cout << std::endl;
// loop through the elements a second time (the order should be the same!)
std::list<std::string>::iterator itr2 = random_order.begin();
for (int i = 0; i < my_list.size(); i++,itr++,itr2++) {
// verify that the elements repeat the order
assert (*itr == *itr2);
}
std::list<std::string> random_order_check(random_order);
random_order_check.sort();
// verify that all of the elements appeared in the initial loop
assert (same(sorted_songs,random_order_check));
// test the re-randomization by creating a new random iterator
std::cout << "random order 2" << std::endl;
std::list<std::string> random_order2;
itr = my_list.begin_random();
for (int i = 0; i < my_list.size(); i++,itr++) {
std::cout << " " << *itr << std::endl;
random_order2.push_back(*itr);
}
std::cout << std::endl;
// with over 3 million different possible permutations of 10
// elements, it is highly unlikely they will be the same!
assert (!same(random_order,random_order2));
/*
// -------------------
// erase tests
// erase the first element inserted
itr = my_list.begin_chronological();
assert (*itr == "hound dog");
itr = my_list.erase(itr);
assert (*itr == "poker face");
assert (my_list.size() == 9);
std::cout << "erased: hound dog" << std::endl;
// erase the second to last element in sorted order
itr = my_list.begin_sorted();
for (int i = 0; i < 7; i++) { itr++; }
assert (*itr == "stairway to heaven");
itr = my_list.erase(itr);
assert (*itr == "walk like an egyptian");
assert (my_list.size() == 8);
std::cout << "erased: stairway to heaven" << std::endl;
// erase the third element in the random order
itr = my_list.begin_random();
itr++;
itr++;
std::string tmp = *itr;
// note that the return value of erase with a random iterator is undefined
my_list.erase(itr);
std::cout << "erased: " << tmp << std::endl;
assert (my_list.size() == 7);
assert (!my_list.empty());
my_list.clear();
assert (my_list.empty());
assert (my_list.size() == 0);
std::cout << "cleared the whole list!" << std::endl << std::endl;
*/
// ---------------------------
// ADD YOUR OWN TEST CASES BELOW
// be sure to test:
// copy constructor
// assignment operator
// destructor
// all corner cases of erase
// decrement operator for the chronological & sorted iterators
// pre vs. post increment & decrement operations for iterators
// MultiLL containing types other than std::string
// anything else that is necessary
std::cout << " *** OUTPUT FROM YOUR TEST CASES ***" << std::endl;
// copy constructor
MultiLL<std::string> copy_list(my_list);
std::cout << "Old list:" << std::endl;
my_print(my_list);
/*
std::cout << "Copy of old list:" << std::endl;
my_print(copy_list);
*/
}
void ProvidedTests() {
std::cout << "Begin ProvidedTests..." << std::endl;
// The test data (stored in STL lists)
std::list<std::string> songs;
songs.push_back("hound dog");
songs.push_back("poker face");
songs.push_back("brown eyed girl");
songs.push_back("let it be");
songs.push_back("walk like an egyptian");
songs.push_back("man in the mirror");
songs.push_back("stairway to heaven");
songs.push_back("dancing in the street");
songs.push_back("every breath you take");
songs.push_back("hotel california");
// the same data, sorted!
std::list<std::string> sorted_songs(songs);
sorted_songs.sort();
// create an empty multi-linked list and fill it with the test data
MultiLL<std::string> my_list;
for (std::list<std::string>::iterator itr = songs.begin(); itr != songs.end(); itr++) {
my_list.add(*itr);
}
assert (songs.size() == my_list.size());
// -------------------
// iterator tests
// test the chronological iterator (forwards)
std::cout << "chronological order" << std::endl;
std::list<std::string> chrono_order;
MultiLL<std::string>::iterator itr = my_list.begin_chronological();
while (itr != my_list.end_chronological()) {
std::cout << " " << *itr << std::endl;
chrono_order.push_back(*itr);
itr++;
}
std::cout << std::endl;
assert (same(songs,chrono_order));
// test the sorted order iterator (forwards)
std::cout << "sorted order" << std::endl;
std::list<std::string> sorted_order;
itr = my_list.begin_sorted();
while (itr != my_list.end_sorted()) {
std::cout << " " << *itr << std::endl;
sorted_order.push_back(*itr);
itr++;
}
std::cout << std::endl;
assert (same(sorted_songs,sorted_order));
// test the random order iterator
std::cout << "random order" << std::endl;
std::list<std::string> random_order;
itr = my_list.begin_random();
for (unsigned int i = 0; i < my_list.size(); i++,itr++) {
std::cout << " " << *itr << std::endl;
random_order.push_back(*itr);
}
std::cout << std::endl;
// loop through the elements a second time (the order should be the same!)
std::list<std::string>::iterator itr2 = random_order.begin();
for (unsigned int i = 0; i < my_list.size(); i++,itr++,itr2++) {
// verify that the elements repeat the order
assert (*itr == *itr2);
}
std::list<std::string> random_order_check(random_order);
random_order_check.sort();
// verify that all of the elements appeared in the initial loop
assert (same(sorted_songs,random_order_check));
// test the re-randomization by creating a new random iterator
std::cout << "random order 2" << std::endl;
std::list<std::string> random_order2;
itr = my_list.begin_random();
for (unsigned int i = 0; i < my_list.size(); i++,itr++) {
std::cout << " " << *itr << std::endl;
random_order2.push_back(*itr);
}
std::cout << std::endl;
// with over 3 million different possible permutations of 10
// elements, it is highly unlikely they will be the same!
assert (!same(random_order,random_order2));
// -------------------
// erase tests
// erase the first element inserted
itr = my_list.begin_chronological();
assert (*itr == "hound dog");
itr = my_list.erase(itr);
assert (*itr == "poker face");
assert (my_list.size() == 9);
std::cout << "erased: hound dog" << std::endl;
// erase the second to last element in sorted order
itr = my_list.begin_sorted();
for (int i = 0; i < 7; i++) { itr++; }
assert (*itr == "stairway to heaven");
itr = my_list.erase(itr);
assert (*itr == "walk like an egyptian");
assert (my_list.size() == 8);
std::cout << "erased: stairway to heaven" << std::endl;
// erase the third element in the random order
itr = my_list.begin_random();
itr++;
itr++;
std::string tmp = *itr;
// note that the return value of erase with a random iterator is undefined
my_list.erase(itr);
std::cout << "erased: " << tmp << std::endl;
assert (my_list.size() == 7);
assert (!my_list.empty());
my_list.clear();
assert (my_list.empty());
assert (my_list.size() == 0);
std::cout << "cleared the whole list!" << std::endl << std::endl;
std::cout << "Finished ProvidedTests." << std::endl;
}
