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::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_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::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);
}