* 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) {
          /*

   * 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
        }
      }
    }
  }

        openKotlinCompilationUnitsByRoot.clear()
        if (errors.isNotEmpty()) {
            throw Exception("Sources repository did not close cleanly").apply {
                errors.forEach(this::addSuppressed)
            }
        }
    }

    /**
     * @return the source file and it's source root
     */
    fun sourceFileAndSourceRootFor(sourceFilePath: String): Pair<File, File> =

        if (allAddresses.isEmpty()) {
          val first = allExceptions.firstOrNull() ?: UnknownHostException("No results for $hostname")

          allExceptions.drop(1).forEach {
            first.addSuppressed(it)
          }

          throw first
        }

        allAddresses
      }
  }

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

            Smb2QueryDirectoryResponse qr = query.getResponse();

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

        if (throwable != null) {
          if (throwable !is IOException) throw throwable
          if (firstException == null) {
            firstException = throwable
          } else {
            firstException.addSuppressed(throwable)
          }
        }

        val nextPlan = connectResult.nextPlan
        if (nextPlan != null) {
          // Try this plan's successor before deferred plans because it won the race!

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

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

            }
        }
        if (!exceptions.isEmpty()) {
            InvokerException exception = new InvokerException("Could not cleanly shut down context pool");
            exceptions.forEach(exception::addSuppressed);
            throw exception;
        }
    }

    @Override
    protected LocalContext createContext(MavenInvokerRequest<MavenOptions> invokerRequest) {
        return residentContext

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

                  shutDown();
                  notifyStopped();