| package junit.tests.runner; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.util.List; |
| |
| import junit.framework.TestCase; |
| import junit.tests.framework.Success; |
| import org.junit.Test; |
| import org.junit.runner.JUnitCore; |
| import org.junit.runner.Result; |
| import org.junit.runner.notification.Failure; |
| import org.junit.tests.running.methods.AnnotationTest; |
| |
| public class ResultTest extends TestCase { |
| |
| private Result fromStream; |
| |
| public void testRunFailureResultCanBeSerialised() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| Result result = runner.run(AnnotationTest.FailureTest.class); |
| assertResultSerializable(result); |
| } |
| |
| public void testRunFailureResultCanBeReserialised_v4_12() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| Result result = runner.run(AnnotationTest.FailureTest.class); |
| assertResultReserializable(result, SerializationFormat.V4_12); |
| } |
| |
| public void testRunAssumptionFailedResultCanBeSerialised() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| Result result = runner.run(AssumptionFailedTest.class); |
| assertResultSerializable(result); |
| } |
| |
| public void testRunAssumptionFailedResultCanBeReserialised_v4_12() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| Result result = runner.run(AssumptionFailedTest.class); |
| assertResultReserializable(result, SerializationFormat.V4_12); |
| } |
| |
| public void testRunAssumptionFailedResultCanBeReserialised_v4_13() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| Result result = runner.run(AssumptionFailedTest.class); |
| assertResultReserializable(result, SerializationFormat.V4_13); |
| } |
| |
| public void testRunSuccessResultCanBeSerialised() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| Result result = runner.run(Success.class); |
| assertResultSerializable(result); |
| } |
| |
| public void testRunSuccessResultCanBeReserialised_v4_12() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| Result result = runner.run(Success.class); |
| assertResultReserializable(result, SerializationFormat.V4_12); |
| } |
| |
| public void testRunSuccessResultCanBeReserialised_v4_13() throws Exception { |
| JUnitCore runner = new JUnitCore(); |
| Result result = runner.run(Success.class); |
| assertResultReserializable(result, SerializationFormat.V4_13); |
| } |
| |
| private enum SerializationFormat { |
| V4_12, |
| V4_13 |
| } |
| |
| private void assertResultSerializable(Result result) throws IOException, ClassNotFoundException { |
| ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); |
| ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream); |
| objectOutputStream.writeObject(result); |
| objectOutputStream.flush(); |
| byte[] bytes = byteArrayOutputStream.toByteArray(); |
| ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(bytes)); |
| Result fromStream = (Result) objectInputStream.readObject(); |
| assertSerializedCorrectly(result, fromStream, SerializationFormat.V4_13); |
| } |
| |
| private void assertResultReserializable(Result result, SerializationFormat resourceSerializationFormat) |
| throws IOException, ClassNotFoundException { |
| String resourceName = getName(); |
| InputStream resource = getClass().getResourceAsStream(resourceName); |
| assertNotNull("Could not read resource " + resourceName, resource); |
| ObjectInputStream objectInputStream = new ObjectInputStream(resource); |
| fromStream = (Result) objectInputStream.readObject(); |
| |
| assertSerializedCorrectly(new ResultWithFixedRunTime(result), |
| fromStream, resourceSerializationFormat); |
| } |
| |
| public static class AssumptionFailedTest { |
| @Test |
| public void assumptionFailed() throws Exception { |
| org.junit.Assume.assumeTrue(false); |
| } |
| } |
| |
| /** |
| * A version of {@code Result} that returns a hard-coded runtime. |
| * This makes values returned by the methods deterministic. |
| */ |
| private static class ResultWithFixedRunTime extends Result { |
| |
| private static final long serialVersionUID = 1L; |
| |
| private final Result delegate; |
| |
| public ResultWithFixedRunTime(Result delegate) { |
| this.delegate = delegate; |
| } |
| |
| @Override |
| public int getRunCount() { |
| return delegate.getRunCount(); |
| } |
| |
| @Override |
| public int getFailureCount() { |
| return delegate.getFailureCount(); |
| } |
| |
| @Override |
| public long getRunTime() { |
| return 2; |
| } |
| |
| @Override |
| public List<Failure> getFailures() { |
| return delegate.getFailures(); |
| } |
| |
| @Override |
| public int getIgnoreCount() { |
| return delegate.getIgnoreCount(); |
| } |
| |
| @Override |
| public int getAssumptionFailureCount() { |
| return delegate.getAssumptionFailureCount(); |
| } |
| } |
| |
| private void assertSerializedCorrectly( |
| Result result, Result fromStream, SerializationFormat serializationFormat) { |
| assertNotNull(fromStream); |
| |
| // Exceptions don't implement equals() so we need to compare field by field |
| assertEquals("failureCount", result.getFailureCount(), fromStream.getFailureCount()); |
| assertEquals("ignoreCount", result.getIgnoreCount(), fromStream.getIgnoreCount()); |
| |
| if (serializationFormat == SerializationFormat.V4_13) { |
| // assumption failures are serialized |
| assertEquals("assumptionFailureCount", |
| result.getAssumptionFailureCount(), |
| fromStream.getAssumptionFailureCount()); |
| } else { |
| // assumption failures were not serialized |
| try { |
| fromStream.getAssumptionFailureCount(); |
| fail("UnsupportedOperationException expected"); |
| } catch (UnsupportedOperationException expected) { |
| } |
| } |
| |
| assertEquals("runTime", result.getRunTime(), fromStream.getRunTime()); |
| assertEquals("failures", result.getFailures().size(), fromStream.getFailures().size()); |
| int index = 0; |
| for (Failure failure : result.getFailures()) { |
| Failure failureFromStream = fromStream.getFailures().get(index); |
| String messagePrefix = String.format("failures[%d]", index++); |
| assertEquals(messagePrefix + ".description", |
| failure.getDescription(), failureFromStream.getDescription()); |
| Throwable exception = failure.getException(); |
| Throwable exceptionFromStream = failureFromStream.getException(); |
| assertEquals(messagePrefix + ".exception", |
| exception.getClass(), exceptionFromStream.getClass()); |
| assertEquals(messagePrefix + ".exception", |
| exception.getMessage(), exceptionFromStream.getMessage()); |
| } |
| } |
| } |