jdk/test/java/lang/Throwable/StackTraceSerialization.java

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2000, 2001, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.

@@ -24,45 +24,82 @@
 import java.io.*;
 import java.util.*;
 
 /*
  * @test
- * @bug     4202914 4363318
+ * @bug     4202914 4363318 6991528
  * @summary Basic test of serialization of stack trace information
  * @author  Josh Bloch
  */
 
 public class StackTraceSerialization {
     public static void main(String args[]) throws Exception {
+        testWithSetStackTrace();
+        testWithFillInStackTrace();
+    }
+
+    private static void testWithSetStackTrace() {
+        Throwable t = new Throwable();
+        t.setStackTrace(null); // Immutable and empty stack
+        assertEmptyStackTrace(t);
+
+        t.fillInStackTrace();
+        // Verify fillInStackTrace is now a no-op.
+        assertEmptyStackTrace(t);
+
+        t.setStackTrace(new StackTrace[] {new StackTraceElement("foo", "bar", "baz", -1)});
+        assertEmptyStackTrace(t);
+
+        if (!equal(t, reconstitute(t)))
+            throw new Exception("Unequal Throwables with set stacktrace");
+    }
+
+    private static void assertEmptyStackTrace(Throwable t) {
+        if (t.getStackTrace.length != 0)
+            throw new AssertionError("Nonempty stacktrace.");
+    }
+
+    private static void testWithFillInStackTrace() {
         Throwable original = null;
         try {
             a();
         } catch(HighLevelException e) {
             original = e;
         }
 
+        if (!equal(original, reconstitute(original)))
+            throw new Exception("Unequal Throwables with filled-in stacktrace");
+    }
+
+    
+    /**
+     * Serialize the argument and return the deserialized result.
+     */
+    private static Throwable reconstitute(Throwable t) {
+        Throwable result = null;
         ByteArrayOutputStream bout = new ByteArrayOutputStream();
         ObjectOutputStream out = new ObjectOutputStream(bout);
-        out.writeObject(original);
+        out.writeObject(t);
         out.flush();
         ByteArrayInputStream bin =
             new ByteArrayInputStream(bout.toByteArray());
-        ObjectInputStream in = new ObjectInputStream(bin);
-        Throwable clone = (Throwable) in.readObject();
-
-        if (!equal(original, clone))
-            throw new Exception();
+o        ObjectInputStream in = new ObjectInputStream(bin);
+        result = (Throwable) in.readObject();
+        return result;
     }
 
     /**
-     * Returns true if e1 and e2 have equal stack traces and their causes
-     * are recursively equal (by the same definition).  Returns false
-     * or throws NullPointerExeption otherwise.
+     * Returns true if e1 and e2 have equal stack traces and their
+     * causes are recursively equal (by the same definition) and their
+     * suppressed exception information is equals.  Returns false or
+     * throws NullPointerExeption otherwise.
      */
     private static boolean equal(Throwable t1, Throwable t2) {
-        return t1==t2 || (Arrays.equals(t1.getStackTrace(), t2.getStackTrace())
-                          && equal(t1.getCause(), t2.getCause()));
+        return t1==t2 ||
+            (Arrays.equals(t1.getStackTrace(), t2.getStackTrace()) &&
+             equal(t1.getCause(), t2.getCause()) &&
+             Objects.equals(t1.getSuppressed(), t2.getSuppressed()));
     }
 
     static void a() throws HighLevelException {
         try {
             b();