Skip to content

Commit dd5a60a

Browse files
author
Alex Klymenko
committed
tests: Adding more various tests cases for testing sorting algorithms
1 parent 30d3486 commit dd5a60a

File tree

1 file changed

+202
-0
lines changed

1 file changed

+202
-0
lines changed

‎src/test/java/com/thealgorithms/sorts/SortingAlgorithmTest.java

Lines changed: 202 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,16 @@
11
package com.thealgorithms.sorts;
22

33
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
4+
import static org.junit.jupiter.api.Assertions.assertEquals;
45
import static org.junit.jupiter.api.Assertions.assertIterableEquals;
6+
import static org.junit.jupiter.api.Assertions.assertThrows;
57
import static org.junit.jupiter.api.Assertions.assertTrue;
68

79
import java.util.ArrayList;
10+
import java.util.Arrays;
811
import java.util.List;
12+
import java.util.Objects;
13+
914
import org.junit.jupiter.api.Test;
1015

1116
public abstract class SortingAlgorithmTest {
@@ -171,4 +176,201 @@ void shouldAcceptWhenRandomListIsPassed() {
171176
List<Double> sorted = getSortAlgorithm().sort(list);
172177
assertTrue(SortUtils.isSorted(sorted));
173178
}
179+
180+
@Test
181+
public void shouldAcceptWhenArrayWithAllIdenticalValuesIsPassed() {
182+
Integer[] array = {1, 1, 1, 1};
183+
Integer[] sortedArray = getSortAlgorithm().sort(array);
184+
assertArrayEquals(new Integer[]{1, 1, 1, 1}, sortedArray);
185+
}
186+
187+
@Test
188+
public void shouldAcceptWhenListWithAllIdenticalValuesIsPassed() {
189+
List<Integer> list = Arrays.asList(1, 1, 1, 1);
190+
List<Integer> sortedList = getSortAlgorithm().sort(list);
191+
assertEquals(Arrays.asList(1, 1, 1, 1), sortedList);
192+
}
193+
194+
@Test
195+
public void shouldAcceptWhenArrayWithMixedPositiveAndNegativeValuesIsPassed() {
196+
Integer[] array = {-1, 3, -2, 5, 0};
197+
Integer[] sortedArray = getSortAlgorithm().sort(array);
198+
assertArrayEquals(new Integer[]{-2, -1, 0, 3, 5}, sortedArray);
199+
}
200+
201+
@Test
202+
public void shouldAcceptWhenListWithMixedPositiveAndNegativeValuesIsPassed() {
203+
List<Integer> list = Arrays.asList(-1, 3, -2, 5, 0);
204+
List<Integer> sortedList = getSortAlgorithm().sort(list);
205+
assertEquals(Arrays.asList(-2, -1, 0, 3, 5), sortedList);
206+
}
207+
208+
@Test
209+
public void shouldAcceptWhenArrayWithLargeNumbersIsPassed() {
210+
Long[] array = {10000000000L, 9999999999L, 10000000001L};
211+
Long[] sortedArray = getSortAlgorithm().sort(array);
212+
assertArrayEquals(new Long[]{9999999999L, 10000000000L, 10000000001L}, sortedArray);
213+
}
214+
215+
@Test
216+
public void shouldAcceptWhenListWithLargeNumbersIsPassed() {
217+
List<Long> list = Arrays.asList(10000000000L, 9999999999L, 10000000001L);
218+
List<Long> sortedList = getSortAlgorithm().sort(list);
219+
assertEquals(Arrays.asList(9999999999L, 10000000000L, 10000000001L), sortedList);
220+
}
221+
222+
@Test
223+
public void shouldAcceptWhenArrayWithMaxIntegerValuesIsPassed() {
224+
Integer[] array = {Integer.MAX_VALUE, Integer.MIN_VALUE, 0};
225+
Integer[] sortedArray = getSortAlgorithm().sort(array);
226+
assertArrayEquals(new Integer[]{Integer.MIN_VALUE, 0, Integer.MAX_VALUE}, sortedArray);
227+
}
228+
229+
@Test
230+
public void shouldAcceptWhenListWithMaxIntegerValuesIsPassed() {
231+
List<Integer> list = Arrays.asList(Integer.MAX_VALUE, Integer.MIN_VALUE, 0);
232+
List<Integer> sortedList = getSortAlgorithm().sort(list);
233+
assertEquals(Arrays.asList(Integer.MIN_VALUE, 0, Integer.MAX_VALUE), sortedList);
234+
}
235+
236+
@Test
237+
public void shouldAcceptWhenArrayWithMinIntegerValuesIsPassed() {
238+
Integer[] array = {Integer.MIN_VALUE, Integer.MAX_VALUE, 0};
239+
Integer[] sortedArray = getSortAlgorithm().sort(array);
240+
assertArrayEquals(new Integer[]{Integer.MIN_VALUE, 0, Integer.MAX_VALUE}, sortedArray);
241+
}
242+
243+
@Test
244+
public void shouldAcceptWhenListWithMinIntegerValuesIsPassed() {
245+
List<Integer> list = Arrays.asList(Integer.MIN_VALUE, Integer.MAX_VALUE, 0);
246+
List<Integer> sortedList = getSortAlgorithm().sort(list);
247+
assertEquals(Arrays.asList(Integer.MIN_VALUE, 0, Integer.MAX_VALUE), sortedList);
248+
}
249+
250+
@Test
251+
public void shouldAcceptWhenArrayWithSpecialCharactersIsPassed() {
252+
String[] array = {"!", "@", "#", "$"};
253+
String[] sortedArray = getSortAlgorithm().sort(array);
254+
assertArrayEquals(new String[]{"!", "#", "$", "@"}, sortedArray);
255+
}
256+
257+
@Test
258+
public void shouldAcceptWhenListWithSpecialCharactersIsPassed() {
259+
List<String> list = Arrays.asList("!", "@", "#", "$");
260+
List<String> sortedList = getSortAlgorithm().sort(list);
261+
assertEquals(Arrays.asList("!", "#", "$", "@"), sortedList);
262+
}
263+
264+
@Test
265+
public void shouldAcceptWhenArrayWithMixedCaseStringsIsPassed() {
266+
String[] array = {"apple", "Banana", "cherry", "Date"};
267+
String[] sortedArray = getSortAlgorithm().sort(array);
268+
assertArrayEquals(new String[]{"Banana", "Date", "apple", "cherry"}, sortedArray);
269+
}
270+
271+
@Test
272+
public void shouldAcceptWhenListWithMixedCaseStringsIsPassed() {
273+
List<String> list = Arrays.asList("apple", "Banana", "cherry", "Date");
274+
List<String> sortedList = getSortAlgorithm().sort(list);
275+
assertEquals(Arrays.asList("Banana", "Date", "apple", "cherry"), sortedList);
276+
}
277+
278+
@Test
279+
public void shouldHandleArrayWithNullValues() {
280+
Integer[] array = {3, null, 2, null, 1};
281+
assertThrows(NullPointerException.class, () -> getSortAlgorithm().sort(array));
282+
}
283+
284+
@Test
285+
public void shouldHandleListWithNullValues() {
286+
List<Integer> list = Arrays.asList(3, null, 2, null, 1);
287+
assertThrows(NullPointerException.class, () -> getSortAlgorithm().sort(list));
288+
}
289+
290+
@Test
291+
public void shouldHandleArrayOfBooleanValues() {
292+
Boolean[] array = {true, false, true, false};
293+
Boolean[] sortedArray = getSortAlgorithm().sort(array);
294+
assertArrayEquals(new Boolean[]{false, false, true, true}, sortedArray);
295+
}
296+
297+
@Test
298+
public void shouldHandleListOfBooleanValues() {
299+
List<Boolean> list = Arrays.asList(true, false, true, false);
300+
List<Boolean> sortedList = getSortAlgorithm().sort(list);
301+
assertEquals(Arrays.asList(false, false, true, true), sortedList);
302+
}
303+
304+
static class CustomObject implements Comparable<CustomObject> {
305+
int value;
306+
307+
CustomObject(int value) {
308+
this.value = value;
309+
}
310+
311+
@Override
312+
public int compareTo(CustomObject o) {
313+
return Integer.compare(this.value, o.value);
314+
}
315+
316+
@Override
317+
public String toString() {
318+
return "CustomObject{" + "value=" + value + '}';
319+
}
320+
321+
@Override
322+
public boolean equals(Object o) {
323+
if (this == o) return true;
324+
if (o == null || getClass() != o.getClass()) return false;
325+
CustomObject that = (CustomObject) o;
326+
return value == that.value;
327+
}
328+
329+
@Override
330+
public int hashCode() {
331+
return Objects.hashCode(value);
332+
}
333+
}
334+
335+
@Test
336+
public void shouldHandleArrayOfCustomObjects() {
337+
CustomObject[] array = {new CustomObject(3), new CustomObject(1), new CustomObject(2)};
338+
CustomObject[] sortedArray = getSortAlgorithm().sort(array);
339+
assertArrayEquals(new CustomObject[]{new CustomObject(1), new CustomObject(2), new CustomObject(3)}, sortedArray);
340+
}
341+
342+
@Test
343+
public void shouldHandleListOfCustomObjects() {
344+
List<CustomObject> list = Arrays.asList(new CustomObject(3), new CustomObject(1), new CustomObject(2));
345+
List<CustomObject> sortedList = getSortAlgorithm().sort(list);
346+
assertEquals(Arrays.asList(new CustomObject(1), new CustomObject(2), new CustomObject(3)), sortedList);
347+
}
348+
349+
@Test
350+
public void shouldHandleArrayOfFloatingPointNumbers() {
351+
Double[] array = {3.3, 2.2, 1.1, Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY};
352+
Double[] sortedArray = getSortAlgorithm().sort(array);
353+
assertArrayEquals(new Double[]{Double.NEGATIVE_INFINITY, 1.1, 2.2, 3.3, Double.POSITIVE_INFINITY, Double.NaN}, sortedArray);
354+
}
355+
356+
@Test
357+
public void shouldHandleListOfFloatingPointNumbers() {
358+
List<Double> list = Arrays.asList(3.3, 2.2, 1.1, Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY);
359+
List<Double> sortedList = getSortAlgorithm().sort(list);
360+
assertEquals(Arrays.asList(Double.NEGATIVE_INFINITY, 1.1, 2.2, 3.3, Double.POSITIVE_INFINITY, Double.NaN), sortedList);
361+
}
362+
363+
@Test
364+
public void shouldHandleArrayWithEmptyStrings() {
365+
String[] array = {"apple", "", "banana", ""};
366+
String[] sortedArray = getSortAlgorithm().sort(array);
367+
assertArrayEquals(new String[]{"", "", "apple", "banana"}, sortedArray);
368+
}
369+
370+
@Test
371+
public void shouldHandleListWithEmptyStrings() {
372+
List<String> list = Arrays.asList("apple", "", "banana", "");
373+
List<String> sortedList = getSortAlgorithm().sort(list);
374+
assertEquals(Arrays.asList("", "", "apple", "banana"), sortedList);
375+
}
174376
}

0 commit comments

Comments
 (0)