Skip to content

Commit f8ee412

Browse files
sirchiasirchia
authored
Fix serialization of AssumptionViolatedException (#1654)
Added serializable descriptions of values and matchers and use them in writeObject() serialization of AssumptionViolatedException. Fixes #1192
1 parent de77f66 commit f8ee412

6 files changed

+225
-0
lines changed

‎src/main/java/org/junit/internal/AssumptionViolatedException.java

+28
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
package org.junit.internal;
22

3+
import java.io.IOException;
4+
import java.io.ObjectOutputStream;
5+
36
import org.hamcrest.Description;
47
import org.hamcrest.Matcher;
58
import org.hamcrest.SelfDescribing;
@@ -108,4 +111,29 @@ public void describeTo(Description description) {
108111
}
109112
}
110113
}
114+
115+
/**
116+
* Override default Java object serialization to correctly deal with potentially unserializable matchers or values.
117+
* By not implementing readObject, we assure ourselves of backwards compatibility and compatibility with the
118+
* standard way of Java serialization.
119+
*
120+
* @param objectOutputStream The outputStream to write our representation to
121+
* @throws IOException When serialization fails
122+
*/
123+
private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
124+
ObjectOutputStream.PutField putField = objectOutputStream.putFields();
125+
putField.put("fAssumption", fAssumption);
126+
putField.put("fValueMatcher", fValueMatcher);
127+
128+
// We have to wrap the matcher into a serializable form.
129+
putField.put("fMatcher", SerializableMatcherDescription.asSerializableMatcher(fMatcher));
130+
131+
// We have to wrap the value inside a non-String class (instead of serializing the String value directly) as
132+
// A Description will handle a String and non-String object differently (1st is surrounded by '"' while the
133+
// latter will be surrounded by '<' '>'. Wrapping it makes sure that the description of a serialized and
134+
// non-serialized instance produce the exact same description
135+
putField.put("fValue", SerializableValueDescription.asSerializableValue(fValue));
136+
137+
objectOutputStream.writeFields();
138+
}
111139
}

‎src/main/java/org/junit/internal/SerializableMatcherDescription.java

+47
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
package org.junit.internal;
2+
3+
import java.io.Serializable;
4+
5+
import org.hamcrest.BaseMatcher;
6+
import org.hamcrest.Description;
7+
import org.hamcrest.Matcher;
8+
import org.hamcrest.StringDescription;
9+
10+
/**
11+
* This class exists solely to provide a serializable description of a matcher to be serialized as a field in
12+
* {@link AssumptionViolatedException}. Being a {@link Throwable}, it is required to be {@link Serializable}, but most
13+
* implementations of {@link Matcher} are not. This class works around that limitation as
14+
* {@link AssumptionViolatedException} only every uses the description of the {@link Matcher}, while still retaining
15+
* backwards compatibility with classes compiled against its class signature before 4.14 and/or deserialization of
16+
* previously serialized instances.
17+
*/
18+
class SerializableMatcherDescription<T> extends BaseMatcher<T> implements Serializable {
19+
20+
private final String matcherDescription;
21+
22+
private SerializableMatcherDescription(Matcher<T> matcher) {
23+
matcherDescription = StringDescription.asString(matcher);
24+
}
25+
26+
public boolean matches(Object o) {
27+
throw new UnsupportedOperationException("This Matcher implementation only captures the description");
28+
}
29+
30+
public void describeTo(Description description) {
31+
description.appendText(matcherDescription);
32+
}
33+
34+
/**
35+
* Factory method that checks to see if the matcher is already serializable.
36+
* @param matcher the matcher to make serializable
37+
* @return The provided matcher if it is null or already serializable,
38+
* the SerializableMatcherDescription representation of it if it is not.
39+
*/
40+
static <T> Matcher<T> asSerializableMatcher(Matcher<T> matcher) {
41+
if (matcher == null || matcher instanceof Serializable) {
42+
return matcher;
43+
} else {
44+
return new SerializableMatcherDescription<T>(matcher);
45+
}
46+
}
47+
}

‎src/main/java/org/junit/internal/SerializableValueDescription.java

