TEST_F(SortingTest, ShouldReturnAscendingSortedIfAlreadyDescending) { Sorting sorting; vector<int> sorted = sorting.selectionSort(desAges); ASSERT_EQ(10, sorted.front()); ASSERT_EQ(30, sorted.back()); }
TEST_F(SortingTest, ShouldReturnTheSameOrderIfAlreadySorted) { Sorting sorting; vector<int> sorted = sorting.selectionSort(ascAges); ASSERT_EQ(sorted.front(), ascAges.front()); ASSERT_EQ(sorted.back(), ascAges.back()); }
TEST_F(SortingTest, ShouldReturnSortedIfNotSorted) { Sorting sorting; vector<int> sorted = sorting.selectionSort(randAges); ASSERT_EQ(10, sorted.front()); ASSERT_EQ(30, sorted.back()); }
TEST_F(SortingTest, ShouldReturnSortedForLargeGroupOfNumber) { Sorting sorting; vector<int> actual = sorting.selectionSort(lrgAges); for (int idx = 0; idx < lrgAges.size(); idx++) { ASSERT_EQ(sortedLrgAges.at(idx), actual.at(idx)); } }
/* * This function prints the Averages from the tests after running through all the tests. * * int max_size = maximum size that we want to test each sorting algorithm to * int min_size = minimum size that we want to test each sorting algorithm to * string theSort = string that contains tha name of the sorting algorithm we are testing. * * Worst-Case Time Complexity: Θ(n^2 + n^2 + n^2 + n^2) = Θ(n^2) */ void testing(int min_size, int max_size, string algorithm){ // making sure I know what the size of each tests I'm doing const int& tests = 5; const int& test_size = 10; // making sure each size of the array is a set value const int& array_size = 10; // average cpu_time arrays for each data set float* increasing_array_averages = new float[array_size]; float* decreasing_array_averages = new float[array_size]; float* random_array_averages = new float[array_size]; float* constant_array_averages = new float[array_size]; std::cout << "\nIncreasing Array using " << algorithm << std::endl; // run 10 size instances (10000, 20000, 30000, etc.) for (int i = 0; i < test_size; i++){ std::cout << max_size << " instances." << std::endl; // instantiate average value and sum value to zero on every new test. float average = 0.0; float sum = 0.0; // create new cpu_times array on every new test. float* cpu_times = new float[5]; // run five tests for (int j = min_size; j < tests; j++){ // set time to 0 before running the cpu times float time = 0.0; // instantiate new array for increasing ordered array. int* increasingArray = ag.generateIncreasingArray(max_size); if (algorithm == "insertionSort"){ clock_t c_start = clock(); s.insertionSort(increasingArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else if (algorithm == "bubbleSort"){ clock_t c_start = clock(); s.bubbleSort(increasingArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else if (algorithm == "quickSort"){ clock_t c_start = clock(); s.quickSort(increasingArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else if (algorithm == "mergeSort"){ clock_t c_start = clock(); s.mergeSort(increasingArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else { clock_t c_start = clock(); s.selectionSort(increasingArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } //std::cout << "CPU Time (IncreasingArray): " << fixed << setprecision(3) << time << " ms." << std::endl; std::cout << fixed << setprecision(3) << time << " ms" << std::endl; // add cpu time to cpu_times array cpu_times[j] = time; // delete array at the end of each run to avoid memory leaks and faulty data delete[] increasingArray; } // add up the cpu_times values for (int j = 0; j < 5; j++){ sum += cpu_times[j]; } // find average value average = sum / 5.0; //std::cout << "Average time (" << max_size << " instances): " << average << "ms.\n" << std::endl; std::cout << fixed << setprecision(3) << average << " ms\n" << std::endl; // add average value to increasing_array_averages array per number of runs increasing_array_averages[i] = average; // once we pass our last instance (100000) break. if (max_size == 100000){ break; } // go to the next instance (10000 to 20000) max_size += 10000; // delete cpu_times array to avoid memory leaks or faulty data delete[] cpu_times; } // start max_size back at 10000 max_size = 10000; std::cout << "\nDecreasing Array using " << algorithm << std::endl; // run 10 size instances (10000, 20000, 30000, etc.) for (int i = min_size; i < test_size; i++){ std::cout << max_size << " instances." << std::endl; // instantiate average value and sum value to zero on every new test. float average = 0.0; float sum = 0.0; // create new cpu_times array on every new test. float* cpu_times = new float[5]; // run five tests for (int j = min_size; j < tests; j++){ // set time to 0 before running the cpu times float time = 0.0; // instantiate new decreasing order array every run. int* decreasingArray = ag.generateDecreasingArray(max_size); if (algorithm == "insertionSort"){ clock_t c_start = clock(); s.insertionSort(decreasingArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else if (algorithm == "bubbleSort"){ clock_t c_start = clock(); s.bubbleSort(decreasingArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else if (algorithm == "quickSort"){ clock_t c_start = clock(); s.quickSort(decreasingArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else if (algorithm == "mergeSort"){ clock_t c_start = clock(); s.mergeSort(decreasingArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else { clock_t c_start = clock(); s.selectionSort(decreasingArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } //std::cout << "CPU Time (DecreasingArray): " << fixed << setprecision(3) << time << " ms." << std::endl; std::cout << fixed << setprecision(3) << time << " ms" << std::endl; // add cpu time to cpu_times array cpu_times[j] = time; // delete array at the end of each run to avoid memory leaks and faulty data delete[] decreasingArray; } // add up the cpu_times values for (int j = 0; j < 5; j++){ sum += cpu_times[j]; } // find average value average = sum / 5.0; //std::cout << "Average time (" << max_size << " instances): " << fixed << setprecision(3) << average << "ms.\n" << std::endl; std::cout << fixed << setprecision(3) << average << " ms\n" << std::endl; // add average value to decreasing_array_averages array per number of runs decreasing_array_averages[i] = average; // once we pass our last instance (100000) break. if (max_size == 100000){ break; } // go to the next instance (10000 to 20000) max_size += 10000; // delete cpu_times array to avoid memory leaks or faulty data delete[] cpu_times; } // start max_size back at 10000 max_size = 10000; std::cout << "\nRandom Array using " << algorithm << std::endl; // run 10 size instances (10000, 20000, 30000, etc.) for (int i = min_size; i < test_size; i++){ std::cout << max_size << " instances." << std::endl; // instantiate average value and sum value to zero on every new test. float average = 0.0; float sum = 0.0; // create new cpu_times array on every new test. float* cpu_times = new float[5]; // run five tests for (int j = min_size; j < tests; j++){ // set time to 0 before running the cpu times float time = 0.0; // instantiate new random order array every run. int* randomArray = ag.generateRandomArray(max_size); if (algorithm == "insertionSort"){ clock_t c_start = clock(); s.insertionSort(randomArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else if (algorithm == "bubbleSort"){ clock_t c_start = clock(); s.bubbleSort(randomArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else if (algorithm == "quickSort"){ clock_t c_start = clock(); s.quickSort(randomArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else if (algorithm == "mergeSort"){ clock_t c_start = clock(); s.mergeSort(randomArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else { clock_t c_start = clock(); s.selectionSort(randomArray, max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } //std::cout << "CPU Time (RandomArray): " << fixed << setprecision(3) << time << " ms." << std::endl; std::cout << fixed << setprecision(3) << time << " ms" << std::endl; // add cpu time to cpu_times array cpu_times[j] = time; // delete array at the end of each run to avoid memory leaks and faulty data delete[] randomArray; } // add up the cpu_times values for (int j = 0; j < 5; j++){ sum += cpu_times[j]; } // find average value average = sum / 5.0; //std::cout << "Average time (" << max_size << " instances): " << fixed << setprecision(3) << average << "ms.\n" << std::endl; std::cout << fixed << setprecision(3) << average << " ms\n" << std::endl; // add average value to random_array_averages array per number of runs random_array_averages[i] = average; // once we pass our last instance (100000) break. if (max_size == 100000){ break; } // go to the next instance (10000 to 20000) max_size += 10000; // delete cpu_times array to avoid memory leaks or faulty data delete[] cpu_times; } // start max_size back at 10000 max_size = 10000; std::cout << "\nConstant Array using " << algorithm << std::endl; // run 10 size instances (10000, 20000, 30000, etc.) for (int i = 0; i < test_size; i++){ std::cout << max_size << " instances." << std::endl; // instantiate average value and sum value to zero on every new test. float average = 0.0; float sum = 0.0; // create new cpu_times array on every new test. float* cpu_times = new float[5]; // run five tests for (int j = 0; j < 5; j++){ // set time to 0 before running the cpu times float time = 0.0; if (algorithm == "insertionSort"){ clock_t c_start = clock(); s.insertionSort(ag.generateConstArray("Awesome", max_size), max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else if (algorithm == "bubbleSort"){ clock_t c_start = clock(); s.bubbleSort(ag.generateConstArray("Awesome", max_size), max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else if (algorithm == "quickSort"){ clock_t c_start = clock(); s.quickSort(ag.generateConstArray("Awesome", max_size), max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else if (algorithm == "mergeSort"){ clock_t c_start = clock(); s.mergeSort(ag.generateConstArray("Awesome", max_size), max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } else { clock_t c_start = clock(); s.selectionSort(ag.generateConstArray("Awesome", max_size), max_size); clock_t c_end = clock(); time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC; } //std::cout << "CPU Time (ConstantArray): " << fixed << setprecision(3) << time << " ms." << std::endl; std::cout << fixed << setprecision(3) << time << " ms" << std::endl; // add cpu time to cpu_times array cpu_times[j] = time; // delete array at the end of each run to avoid memory leaks and faulty data delete[] ag.generateConstArray("Awesome", max_size); } // add up the cpu_times values for (int j = 0; j < 5; j++){ sum += cpu_times[j]; } // find average value average = sum / 5.0; //std::cout << "Average time (" << max_size << " instances): " << fixed << setprecision(3) << average << " ms.\n" << std::endl; std::cout << fixed << setprecision(3) << average << " ms\n" << std::endl; // add average value to constant_array_averages array per number of runs constant_array_averages[i] = average; // once we pass our last instance (100000) break. if (max_size == 100000){ break; } // go to the next instance (10000 to 20000) max_size += 10000; // delete cpu_times array to avoid memory leaks or faulty data delete[] cpu_times; } // print averages of each array generated. printAverages(increasing_array_averages, decreasing_array_averages, random_array_averages, constant_array_averages, array_size, algorithm); // delete each array we used to hold specific (generated arrays) of averages from each test. delete[] constant_array_averages; delete[] random_array_averages; delete[] decreasing_array_averages; delete[] increasing_array_averages; }