Merge pull request #994 from marcphilipp/serialization-compatibility

David Saff · David Saff · commit c2f2a8c11487 · 2014-09-24T12:57:25.000-04:00
Ensure serialization compatibility where possible
diff --git a/src/main/java/org/junit/ComparisonFailure.java b/src/main/java/org/junit/ComparisonFailure.java
@@ -18,8 +18,13 @@ public class ComparisonFailure extends AssertionError {
     private static final int MAX_CONTEXT_LENGTH = 20;
     private static final long serialVersionUID = 1L;
 
-    private String expected;
-    private String actual;
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit/issues/976
+     */
+    private String fExpected;
+    private String fActual;
 
     /**
      * Constructs a comparison failure.
@@ -30,8 +35,8 @@ public class ComparisonFailure extends AssertionError {
      */
     public ComparisonFailure(String message, String expected, String actual) {
         super(message);
-        this.expected = expected;
-        this.actual = actual;
+        this.fExpected = expected;
+        this.fActual = actual;
     }
 
     /**
@@ -41,7 +46,7 @@ public ComparisonFailure(String message, String expected, String actual) {
      */
     @Override
     public String getMessage() {
-        return new ComparisonCompactor(MAX_CONTEXT_LENGTH, expected, actual).compact(super.getMessage());
+        return new ComparisonCompactor(MAX_CONTEXT_LENGTH, fExpected, fActual).compact(super.getMessage());
     }
 
     /**
@@ -50,7 +55,7 @@ public String getMessage() {
      * @return the actual string value
      */
     public String getActual() {
-        return actual;
+        return fActual;
     }
 
     /**
@@ -59,7 +64,7 @@ public String getActual() {
      * @return the expected string value
      */
     public String getExpected() {
-        return expected;
+        return fExpected;
     }
 
     private static class ComparisonCompactor {
diff --git a/src/main/java/org/junit/experimental/max/MaxHistory.java b/src/main/java/org/junit/experimental/max/MaxHistory.java
@@ -61,41 +61,44 @@ private static MaxHistory readHistory(File storedResults)
         }
     }
 