+38
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
package org.junit.internal;
2+
3+
import java.io.Serializable;
4+
5+
/**
6+
* This class exists solely to provide a serializable description of a value to be serialized as a field in
7+
* {@link AssumptionViolatedException}. Being a {@link Throwable}, it is required to be {@link Serializable}, but a
8+
* value of type Object provides no guarantee to be serializable. This class works around that limitation as
9+
* {@link AssumptionViolatedException} only every uses the string representation of the value, while still retaining
10+
* backwards compatibility with classes compiled against its class signature before 4.14 and/or deserialization of
11+
* previously serialized instances.
12+
*/
13+
class SerializableValueDescription implements Serializable {
14+
private final String value;
15+
16+
private SerializableValueDescription(Object value) {
17+
this.value = String.valueOf(value);
18+
}
19+
20+
/**
21+
* Factory method that checks to see if the value is already serializable.
22+
* @param value the value to make serializable
23+
* @return The provided value if it is null or already serializable,
24+
* the SerializableValueDescription representation of it if it is not.
25+
*/
26+
static Object asSerializableValue(Object value) {
27+
if (value == null || value instanceof Serializable) {
28+
return value;
29+
} else {
30+
return new SerializableValueDescription(value);
31+
}
32+
}
33+
34+
@Override
35+
public String toString() {
36+
return value;
37+
}
38+
}

‎src/test/java/org/junit/AssumptionViolatedExceptionTest.java

+112
Original file line numberDiff line numberDiff line change
@@ -4,12 +4,27 @@
44
import static org.hamcrest.CoreMatchers.is;
55
import static org.hamcrest.CoreMatchers.notNullValue;
66
import static org.hamcrest.MatcherAssert.assertThat;
7+
import static org.hamcrest.core.IsNot.not;
8+
import static org.junit.Assert.assertEquals;
9+
import static org.junit.Assert.assertNotNull;
710
import static org.junit.Assume.assumeThat;
11+
12+
import java.io.ByteArrayInputStream;
13+
import java.io.ByteArrayOutputStream;
14+
import java.io.IOException;
15+
import java.io.InputStream;
16+
import java.io.ObjectInputStream;
17+
import java.io.ObjectOutputStream;
18+
import java.io.Serializable;
19+
20+
import org.hamcrest.BaseMatcher;
21+
import org.hamcrest.Description;
822
import org.hamcrest.Matcher;
923
import org.hamcrest.StringDescription;
1024
import org.junit.experimental.theories.DataPoint;
1125
import org.junit.experimental.theories.Theories;
1226
import org.junit.experimental.theories.Theory;
27+
import org.junit.rules.TestName;
1328
import org.junit.runner.RunWith;
1429

