bool Test::test_mazeReader01() { bool isPassed = false; m_testNum++; printTestMessage(m_testNum, "MazeReader throws MazeCreationException if file doesn't exist"); try { MazeReader mr(""); } catch(MazeCreationException& mce) { isPassed = true; } catch(...) { std::cerr << "ERROR: Exception thrown was not MazeCreationException" << std::endl; } printPassFail(isPassed); return(isPassed); }
bool Test::test2() { bool isPassed = true; const int SIZE = 1000; const int LOW = -100; const int HIGH = 100; int* arr = Sorts<int>::createTestArray(SIZE, LOW, HIGH); printTestMessage(2, "createTestArray creates an array with values in the provided range"); //check each value to ensure it's in range for(int i=0; i<SIZE && isPassed; i++) { if(arr[i] < LOW || arr[i] > HIGH) { isPassed = false; std::cerr << "ERROR! Excepted value from " << LOW << " to " << HIGH << ". Got " << arr[i]; std::cerr << std::endl; } } delete[] arr; arr = nullptr; printPassFail(isPassed); return (isPassed); }
bool Test::test17() { bool isPassed = false; const int LOW = 0; const int HIGH = 5000; int* arr = Sorts<int>::createTestArray(TEST_SIZE, LOW, HIGH); double time = 0.0; printTestMessage(17, "selection sort completes in reasonable amount of time (0-10secs platform dependent) " + std::to_string(TEST_SIZE)); time = Sorts<int>::sortTimer(Sorts<int>::selectionSort, arr, TEST_SIZE); std::cerr << "\nTime for selection sort on " + std::to_string(TEST_SIZE) + " elements: " << time << " "; if(time<0 || time>10) { isPassed = false; } else { isPassed = true; } delete[] arr; arr = nullptr; printPassFail(isPassed); return (isPassed); }
bool Test::test_order03() { bool isPassed = false; BSTI<int>* bst = new BinarySearchTree<int>(); std::vector<int> input = {50, 25, 75, 10, 30, 65, 100}; std::vector<int> correct = {10, 30, 25, 65, 100, 75, 50}; std::vector<int> output; m_testNum++; printTestMessage(m_testNum, "vector returned by treeToVector(IN_ORDER) returns vector: {10, 30, 25, 65, 100, 75, 50}"); loadVectorIntoTree(input, bst); output = bst->treeToVector(POST_ORDER); if(output == correct) { isPassed = true; } else { isPassed = false; std::cerr << "ERROR: expected "; printVector(correct); std::cerr << " got "; printVector(output); std::cerr << std::endl; } printPassFail(isPassed); delete bst; return(isPassed); }
bool Test::test9() { Stack<int> stack; bool isPassed = false; int trackedSize = 0; printTestMessage(9, "size remains accurate after lots of pushes and pops"); try { for(int i=0; i<TEST_SIZE; i++) { if(i%5 == 0 && i > 0) { stack.pop(); trackedSize--; } else { stack.push(i); trackedSize++; } } } catch(...) { std::cerr << "Unexpected exception thrown!" << std::endl; } isPassed = stack.size() == trackedSize; std::cerr << "\nExpected size: " << trackedSize << " size() returned: " << stack.size() << " "; printPassFail(isPassed); return(isPassed); }
bool Test::test_search06() { bool isPassed = true; BSTI<int>* bst = new BinarySearchTree<int>(); std::vector<int> vec; m_testNum++; printTestMessage(m_testNum, "searching for all values in a large tree of random values; all searches return true"); uniqueRandomFill(vec, TEST_SIZE); loadVectorIntoTree(vec, bst); for(std::size_t i=0; i<vec.size(); i++) { if( !bst->search(vec[i]) ) { isPassed = false; std::cerr << "ERROR: Search for " << vec[i] << " returned false after being added." << std::endl; } } printPassFail(isPassed); delete bst; return(isPassed); }
bool Test::test_clone02() { bool isPassed = true; BSTI<int>* original = new BinarySearchTree<int>(); BSTI<int>* copy = nullptr; std::vector<int> vec; m_testNum++; printTestMessage(m_testNum, "cloning a large tree, deleting original, searching for all values in copy"); uniqueRandomFill(vec, TEST_SIZE); loadVectorIntoTree(vec, original); copy = original->clone(); delete original; original = nullptr; for(std::size_t i=0; i<vec.size(); i++) { if( !copy->search(vec[i]) ) { isPassed = false; std::cerr << "ERROR: Search for " << vec[i] << " returned false after being added." << std::endl; } } printPassFail(isPassed); delete copy; copy = nullptr; return(isPassed); }
bool Test::test11() { Stack<int> stack; int num = 0; bool isPassed = true; printTestMessage(11, "print after lots of pushes retains order"); loadValues(stack); redirectOS(); ss_redirect.clear(); stack.print(); restoreOS(); //sizes will be printed in reverse, since you know, stacks. for(int i=TEST_SIZE-1; i>=0; i--) { ss_redirect >> num; if( i!=num ) { isPassed = false; } } printPassFail(isPassed); return(isPassed); }
bool Test_LinkedList::test16() { LinkedList<int> list; bool isPassed = false; int trackedSize = 0; printTestMessage("size preserved by removeBack on populated list"); //Remove front on every 3rd iteration, add otherwise. for(int i=0; i<TEST_SIZE; i++) { if( i>0 && i%3 == 0) { list.removeBack(); trackedSize--; } else { list.addBack(i); trackedSize++; } } isPassed = trackedSize == list.size(); printPassFail(isPassed); return (isPassed); }
bool Test::testBadFile(std::string testFileName, std::string testMessage) { bool isPassed = false; m_testNum++; printTestMessage(m_testNum, testMessage); if( isFileAccessible(testFileName) ) { try { MazeReader mr(testFileName); } catch(MazeCreationException& mce) { isPassed = true; } catch(...) { std::cerr << "ERROR: Exception thrown was not MazeCreationException" << std::endl; } } else { std::cerr << "ERROR " << testFileName << " not accessible. Place in lab folder." << std::endl; } printPassFail(isPassed); return(isPassed); }
bool Test::test_mazeWalker04() { bool isPassed = false; std::string testFileName = "noExit.txt"; const int correctRows = 6; const int correctCols = 6; int** correctArray = new int*[correctRows]; Search searchChoice = Search::BFS; correctArray[0] = new int[correctCols]{0, 0, 0, 0, 0, 1}; correctArray[1] = new int[correctCols]{11, 9, 7, 6, 4, 2}; correctArray[2] = new int[correctCols]{0, 0, 8, 0, 0, 3}; correctArray[3] = new int[correctCols]{14, 12, 10, 0, 0, 5}; correctArray[4] = new int[correctCols]{0, 13, 0, 0, 0, 0}; correctArray[5] = new int[correctCols]{0, 15, 16, 17, 18, 19}; m_testNum++; printTestMessage(m_testNum, "MazeWalker visits all reachable positions in noExit.txt in correct order using bfs"); isPassed = testWalker(testFileName, correctArray, correctRows, correctCols, searchChoice); printPassFail(isPassed); for(int i=0; i<correctRows; i++) { delete[] correctArray[i]; } delete[] correctArray; return(isPassed); }
bool Test::test_mazeWalker02() { bool isPassed = false; std::string testFileName = "maze.txt"; const int correctRows = 8; const int correctCols = 6; int** correctArray = new int*[correctRows]; Search searchChoice = Search::BFS; correctArray[0] = new int[correctCols]{16, 0, 0, 0, 0, 0}; correctArray[1] = new int[correctCols]{14, 12, 10, 11, 13, 15}; correctArray[2] = new int[correctCols]{0, 0, 9, 0, 0, 0}; correctArray[3] = new int[correctCols]{8, 6, 7, 0, 0, 0}; correctArray[4] = new int[correctCols]{0, 5, 0, 0, 0, 0}; correctArray[5] = new int[correctCols]{0, 4, 3, 2, 1, 0}; correctArray[6] = new int[correctCols]{0, 0, 0, 0, 0, 0}; correctArray[7] = new int[correctCols]{0, 0, 0, 0, 0, 0}; m_testNum++; printTestMessage(m_testNum, "MazeWalker finds exit in maze.txt in correct order using bfs"); isPassed = testWalker(testFileName, correctArray, correctRows, correctCols, searchChoice); printPassFail(isPassed); for(int i=0; i<correctRows; i++) { delete[] correctArray[i]; } delete[] correctArray; return(isPassed); }
bool Test_LinkedList::test7() { LinkedList<int> list; int trackedSize = 0; bool isPassed=false; printTestMessage("size returns correct value after adds and removeBack"); //Mix of adding to the front, back and removing back for(int i = 0; i < TEST_SIZE; i++) { if(i%2 == 0) { list.addBack(i); trackedSize++; } else if(i%3 == 0) { list.removeBack(); trackedSize--; } else { list.addFront(i); trackedSize++; } } isPassed = list.size() == trackedSize; printPassFail(isPassed); return (isPassed); }
bool Test::test_sort26() { bool isPassed = false; const int LOW = 0; const int HIGH = 5000; int* arr = Sorts<int>::createTestArray(TEST_SIZE, LOW, HIGH); double time = 0.0; m_testNum++; printTestMessage(m_testNum, "quickSortWithMedian sort completes in reasonable amount of time (0-2secs platform dependent) " + std::to_string(TEST_SIZE)); time = Sorts<int>::sortTimer(Sorts<int>::quickSortWithMedian, arr, TEST_SIZE); std::cerr << "\nTime for quickSortWithMedian sort on " + std::to_string(TEST_SIZE) + " elements: " << time << " "; if(time<0 || time>2) { isPassed = false; } else { isPassed = true; } delete[] arr; arr = nullptr; printPassFail(isPassed); return (isPassed); }
bool Test::test1() { Stack<int> stack; bool isPassed = stack.size() == 0; printTestMessage(1, "size of empty stack is zero"); printPassFail(isPassed); return (isPassed); }
bool Test_LinkedList::test8() { LinkedList<int> list; bool isPassed = false; printTestMessage("search returns false on empty list"); isPassed = !list.search(42); printPassFail(isPassed); return (isPassed); }
bool Test_LinkedList::test14() { LinkedList<int> list; bool isPassed = false; printTestMessage("removeBack returns false on empty list"); isPassed = !list.removeBack(); printPassFail(isPassed); return (isPassed); }
bool Test_LinkedList::test1() { LinkedList<int> list; bool isPassed = false; printTestMessage("size of empty list is zero"); isPassed = list.size() == 0; printPassFail(isPassed); return (list.size() == 0); }
bool Test::test2() { Stack<int> stack; bool isPassed=false; stack.push(1); printTestMessage(2, "size returns correct value after 1 push"); isPassed = stack.size() == 1; printPassFail(isPassed); return (isPassed); }
bool Test::test4() { bool isPassed = false; int arr[] = {31, 1, 0, 4, 1}; printTestMessage(4, "isSorted returns false when array is not sorted"); isPassed = Sorts<int>::isSorted(arr, 5) == false; printPassFail(isPassed); return (isPassed); }
bool Test::test5() { bool isPassed = false; int arr[] = {31,30,29,28,27}; printTestMessage(5, "isSorted returns false when array is sorted, but not ascending"); isPassed = Sorts<int>::isSorted(arr, 5) == false; printPassFail(isPassed); return (isPassed); }
bool Test::test6() { bool isPassed = false; int arr[] = {27,27,29,64,65}; printTestMessage(6, "isSorted returns true when array is sorted in ascending order"); isPassed = Sorts<int>::isSorted(arr, 5); printPassFail(isPassed); return (isPassed); }
bool Test_LinkedList::test11() { LinkedList<int> list; bool isPassed = false; std::vector<int> vec; printTestMessage("toVector returns empty vector for empty list"); vec = list.toVector(); isPassed = vec.empty(); printPassFail(isPassed); return (isPassed); }
bool Test::test7() { bool isPassed = false; int arr[] = {27}; printTestMessage(7, "bubble sort called with an array of size 1"); Sorts<int>::bubbleSort(arr, 1); isPassed = Sorts<int>::isSorted(arr,1); printPassFail(isPassed); return (isPassed); }
bool Test::test3() { bool isPassed = false; int* arr = nullptr; printTestMessage(3, "isSorted returns true when array size is 1"); isPassed = Sorts<int>::isSorted(arr, 1); printPassFail(isPassed); return (isPassed); }
bool Test::test3() { Stack<int> stack; bool isPassed = false; printTestMessage(3, "size returns correct value after lots of pushes"); loadValues(stack); isPassed = stack.size() == TEST_SIZE; printPassFail(isPassed); return(isPassed); }
bool Test::test10() { bool isPassed = false; int arr[] = {27}; printTestMessage(10, "bogo sort called with an array of size 1"); Sorts<int>::insertionSort(arr, 1); isPassed = Sorts<int>::isSorted(arr,1); printPassFail(isPassed); return (isPassed); }
bool Test::test_isEmpty01() { bool isPassed = false; BSTI<int>* bst = new BinarySearchTree<int>(); m_testNum++; printTestMessage(m_testNum, "isEmpty returns true on empty tree"); isPassed = bst->isEmpty(); printPassFail(isPassed); delete bst; return(isPassed); }
bool Test_LinkedList::test3() { LinkedList<int> list; bool isPassed = false; printTestMessage("size returns correct value after 1 addBack"); list.addBack(5); isPassed = list.size() == 1; printPassFail(isPassed); return(isPassed); }
bool Test::test_search01() { bool isPassed = false; BSTI<int>* bst = new BinarySearchTree<int>(); m_testNum++; printTestMessage(m_testNum, "searching an empty tree returns false"); isPassed = !bst->search(42); printPassFail(isPassed); delete bst; return(isPassed); }