Exception causeOfSuppressed = new NoSuchElementException("cause of suppressed");
        Exception suppressed = new IllegalStateException("suppressed", causeOfSuppressed);
        suppressed.addSuppressed(new IllegalArgumentException(
                "suppressed suppressed", new ArrayIndexOutOfBoundsException("suppressed suppressed cause")));
        Exception cause = new IllegalArgumentException("cause");

                        exception.addSuppressed(new RuntimeException("I am suppressed"));
                        throw exception;
                    }
                    if (input.contains("bb")) {
                        RuntimeException exception =
                                new CustomException("This is a CUSTOM exception with suppressed one");

      this.closeable = closeable;
      this.thrown = thrown;
      this.suppressed = suppressed;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof Suppression) {
        Suppression other = (Suppression) obj;
        return closeable.equals(other.closeable)
            && thrown.equals(other.thrown)
            && suppressed.equals(other.suppressed);
      }

    private final List<StackTraceRelevance> frameRelevance;
    private final List<Failure> suppressed;
    private final List<Failure> causes;

    public DefaultFailure(
        Throwable original,
        List<StackTraceElement> stackTrace,
        List<StackTraceRelevance> frameRelevance,
        List<Failure> suppressed,
        List<Failure> causes
    ) {
        if (stackTrace.size() != frameRelevance.size()) {

        final List<? extends Throwable> causes;
        final List<? extends Throwable> suppressed;
        if (hasCycle) {
            // Ignore causes and suppressed in case of cycle
            causes = Collections.emptyList();
            suppressed = Collections.emptyList();
        } else {
            causes = extractCauses(throwable);
            suppressed = extractSuppressed(throwable);
        }

   */
  private static final Suppressor SUPPRESSING_SUPPRESSOR =
      (closeable, thrown, suppressed) -> {
        // ensure no exceptions from addSuppressed
        if (thrown == suppressed) {
          return;
        }
        try {
          thrown.addSuppressed(suppressed);
        } catch (Throwable e) {
          /*

  public void testCopyExceptions() {
    // test that exceptions are suppressed

    for (CharSource in : BROKEN_SOURCES) {
      int suppressed = runSuppressionFailureTest(in, newNormalCharSink());
      assertEquals(0, suppressed);

      suppressed = runSuppressionFailureTest(in, BROKEN_CLOSE_SINK);
      assertEquals((in == BROKEN_OPEN_SOURCE) ? 0 : 1, suppressed);
    }

    for (CharSink out : BROKEN_SINKS) {

   */
  private static final Suppressor SUPPRESSING_SUPPRESSOR =
      (closeable, thrown, suppressed) -> {
        // ensure no exceptions from addSuppressed
        if (thrown == suppressed) {
          return;
        }
        try {
          thrown.addSuppressed(suppressed);
        } catch (Throwable e) {
          /*

      client.newCall(request).execute()
    }.also { expected ->
      expected.assertSuppressed {
        val suppressed = it.single()
        assertThat(suppressed).isInstanceOf(IOException::class.java)
        assertThat(suppressed).isNotSameAs(expected)
      }
    }
  }

  /** Confirm suppressed exceptions that occur after connecting are returned. */
  @Test fun httpExceptionsAreReturnedAsSuppressed() {

  public void testCopyExceptions() {
    // test that exceptions are suppressed

    for (ByteSource in : BROKEN_SOURCES) {
      int suppressed = runSuppressionFailureTest(in, newNormalByteSink());
      assertEquals(0, suppressed);

      suppressed = runSuppressionFailureTest(in, BROKEN_CLOSE_SINK);
      assertEquals((in == BROKEN_OPEN_SOURCE) ? 0 : 1, suppressed);
    }

    for (ByteSink out : BROKEN_SINKS) {