* context from when the error or exception was initially detected. Example usage:
   *
   * <pre>
   * assertEquals("Unable to assign a customer id", Throwables.getRootCause(e).getMessage());
   * </pre>
   *
   * @throws IllegalArgumentException if there is a loop in the causal chain
   */
  public static Throwable getRootCause(Throwable throwable) {

      if (!isPermitted(exception)) {
        String message =
            "Exception "
                + exception.getClass().getSimpleName()
                + " was thrown; expected "
                + getMessage();
        throw new AssertionError(message, exception);
      }
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

    ImmutableMap<Object, ImmutableList<Object>> tmpMap;
    try {
      tmpMap = builder.buildOrThrow();
    } catch (IllegalArgumentException e) {
      throw (InvalidObjectException) new InvalidObjectException(e.getMessage()).initCause(e);
    }

    deserializationReplacement = new ImmutableListMultimap<>(tmpMap, tmpSize);
  }

  @GwtIncompatible
  @J2ktIncompatible
    private Object readResolve() {

                    }
                    this.style = sb.toString();
                }
            } catch (final IOException ioe) {
                throw new ServletException(ioe.getMessage());
            }

            this.enableBasic = Config.getBoolean(p, "jcifs.http.enableBasic", false);
            this.insecureBasic = Config.getBoolean(p, "jcifs.http.insecureBasic", false);

            writeSecurityBuffer(type3, 52, offset, sessionKey);
            writeULong(type3, 60, flags);
            return type3;
        } catch (final IOException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    @Override
    public String toString() {
        final String user = getUser();
        final String domain = getDomain();
        final String workstation = getWorkstation();

                                    final Failure failure = resp.getFailure();
                                    logger.debug("Failed Request: {}\n=>{}", req, failure.getMessage());
                                }
                            }
                        }
                    }
                    throw new SearchEngineClientException(response.buildFailureMessage());

    LogRecord record = Iterables.getOnlyElement(logHandler.getStoredLogRecords());
    // We log failures that occur after startup
    assertThat(record.getMessage())
        .contains("Service FailRunService [FAILED] has failed in the RUNNING state");
  }

  /**
   * Tests that a ServiceManager can be fully shut down if one of its failure listeners is slow or

                    context.success("No inference optimizations needed");
                }
            } catch (Exception e) {
                context.failure("Failed to apply inference optimizations" + ": " + e.getMessage());
                errorPoms.add(pomPath);
            } finally {
                context.unindent();
            }
        }

        return new UpgradeResult(processedPoms, modifiedPoms, errorPoms);

                }
                
            } catch (Exception e) {
                log.debug("Reconnect attempt {} failed: {}", attempt + 1, e.getMessage());
                
                // Retry
                return attemptReconnect(file, info, attempt + 1).join();
            }
        });
    }
}
```

        try {
            execJob.execute();
            fail("Should throw RuntimeException");
        } catch (RuntimeException e) {
            assertEquals("Test exception", e.getMessage());
        }
    }

    // Test concurrent modification of jvmOptions
    @Test
    public void test_jvmOptions_concurrent() throws InterruptedException {