Adding support for suppressed exceptions to Throwables.getTrimmedStackTrace().

PiperOrigin-RevId: 745694342

Author: copybara-androidxtest

services/CHANGELOG.md

@@ -10,6 +10,8 @@
 
 **New Features**
 
+* StackTrimmer now reports suppressed exceptions
+
 **Breaking Changes**
 
 **API Changes**

services/events/java/androidx/test/services/events/internal/Throwables.java

@@ -1,3 +1,18 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package androidx.test.services.events.internal;
 
 import java.io.BufferedReader;
@@ -35,6 +50,8 @@ public static String getTrimmedStackTrace(Throwable exception) {
 
     StringBuilder result = new StringBuilder(exception.toString());
     appendStackTraceLines(trimmedStackTraceLines, result);
+    // Throwable.lockedPrintStackTrace prints suppressed exceptions before it prints the cause.
+    appendStackTraceLines(getSuppressedStackTraceLines(exception), result);
     appendStackTraceLines(getCauseStackTraceLines(exception), result);
     return result.toString();
   }
@@ -63,6 +80,27 @@ private static List<String> getTrimmedStackTraceLines(Throwable exception) {
     return Collections.emptyList();
   }
 
+  private static List<String> getSuppressedStackTraceLines(Throwable exception) {
+    if (exception.getSuppressed() == null || exception.getSuppressed().length == 0) {
+      return Collections.emptyList();
+    }
+    List<String> lines = new ArrayList<>();
+    for (Throwable suppressed : exception.getSuppressed()) {
+      lines.add(
+          "\tSuppressed: " + suppressed.getClass().getName() + ": " + suppressed.getMessage());
+      for (String line : getTrimmedStackTraceLines(suppressed)) {
+        if (line.isEmpty()) {
+          continue;
+        }
+        lines.add("\t" + line);
+      }
+      for (String line : getCauseStackTraceLines(suppressed)) {
+        lines.add("\t" + line);
+      }
+    }
+    return lines;
+  }
+
   private static List<String> getCauseStackTraceLines(Throwable exception) {
     if (exception.getCause() != null) {
       String fullTrace = getFullStackTrace(exception);

services/events/javatests/androidx/test/services/events/internal/StackTrimmerTest.java

@@ -57,6 +57,28 @@ public void verifyFailureStackTraceIsTruncated() throws Exception {
         testResultTraceLength <= MAX_TRACE_SIZE);
   }
 
+  @Test
+  public void verifySuppressedExceptionIsRendered() throws Exception {
+    Throwable example = new Exception("Failing exception");
+    example.initCause(new RuntimeException("Cause of failing exception"));
+    Throwable suppressed = new RuntimeException("Suppressed exception");
+    suppressed.initCause(new RuntimeException("Cause of suppressed exception"));
+    example.addSuppressed(suppressed);
+    Failure testFailure = new Failure(Description.EMPTY, example);
+
+    // ensure trace contains the current method, but not any of the junit + androidx.test framework
+    // traces
+    String trace = StackTrimmer.getTrimmedStackTrace(testFailure);
+    assertThat(trace).contains("StackTrimmerTest.verifySuppressedExceptionIsRendered");
+    assertThat(trace).contains("Failing exception");
+    assertThat(trace).contains("Cause of failing exception");
+    assertThat(trace).contains("Suppressed exception");
+    assertThat(trace).contains("Cause of suppressed exception");
+    // Make sure that nothing crept into the suppressed exception's stack trace, or its cause.
+    assertThat(trace).doesNotContain("androidx.test.runner.AndroidJUnitRunner.onStart");
+    assertThat(trace).doesNotContain("org.junit.runners.ParentRunner.run");
+  }
+
   private static String getVeryLargeString() {
     return new String(new char[1000000]);
   }