1530
@RunWith(Theories.class)
@@ -23,6 +38,14 @@ public class AssumptionViolatedExceptionTest {
2338
@DataPoint
2439
public static Matcher<Integer> NULL = null;
2540

41+
@Rule
42+
public TestName name = new TestName();
43+
44+
private static final String MESSAGE = "Assumption message";
45+
private static Matcher<Integer> SERIALIZABLE_IS_THREE = new SerializableIsThreeMatcher<Integer>();
46+
private static final UnserializableClass UNSERIALIZABLE_VALUE = new UnserializableClass();
47+
private static final Matcher<UnserializableClass> UNSERIALIZABLE_MATCHER = not(is(UNSERIALIZABLE_VALUE));
48+
2649
@Theory
2750
public void toStringReportsMatcher(Integer actual, Matcher<Integer> matcher) {
2851
assumeThat(matcher, notNullValue());
@@ -92,4 +115,93 @@ public void canSetCauseWithInstanceCreatedWithExplicitThrowableConstructor() {
92115
AssumptionViolatedException e = new AssumptionViolatedException("invalid number", cause);
93116
assertThat(e.getCause(), is(cause));
94117
}
118+
119+
@Test
120+
public void assumptionViolatedExceptionWithoutValueAndMatcherCanBeReserialized_v4_13()
121+
throws IOException, ClassNotFoundException {
122+
assertReserializable(new AssumptionViolatedException(MESSAGE));
123+
}
124+
125+
@Test
126+
public void assumptionViolatedExceptionWithValueAndMatcherCanBeReserialized_v4_13()
127+
throws IOException, ClassNotFoundException {
128+
assertReserializable(new AssumptionViolatedException(MESSAGE, TWO, SERIALIZABLE_IS_THREE));
129+
}
130+
131+
@Test
132+
public void unserializableValueAndMatcherCanBeSerialized() throws IOException, ClassNotFoundException {
133+
AssumptionViolatedException exception = new AssumptionViolatedException(MESSAGE,
134+
UNSERIALIZABLE_VALUE, UNSERIALIZABLE_MATCHER);
135+
136+
assertCanBeSerialized(exception);
137+
}
138+
139+
@Test
140+
public void nullValueAndMatcherCanBeSerialized() throws IOException, ClassNotFoundException {
141+
AssumptionViolatedException exception = new AssumptionViolatedException(MESSAGE);
142+
143+
assertCanBeSerialized(exception);
144+
}
145+
146+
@Test
147+
public void serializableValueAndMatcherCanBeSerialized() throws IOException, ClassNotFoundException {
148+
AssumptionViolatedException exception = new AssumptionViolatedException(MESSAGE,
149+
TWO, SERIALIZABLE_IS_THREE);
150+
151+
assertCanBeSerialized(exception);
152+
}
153+
154+
private void assertCanBeSerialized(AssumptionViolatedException exception)
155+
throws IOException, ClassNotFoundException {
156+
ByteArrayOutputStream baos = new ByteArrayOutputStream();
157+
ObjectOutputStream oos = new ObjectOutputStream(baos);
158+
oos.writeObject(exception);
159+
160+
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
161+
ObjectInputStream ois = new ObjectInputStream(bais);
162+
AssumptionViolatedException fromStream = (AssumptionViolatedException) ois.readObject();
163+
164+
assertSerializedCorrectly(exception, fromStream);
165+
}
166+
167+
private void assertReserializable(AssumptionViolatedException expected)
168+
throws IOException, ClassNotFoundException {
169+
String resourceName = name.getMethodName();
170+
InputStream resource = getClass().getResourceAsStream(resourceName);
171+
assertNotNull("Could not read resource " + resourceName, resource);
172+
ObjectInputStream objectInputStream = new ObjectInputStream(resource);
173+
AssumptionViolatedException fromStream = (AssumptionViolatedException) objectInputStream.readObject();
174+
175+
assertSerializedCorrectly(expected, fromStream);
176+
}
177+
178+
private void assertSerializedCorrectly(
179+
AssumptionViolatedException expected, AssumptionViolatedException fromStream) {
180+
assertNotNull(fromStream);
181+
182+
// Exceptions don't implement equals() so we need to compare field by field
183+
assertEquals("message", expected.getMessage(), fromStream.getMessage());
184+
assertEquals("description", StringDescription.asString(expected), StringDescription.asString(fromStream));
185+
// We don't check the stackTrace as that will be influenced by how the test was started
186+
// (e.g. by maven or directly from IDE)
187+
// We also don't check the cause as that should already be serialized correctly by the superclass
188+
}
189+
190+
private static class SerializableIsThreeMatcher<T> extends BaseMatcher<T> implements Serializable {
191+
192+
public boolean matches(Object item) {
193+
return IS_THREE.matches(item);
194+
}
195+
196+
public void describeTo(Description description) {
197+
IS_THREE.describeTo(description);
198+
}
199+
}
200+
201+
private static class UnserializableClass {
202+
@Override
203+
public String toString() {
204+
return "I'm not serializable";
205+
}
206+
}
95207
}

‎src/test/resources/org/junit/assumptionViolatedExceptionWithValueAndMatcherCanBeReserialized_v4_13

3.71 KB
Binary file not shown.

‎src/test/resources/org/junit/assumptionViolatedExceptionWithoutValueAndMatcherCanBeReserialized_v4_13

3.55 KB
Binary file not shown.

0 commit comments

Comments
 (0)