Google Guava Collection Test Suite

By gamlerhart September 25, 2012 English, java

Did you even implement your own collections for some reason? Collections which implement the Java collection interfaces? Did you ever wonder if there is test suite for collections, which tests the specified collection-interface behavior? When your answer is yes to these questions then you should check out the Google Guava Testlib.

Testing Collections, Ahoi

The Google Guava Testlib brings a whole test suite which tests the behavior of Set, List and Map implementations. You can specify which features your collections support and then profit from the hundreds of tests Google has written for you.

Getting Started

First we need to get the library. The easiest way to get it is with Maven:

After that we can start to write a test suite. There are test-suite builders for this purpose, the most important ones are ListTestSuiteBuilder, SetTestSuiteBuilder and MapTestSuiteBuilder. These builder allow you to create a test-suite according to your needs.
First you specify the collection to be used and the test data with the using-method. Afterwards you can specify what features are implemented by your collection. Here’s an example:

private Test myListTestSuite() { return ListTestSuiteBuilder.using( // This class is responsible for creating the collection // And providing data, which can be put into the collection // Here we use a abstract generator which will create strings // which will be put into the collection new TestStringListGenerator(){ @Override protected List<String> create(String[] elements) { // Fill here your collection with the given elements return new MyListImplementation<String>(elements); } }) // The name of the test suite .named("My List Tests") // Here we give a hit what features our collection supports .withFeatures(ListFeature.GENERAL_PURPOSE, CollectionFeature.ALLOWS_NULL_VALUES, CollectionFeature.SERIALIZABLE, CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION, CollectionSize.ANY) .createTestSuite(); }

Take a good look into the available constants in CollectionFeature, ListFeature and MapFeature for the features sets to test.
Anyway, BAAAMM! Now I’ve already a huge suite of test running, which cover a lot of dirty details. For example my implementation seems to have issues with the equals method of the returned sub-lists:

Oh Oh

Setup/Tear-Down, Suppressing Tests

Now the actual tests do run in already written test classes. So what if your collection needs some setup- / tear down code? For example I use the test-suite to test collections which are backed up by a database. That means I need a setup- / tear down phase.
This can be done by providing a runnable for the setup and tear down:

return ListTestSuiteBuilder .using(new TestStringListGenerator(){ @Override protected List<String> create(String[] elements) { return new MyListImplementation<String>(elements); } }) .named("My List Tests") .withFeatures(ListFeature.GENERAL_PURPOSE, CollectionFeature.ALLOWS_NULL_VALUES, CollectionFeature.SERIALIZABLE, CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION, CollectionSize.ANY) .withSetUp(new Runnable() { @Override public void run() { // some setup } }) .withTearDown(new Runnable() { @Override public void run() { // some setup } }) .createTestSuite();

You also can suppress very specific methods of the test suite. This is done by giving the methods which should be suppressed:

// previous calls .suppressing(Arrays.asList(suppressMethod(ListSubListTester.class, "testSubList_entireList"))) .createTestSuite(); private Method suppressMethod(Class testClass, String methodName) { try { return testClass.getMethod(methodName, new Class[0]); } catch (NoSuchMethodException e) { throw new AssertionError("Could not find method to suppress ", e); } }

Your Own TestData

Perhaps your collection implementation can only hold very specialized elements. In that case you might need to generate the test-items yourself, which are added to the list. Instead of using the Google test data provider, you can use your own. Here’s an example, which tests the collection with a custom type:

// Pass your test data provider to the using method ListTestSuiteBuilder.using(new MyTestDataGenerator()) . // continue as normal /** * Own implementation of a test data generator. * First look if an existing one fits your needs */ class MyTestDataGenerator implements TestListGenerator<MySpecialItem> { @Override public SampleElements<MySpecialItem> samples() { return new SampleElements<MySpecialItem>( new MySpecialItem("1"), new MySpecialItem("2"), new MySpecialItem("3"), new MySpecialItem("4"), new MySpecialItem("5") ); } @Override public List<MySpecialItem> create(Object... elementsAsObjects) { // Put the elements in the given array // into the collection. MySpecialItem[] castedElements = new MySpecialItem[elementsAsObjects.length]; int i = 0; for (Object elementAsObject : elementsAsObjects) { castedElements[i++] = (MySpecialItem) elementAsObject; } return new MyListImplementation<MySpecialItem>((MySpecialItem[])castedElements); } @Override public MySpecialItem[] createArray(int length) { // Just create an array of the element type with the given length return new MySpecialItem[length]; } @Override public Iterable<MySpecialItem> order(List<MySpecialItem> insertionOrder) { // In case your collection reorders elements, // Then you should return the original order here return insertionOrder; } } // Let's assume our collection only can handle specialized items class MySpecialItem implements Serializable{ private final String data; MySpecialItem(String data) { this.data = data; } @Override public String toString() { return "MySpecialItem{" + "data='" + data + '\'' + '}'; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; MySpecialItem that = (MySpecialItem) o; if (data != null ? !data.equals(that.data) : that.data != null) return false; return true; } @Override public int hashCode() { return data != null ? data.hashCode() : 0; } }

Other Types

Above I’ve shown examples for a List implementation. For Sets and Maps it works more or less exactly the same way. Instead of ListSomeThingSomething the classes are called SetSomethingSomething or MapSomethingSomething. Otherwise the same principals apply.

Conclusion

If you ever implement your own Java collections, take a look at the Guava Test lib. It saves you a ton of work!

Tagged on: guava, java, test

Gamlor

thoughts about programming, tv-series and other geeky stuff.