test/java/lang/Throwable/StackTraceSerialization.java

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2011, 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,66 +24,79 @@
 import java.io.*;
 import java.util.*;
 
 /*
  * @test
- * @bug     4202914 4363318 6991528
+ * @bug     4202914 4363318 6991528 6998871
  * @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() throws Exception {
+    private static void testWithSetStackTrace() {
+        StackTraceElement[] stackTrace = {new StackTraceElement("foo", "bar", "baz", -1)};
+
         Throwable t = new Throwable();
+        t.setStackTrace(null); // Immutable and empty stack
+        assertEmptyStackTrace(t);
+
+        // Verify fillInStackTrace is now a no-op.
+        t.fillInStackTrace();
+        assertEmptyStackTrace(t);
 
-        t.setStackTrace(new StackTraceElement[]
-            {new StackTraceElement("foo", "bar", "baz", -1)});
+        t.setStackTrace(stackTrace);
+        assertEmptyStackTrace(t);
 
         if (!equal(t, reconstitute(t)))
-            throw new Exception("Unequal Throwables with set stacktrace");
+            throw new RuntimeException("Unequal Throwables with set stacktrace");
+
+        Throwable t2 = new Throwable();
+        t2.setStackTrace(stackTrace);
+        if (!equal(t2, reconstitute(t2)))
+            throw new RuntimeException("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() throws Exception {
+    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");
+            throw new RuntimeException("Unequal Throwables with filled-in stacktrace");
     }
 
-
     /**
      * Serialize the argument and return the deserialized result.
      */
-    private static Throwable reconstitute(Throwable t) throws Exception {
+    private static Throwable reconstitute(Throwable t) {
         Throwable result = null;
-
         try(ByteArrayOutputStream bout = new ByteArrayOutputStream();
             ObjectOutputStream out = new ObjectOutputStream(bout)) {
             out.writeObject(t);
             out.flush();
             try(ByteArrayInputStream bin =
                 new ByteArrayInputStream(bout.toByteArray());
                 ObjectInputStream in = new ObjectInputStream(bin)) {
                 result = (Throwable) in.readObject();
             }
+        } catch(IOException | ClassNotFoundException e) {
+            throw new RuntimeException(e);
         }
-
         return result;
     }
 
     /**
      * Returns true if e1 and e2 have equal stack traces and their