I want to write unit tests for a parser and would like to check that it correctly throws an exception for all input strings in a list. Now as I understand it, the standard approach with JUnit would be to write a separate test method for each case:
public final class ParseFailureTest1 {
@Test(expected = ParseException.class)
public void testParseFailure1() throws Exception {
Parser.parse("[1 2]"); // Missing comma
}
@Test(expected = ParseException.class)
public void testParseFailure2() throws Exception {
Parser.parse("[1, 2,]"); // Additional commas
}
}
But as I want to apply the same test to 20 or 50 different strings, it seems impractical.
An alternative would be to explicitly check for an exception with a catch
block:
public final class ParseFailureTest2 {
@Test
public void testParseFailure() throws Exception {
List<String> documents = Arrays.asList(
"[1 2]", // Missing comma
"[1, 2,]"); // Additional commas
for (String document : documents) {
try {
Parser.parse(document);
throw new AssertionError("Exception was not thrown");
} catch (ParseException e) {
// Expected, do nothing.
}
}
}
}
But this is error prone and I won't get any information about which exception was expected and if a different exception was thrown, it would count as a test error and not a failure.
My solution would be to use a method similar to expectException
below:
public final class ParseFailureTest3 {
@Test
public void testParseFailure() throws Exception {
List<String> documents = Arrays.asList(
"[1 2]", // Missing comma
"[1, 2,]"); // Additional commas
for (final String document : documents) {
expectException(ParseException.class, new TestRunnable() {
@Override
public void run() throws Throwable {
Parser.parse(document);
}
});
}
}
public static void expectException(Class<? extends Throwable> expected, TestRunnable test) {
try {
test.run();
} catch (Throwable e) {
if (e.getClass() == expected) {
return; // Expected, do nothing.
} else {
throw new AssertionError(String.format("Wrong exception was thrown: %s instead of %s", e.getClass(), expected), e);
}
}
throw new AssertionError(String.format("Expected exception was not thrown: %s", expected));
}
public interface TestRunnable {
void run() throws Throwable;
}
}
Is there a method for that purpose in the JUnit framework or a related library or would you suggest a different approach (or one of my rejected approaches) to the problem?
Use JUnit4 for Parameterized test feature. The following code should work.
import java.util.Arrays;
import java.util.Collection;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
@RunWith(value = Parameterized.class)
public class ParseTest {
private String parseValue;
public ParseTest(String parseValue) {
this.parseValue = parseValue;
}
@Parameters
public static Collection<Object[]> data() {
Object[][] data = new Object[][] { { "[1 2]" }, { "[1,2,]" } };
return Arrays.asList(data);
}
@Test(expected = ParseException.class)
public void testParseFailure1() throws Exception {
Parse.parse(parseValue);
}
}
For more info refer http://www.mkyong.com/unittest/junit-4-tutorial-6-parameterized-test/
Use the fail()
method:
@Test
public void testParseFailure() throws Exception {
List<String> documents = Arrays.asList(
"[1 2]", // Missing comma
"[1, 2,]"); // Additional commas
for (String document : documents) {
try {
Parser.parse(document);
fail("Parsing " + document + " should have thrown a ParseException");
}
catch (ParseException e) {
// Expected, do nothing.
}
}
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With