In this post, I am going to show you how to use the Java Collections API to help you both randomize and sort data so that it is more easily testable. Testable code leads to code that is easier to maintain. This will improve the longevity of any project.
Recently, I implemented a sorting algorithm in my application. This was a critical component in my application. I found it appropriate to write JUnit tests to validate the business logic. I was very happy with my implementation. Therefore, I thought I would share it with the world. Enjoy!
Pro Tip
It may be a bad code smell if you cannot set up, identity, and verify expected results for a given method. This may imply that your code is not easily testable. This can lead to unmaintainable and erroneous code. More advanced examples may require additional mocking of dependencies. Higher-level code may benefit more from integration testing.
Implement Comparable
First, I write a class that implements the Comparable interface:
public class SortableObj implements Comparable<SortableObj> {
@Override
public int compareTo(SortableObj b) {
}
}
Setup / Test
Then, I setup a test with expected vs actual results. After my objects are composed properly, I call a method to test my setup:
@Test
public void firstSortScenario() {
// setup test
SortableObj first = new SortableObj();
// do some decoration
SortableObj second = new SortableObj();
// do some decoration
SortableObj third = new SortableObj();
// do some decoration
SortableObj fourth = new SortableObj();
// do some decoration
List<SortableObj> expected = Arrays.asList(first, second, third, fourth);
List<SortableObj> actual = Arrays.asList(fourth, third, first, second);
// test
shuffleTest(expected, actual);
}
Validate/Assert
Finally, I use the Collections API to shuffle the actual list, sort it, and assert that it is equal to the expected list. This should cover edge cases where the order of the list affects the integrity of the sort.
private void shuffleTest(List<SortableObj> expected, List<SortableObj> actual) {
for(int i=0;i<10;i++) {
Collections.shuffle(actual);
Collections.sort(actual);
assertThat(actual).isEqualTo(expected);
}
}
Conclusion
This is the format I use for all my tests. I set up some data, call the method that is under test, and then validate expected vs actual results. You should be able to apply this methodology to all unit tests. Calling shuffle helped put me at ease that I did not miss any odd edge cases based on the order of the original list.
Resources:
Junit
Mockito
