-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathTestAlgorithms.java
More file actions
150 lines (126 loc) · 3.44 KB
/
Copy pathTestAlgorithms.java
File metadata and controls
150 lines (126 loc) · 3.44 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
package ru;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import ru.algorithms.*;
import static org.junit.jupiter.api.Assertions.*;
import java.time.Duration;
import java.time.Instant;
import java.util.Arrays;
import java.util.concurrent.ThreadLocalRandom;
/**
* Class for util methods for sorting tests
*/
@DisplayName("Sorting tests")
public class TestAlgorithms {
/**
* Size of an arrays
*/
public static final int ARRAY_LEN = 100_000;
/**
* Bound for generation of test arrays
*/
public static final int GENERATION_BOUND = 1_000_000;
/**
* Randomly generated array
*/
public static Integer[] generatedArray;
/**
* Sorted array
*/
public static Integer[] sortedArray;
/**
* Procedure of generating arrays
*/
@BeforeAll
static void generateArrays() {
generatedArray = generateArray();
sortedArray = Arrays.copyOf(generatedArray, ARRAY_LEN);
Arrays.sort(sortedArray);
}
/**
* Method for generating an array of Integers
*
* @return generated array
*/
public static Integer[] generateArray() {
ThreadLocalRandom random = ThreadLocalRandom.current();
Integer[] generatedArray = new Integer[ARRAY_LEN];
for (int i = 0; i < ARRAY_LEN; i++)
generatedArray[i] = random.nextInt(GENERATION_BOUND);
return generatedArray;
}
/**
* Procedure for testing
*
* @param sorter current sorting algorithm
*/
public void sortTest(Sorter<Integer> sorter) {
Integer[] arrayForSort = Arrays.copyOf(generatedArray, ARRAY_LEN);
Instant startTime = Instant.now();
sorter.sort(arrayForSort);
Instant endTime = Instant.now();
assertArrayEquals(arrayForSort, sortedArray);
System.out.println("Sorting method time: " + (Duration.between(startTime, endTime).toMillis()) + " milliseconds.");
}
@Test
@DisplayName("Bubble Sort test")
void testBubbleSort() {
sortTest(new BubbleSort<>());
}
@Test
@DisplayName("Cocktail Shaker Sort test")
void testCocktailShakerSort() {
sortTest(new CocktailShakerSort<>());
}
@Test
@DisplayName("Selection Sort test")
void testSelectionSort() {
sortTest(new SelectionSort<>());
}
@Test
@DisplayName("Merge Sort test")
void testMergeSort() {
sortTest(new MergeSort<>());
}
@Test
@DisplayName("Heap Sort test")
void testHeapSort() {
sortTest(new HeapSort<>());
}
@Test
@DisplayName("Insertion Sort test")
void testInsertionSort() {
sortTest(new InsertionSort<>());
}
@Test
@DisplayName("Odd-even Sort test")
void testOddEvenSort() {
sortTest(new OddEvenSort<>());
}
@Test
@DisplayName("Comb Sort test")
void testCombSort() {
sortTest(new CombSort<>());
}
@Test
@DisplayName("Shell Sort test")
void testShellSort() {
sortTest(new ShellSort<>());
}
@Test
@DisplayName("Binary Insertion Sort test")
void testBinaryInsertionSort() {
sortTest(new BinaryInsertionSort<>());
}
@Test
@DisplayName("Cycle Sort test")
void testCycleSort() {
sortTest(new CycleSort<>());
}
@Test
@DisplayName("Gnome Sort test")
void testGnomeSort() {
sortTest(new GnomeSort<>());
}
}