ResultOffsetExceededException suppressedException = new ResultOffsetExceededException("Suppressed exception");

        mainException.addSuppressed(suppressedException);

        Throwable[] suppressed = mainException.getSuppressed();
        assertNotNull(suppressed);
        assertEquals(1, suppressed.length);

      throw failure
    }

    val unknownHostException = UnknownHostException(hostname)
    unknownHostException.initCause(failure)

    for (i in 1 until failures.size) {
      unknownHostException.addSuppressed(failures[i])
    }

    throw unknownHostException
  }

  @Throws(Exception::class)
  private fun readResponse(
    hostname: String,
    response: Response,
  ): List<InetAddress> {

        ContentNotFoundException exception = new ContentNotFoundException(parentUrl, url);

        // Verify that suppression is disabled
        try {
            exception.addSuppressed(new Exception("Test suppressed"));
            // If suppression is disabled, getSuppressed should return empty array
            assertEquals(0, exception.getSuppressed().length);
        } catch (Exception e) {

        }
        logger.error("-----------------------------------------")
        GradleException toThrow = new GradleException(msg)
        for (Exception e : suppressed) {
            toThrow.addSuppressed(e)
        }
        throw toThrow
    }

    /** Adds a task to kill an elasticsearch node with the given pidfile */
    private TaskProvider<AntFixtureStop> createStopTask() {

        } catch (final IOException ioe) {
            log.warn("sendrecv failed", ioe);
            try {
                disconnect(true);
            } catch (final IOException ioe2) {
                ioe.addSuppressed(ioe2);
                log.info("disconnect failed", ioe2);
            }
            throw ioe;
        } catch (final InterruptedException ie) {
            throw new TransportException(ie);
        } finally {

          out = transfer;
        } catch (IOException e) {
          if (transfer != null) {
            try {
              transfer.close();
            } catch (IOException closeException) {
              e.addSuppressed(closeException);
            }
          }
          temp.delete();
          throw e;
        }

        file = temp;
        memory = null;
      }
    }
  }

            try {
                transport.disconnect(true);
            } catch (final IOException e) {
                log.warn("Failed to disconnect transport", e);
                se.addSuppressed(e);
            }
            throw se;
        }
    }

    /**
     * @param trans
     * @param sess
     * @throws CIFSException
     *
     */

                                StandardCopyOption.REPLACE_EXISTING,
                                StandardCopyOption.COPY_ATTRIBUTES);
                    } catch (IOException e) {
                        e.addSuppressed(suppressed);
                        throw e;
                    }
                }
            }
        } catch (IOException e) {

                    + Multimaps.filterKeys(servicesByState, not(equalTo(RUNNING))));
        for (Service service : servicesByState.get(State.FAILED)) {
          exception.addSuppressed(new FailedService(service));
        }
        throw exception;
      }
    }
  }

  /**
   * A {@link Service} that wraps another service and times how long it takes for it to start and

      try {
        stream.close();
      } catch (Exception e) { // sneaky checked exception
        if (exception == null) {
          exception = e;
        } else {
          exception.addSuppressed(e);
        }
      }
    }
    if (exception != null) {
      // Normally this is a RuntimeException that doesn't need sneakyThrow.
      // But theoretically we could see sneaky checked exception