-    private final Map<String, Long> durations = new HashMap<String, Long>();
-
-    private final Map<String, Long> failureTimestamps = new HashMap<String, Long>();
-
-    private final File historyStore;
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit/issues/976
+     */
+    private final Map<String, Long> fDurations = new HashMap<String, Long>();
+    private final Map<String, Long> fFailureTimestamps = new HashMap<String, Long>();
+    private final File fHistoryStore;
 
     private MaxHistory(File storedResults) {
-        historyStore = storedResults;
+        fHistoryStore = storedResults;
     }
 
     private void save() throws IOException {
         ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream(
-                historyStore));
+                fHistoryStore));
         stream.writeObject(this);
         stream.close();
     }
 
     Long getFailureTimestamp(Description key) {
-        return failureTimestamps.get(key.toString());
+        return fFailureTimestamps.get(key.toString());
     }
 
     void putTestFailureTimestamp(Description key, long end) {
-        failureTimestamps.put(key.toString(), end);
+        fFailureTimestamps.put(key.toString(), end);
     }
 
     boolean isNewTest(Description key) {
-        return !durations.containsKey(key.toString());
+        return !fDurations.containsKey(key.toString());
     }
 
     Long getTestDuration(Description key) {
-        return durations.get(key.toString());
+        return fDurations.get(key.toString());
     }
 
     void putTestDuration(Description description, long duration) {
-        durations.put(description.toString(), duration);
+        fDurations.put(description.toString(), duration);
     }
 
     private final class RememberingListener extends RunListener {
diff --git a/src/main/java/org/junit/internal/ArrayComparisonFailure.java b/src/main/java/org/junit/internal/ArrayComparisonFailure.java
@@ -14,8 +14,13 @@ public class ArrayComparisonFailure extends AssertionError {
 
     private static final long serialVersionUID = 1L;
 
-    private final List<Integer> indices = new ArrayList<Integer>();
-    private final String message;
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit/issues/976
+     */
+    private final List<Integer> fIndices = new ArrayList<Integer>();
+    private final String fMessage;
 
     /**
      * Construct a new <code>ArrayComparisonFailure</code> with an error text and the array's
@@ -26,23 +31,23 @@ public class ArrayComparisonFailure extends AssertionError {
      * @see Assert#assertArrayEquals(String, Object[], Object[])
      */
     public ArrayComparisonFailure(String message, AssertionError cause, int index) {
-        this.message = message;
+        this.fMessage = message;
         initCause(cause);
         addDimension(index);
     }
 
     public void addDimension(int index) {
-        indices.add(0, index);
+        fIndices.add(0, index);
     }
 
     @Override
     public String getMessage() {
         StringBuilder sb = new StringBuilder();
-        if (message != null) {
-            sb.append(message);
+        if (fMessage != null) {
+            sb.append(fMessage);
         }
         sb.append("arrays first differed at element ");
-        for (int each : indices) {
+        for (int each : fIndices) {
             sb.append("[");
             sb.append(each);
             sb.append("]");
diff --git a/src/main/java/org/junit/internal/AssumptionViolatedException.java b/src/main/java/org/junit/internal/AssumptionViolatedException.java
@@ -18,18 +18,21 @@
 public class AssumptionViolatedException extends RuntimeException implements SelfDescribing {
     private static final long serialVersionUID = 2L;
 
-    private final String assumption;
-
-    private final boolean valueMatcher;
-    private final Object value;
-
-    private final Matcher<?> matcher;
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit/issues/976
+     */
+    private final String fAssumption;
+    private final boolean fValueMatcher;
+    private final Object fValue;
+    private final Matcher<?> fMatcher;
 
     public AssumptionViolatedException(String assumption, boolean valueMatcher, Object value, Matcher<?> matcher) {
-        this.assumption = assumption;
-        this.value = value;
-        this.matcher = matcher;
-        this.valueMatcher = valueMatcher;
+        this.fAssumption = assumption;
+        this.fValue = value;
+        this.fMatcher = matcher;
+        this.fValueMatcher = valueMatcher;
 
         if (value instanceof Throwable) {
           initCause((Throwable) value);
@@ -72,21 +75,21 @@ public String getMessage() {
     }
 
     public void describeTo(Description description) {
-        if (assumption != null) {
-            description.appendText(assumption);
+        if (fAssumption != null) {
+            description.appendText(fAssumption);
         }
 
-        if (valueMatcher) {
-            if (assumption != null) {
+        if (fValueMatcher) {
+            if (fAssumption != null) {
                 description.appendText(": ");
             }
 
             description.appendText("got: ");
-            description.appendValue(value);
+            description.appendValue(fValue);
 
-            if (matcher != null) {
+            if (fMatcher != null) {
                 description.appendText(", expected: ");
-                description.appendDescriptionOf(matcher);
+                description.appendDescriptionOf(fMatcher);
             }
         }
     }
diff --git a/src/main/java/org/junit/internal/runners/InitializationError.java b/src/main/java/org/junit/internal/runners/InitializationError.java
@@ -11,10 +11,16 @@
 @Deprecated
 public class InitializationError extends Exception {
     private static final long serialVersionUID = 1L;
-    private final List<Throwable> errors;
+
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit/issues/976
+     */
+    private final List<Throwable> fErrors;
 
     public InitializationError(List<Throwable> errors) {
-        this.errors = errors;
+        this.fErrors = errors;
     }
 
     public InitializationError(Throwable... errors) {
@@ -26,6 +32,6 @@ public InitializationError(String string) {
     }
 
     public List<Throwable> getCauses() {
-        return errors;
+        return fErrors;
     }
 }
diff --git a/src/main/java/org/junit/runner/Description.java b/src/main/java/org/junit/runner/Description.java
@@ -136,11 +136,16 @@ public static Description createSuiteDescription(Class<?> testClass) {
      */
     public static final Description TEST_MECHANISM = new Description(null, "Test mechanism");
 
-    private final Collection<Description> children = new ConcurrentLinkedQueue<Description>();
-    private final String displayName;
-    private final Serializable uniqueId;
-    private final Annotation[] annotations;
-    private volatile /* write-once */ Class<?> testClass;
+    /*
+     * We have to use the f prefix until the next major release to ensure
+     * serialization compatibility. 
+     * See https://github.com/junit-team/junit/issues/976
+     */
+    private final Collection<Description> fChildren = new ConcurrentLinkedQueue<Description>();
+    private final String fDisplayName;
+    private final Serializable fUniqueId;
+    private final Annotation[] fAnnotations;
+    private volatile /* write-once */ Class<?> fTestClass;
 
     private Description(Class<?> clazz, String displayName, Annotation... annotations) {
         this(clazz, displayName, displayName, annotations);
@@ -155,17 +160,17 @@ private Description(Class<?> testClass, String displayName, Serializable uniqueI
             throw new IllegalArgumentException(
                     "The unique id must not be null.");
         }
-        this.testClass = testClass;
-        this.displayName = displayName;
-        this.uniqueId = uniqueId;
-        this.annotations = annotations;
+        this.fTestClass = testClass;
+        this.fDisplayName = displayName;
+        this.fUniqueId = uniqueId;
+        this.fAnnotations = annotations;
     }
 
     /**
      * @return a user-understandable label
      */
     public String getDisplayName() {
-        return displayName;
+        return fDisplayName;
     }
 
     /**
@@ -174,15 +179,15 @@ public String getDisplayName() {
      * @param description the soon-to-be child.
      */
     public void addChild(Description description) {
-        children.add(description);
+        fChildren.add(description);
     }
 
     /**
      * Gets the copy of the children of this {@code Description}.
      * Returns an empty list if there are no children.
      */
     public ArrayList<Description> getChildren() {
-        return new ArrayList<Description>(children);
+        return new ArrayList<Description>(fChildren);
     }
 
     /**
@@ -196,7 +201,7 @@ public boolean isSuite() {
      * @return <code>true</code> if the receiver is an atomic test
      */
     public boolean isTest() {
-        return children.isEmpty();
+        return fChildren.isEmpty();
     }
 
     /**
@@ -207,15 +212,15 @@ public int testCount() {
             return 1;
         }
         int result = 0;
-        for (Description child : children) {
+        for (Description child : fChildren) {
             result += child.testCount();
         }
         return result;
     }
 
     @Override
     public int hashCode() {
-        return uniqueId.hashCode();
+        return fUniqueId.hashCode();
     }
 
     @Override
@@ -224,7 +229,7 @@ public boolean equals(Object obj) {
             return false;
         }
         Description d = (Description) obj;
-        return uniqueId.equals(d.uniqueId);
+        return fUniqueId.equals(d.fUniqueId);
     }
 
     @Override
@@ -244,15 +249,15 @@ public boolean isEmpty() {
      *         children will be added back)
      */
     public Description childlessCopy() {
-        return new Description(testClass, displayName, annotations);
+        return new Description(fTestClass, fDisplayName, fAnnotations);
     }
 
     /**
      * @return the annotation of type annotationType that is attached to this description node,
      *         or null if none exists
      */
     public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
-        for (Annotation each : annotations) {
+        for (Annotation each : fAnnotations) {
             if (each.annotationType().equals(annotationType)) {
                 return annotationType.cast(each);
             }
@@ -264,24 +269,24 @@ public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
      * @return all of the annotations attached to this description node
      */
     public Collection<Annotation> getAnnotations() {
-        return Arrays.asList(annotations);
+        return Arrays.asList(fAnnotations);
     }
 
     /**
      * @return If this describes a method invocation,
      *         the class of the test instance.
      */
     public Class<?> getTestClass() {
-        if (testClass != null) {
-            return testClass;
+        if (fTestClass != null) {
+            return fTestClass;
         }
         String name = getClassName();
         if (name == null) {
             return null;
         }
         try {
-            testClass = Class.forName(name, false, getClass().getClassLoader());
-            return testClass;
+            fTestClass = Class.forName(name, false, getClass().getClassLoader());
+            return fTestClass;
         } catch (ClassNotFoundException e) {
             return null;
         }
@@ -292,7 +297,7 @@ public Class<?> getTestClass() {
      *         the name of the class of the test instance
      */
     public String getClassName() {
-        return testClass != null ? testClass.getName() : methodAndClassNamePatternGroupOrDefault(2, toString());
+        return fTestClass != null ? fTestClass.getName() : methodAndClassNamePatternGroupOrDefault(2, toString());
     }
 
     /**
diff --git a/src/main/java/org/junit/runner/notification/Failure.java b/src/main/java/org/junit/runner/notification/Failure.java
diff --git a/src/main/java/org/junit/runners/model/InitializationError.java b/src/main/java/org/junit/runners/model/InitializationError.java
diff --git a/src/main/java/org/junit/runners/model/MultipleFailureException.java b/src/main/java/org/junit/runners/model/MultipleFailureException.java

Original file line number	Diff line number	Diff line change
`@@ -61,41 +61,44 @@ private static MaxHistory readHistory(File storedResults)`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`64`		`- private final Map<String, Long> durations = new HashMap<String, Long>();`
`65`		`-`
`66`		`- private final Map<String, Long> failureTimestamps = new HashMap<String, Long>();`
`67`		`-`
`68`		`- private final File historyStore;`
	`64`	`+ /*`
	`65`	`+ * We have to use the f prefix until the next major release to ensure`
	`66`	`+ * serialization compatibility.`
	`67`	`+ * See https://github.com/junit-team/junit/issues/976`
	`68`	`+ */`
	`69`	`+ private final Map<String, Long> fDurations = new HashMap<String, Long>();`
	`70`	`+ private final Map<String, Long> fFailureTimestamps = new HashMap<String, Long>();`
	`71`	`+ private final File fHistoryStore;`
`69`	`72`
`70`	`73`	`private MaxHistory(File storedResults) {`
`71`		`- historyStore = storedResults;`
	`74`	`+ fHistoryStore = storedResults;`
`72`	`75`	`}`
`73`	`76`
`74`	`77`	`private void save() throws IOException {`
`75`	`78`	`ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream(`
`76`		`- historyStore));`
	`79`	`+ fHistoryStore));`
`77`	`80`	`stream.writeObject(this);`
`78`	`81`	`stream.close();`
`79`	`82`	`}`
`80`	`83`
`81`	`84`	`Long getFailureTimestamp(Description key) {`
`82`		`- return failureTimestamps.get(key.toString());`
	`85`	`+ return fFailureTimestamps.get(key.toString());`
`83`	`86`	`}`
`84`	`87`
`85`	`88`	`void putTestFailureTimestamp(Description key, long end) {`
`86`		`- failureTimestamps.put(key.toString(), end);`
	`89`	`+ fFailureTimestamps.put(key.toString(), end);`
`87`	`90`	`}`
`88`	`91`
`89`	`92`	`boolean isNewTest(Description key) {`
`90`		`- return !durations.containsKey(key.toString());`
	`93`	`+ return !fDurations.containsKey(key.toString());`
`91`	`94`	`}`
`92`	`95`
`93`	`96`	`Long getTestDuration(Description key) {`
`94`		`- return durations.get(key.toString());`
	`97`	`+ return fDurations.get(key.toString());`
`95`	`98`	`}`
`96`	`99`
`97`	`100`	`void putTestDuration(Description description, long duration) {`
`98`		`- durations.put(description.toString(), duration);`
	`101`	`+ fDurations.put(description.toString(), duration);`
`99`	`102`	`}`
`100`	`103`
`101`	`104`	`private final class RememberingListener extends RunListener {`
Original file line number	Diff line number	Diff line change
`@@ -11,10 +11,16 @@`
`11`	`11`	`@Deprecated`
`12`	`12`	`public class InitializationError extends Exception {`
`13`	`13`	`private static final long serialVersionUID = 1L;`
`14`		`- private final List<Throwable> errors;`
	`14`	`+`
	`15`	`+ /*`
	`16`	`+ * We have to use the f prefix until the next major release to ensure`
	`17`	`+ * serialization compatibility.`
	`18`	`+ * See https://github.com/junit-team/junit/issues/976`
	`19`	`+ */`
	`20`	`+ private final List<Throwable> fErrors;`
`15`	`21`
`16`	`22`	`public InitializationError(List<Throwable> errors) {`
`17`		`- this.errors = errors;`
	`23`	`+ this.fErrors = errors;`
`18`	`24`	`}`
`19`	`25`
`20`	`26`	`public InitializationError(Throwable... errors) {`
`@@ -26,6 +32,6 @@ public InitializationError(String string) {`
`26`	`32`	`}`
`27`	`33`
`28`	`34`	`public List<Throwable> getCauses() {`
`29`		`- return errors;`
	`35`	`+ return fErrors;`
`30`	`36`	`}`
`31`	`37`	`}`