* addSuppressed(Throwable) mechanism.
   */
  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) {
          /*

          }
        }
        return plan.handleSuccess()
      } catch (e: IOException) {
        if (firstException == null) {
          firstException = e
        } else {
          firstException.addSuppressed(e)
        }
        if (!routePlanner.hasNext()) {
          throw firstException
        }
      }
    }
  }

        assertNull(exception.getCause());

        // Test that suppression is enabled
        RuntimeException suppressed = new RuntimeException("Suppressed exception");
        exception.addSuppressed(suppressed);
        assertEquals(1, exception.getSuppressed().length);
        assertEquals(suppressed, exception.getSuppressed()[0]);
    }

    public void test_constructor_withSuppressionDisabled() {

        Exception suppressed1 = new IllegalArgumentException("Suppressed 1");
        Exception suppressed2 = new IOException("Suppressed 2");
        mainException.addSuppressed(suppressed1);
        mainException.addSuppressed(suppressed2);

        Throwable[] suppressedExceptions = mainException.getSuppressed();
        assertEquals(2, suppressedExceptions.length);

        )
      }
      return response
    } catch (e: IOException) {
      if (sendRequestException != null) {
        sendRequestException.addSuppressed(e)
        throw sendRequestException
      }
      throw e
    }
  }

  private fun shouldIgnoreAndWaitForRealResponse(code: Int): Boolean =
    when {

                try {
                    th.send(new Smb2CloseRequest(th.getConfig(), cr.getFileId()));
                } catch (final SmbException e2) {
                    e.addSuppressed(e2);
                }
            }

            final Smb2QueryDirectoryResponse qr = query.getResponse();

            if (qr != null && qr.isReceived() && qr.getStatus() == NtStatus.NT_STATUS_NO_SUCH_FILE) {

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

        mainException.addSuppressed(suppressedException);

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

                      try {
                        shutDown();
                      } catch (Exception ignored) {
                        restoreInterruptIfIsInterruptedException(ignored);
                        t.addSuppressed(ignored);
                      }
                      notifyFailed(t);
                      return;
                    }
                  }

                  shutDown();
                  notifyStopped();

      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> {

                      try {
                        shutDown();
                      } catch (Exception ignored) {
                        restoreInterruptIfIsInterruptedException(ignored);
                        t.addSuppressed(ignored);
                      }
                      notifyFailed(t);
                      return;
                    }
                  }

                  shutDown();
                  notifyStopped();