@DisplayName("Message+Cause ctor: propagates message/cause and unsuccessful status")
    void messageAndCauseConstructor_setsMessageCause_andUnsuccessfulStatus(String msg) {
        // Arrange
        Throwable cause = new IllegalStateException("root cause");

        // Act
        SMBSignatureValidationException ex = new SMBSignatureValidationException(msg, cause);

        // Assert
        if (msg == null) {

 *
 */
public class RobotsTxtException extends CrawlerSystemException {

    private static final long serialVersionUID = 1L;

    /**
     * Constructs a new RobotsTxtException with the specified detail message and cause.
     * @param message the detail message
     * @param cause the cause of the exception
     */

   * {@link #add(Object)} or {@link #pollFirstEntry}. This skeleton implementation correctly
   * delegates each of its operations to the appropriate methods of this {@code
   * ForwardingSortedMultiset}.
   *
   * <p>In many cases, you may wish to override {@link #descendingMultiset()} to return an instance
   * of a subclass of {@code StandardDescendingMultiset}.
   *
   * @since 15.0
   */

     *
     * @param targetClass
     *            Target class
     * @param cause
     *            The cause of the exception
     */
    public IllegalAccessRuntimeException(final Class<?> targetClass, final IllegalAccessException cause) {
        super("ECL0042", asArray(targetClass.getName(), cause), cause);
        this.targetClass = targetClass;
    }

    /**
     * Returns the target class.
     *

     * Constructs a new SuggestSettingsException with the specified cause.
     * @param cause The cause.
     */
    public SuggestSettingsException(final Throwable cause) {
        super(cause);
    }

    /**
     * Constructs a new SuggestSettingsException with the specified detail message and cause.
     * @param msg The detail message.
     * @param cause The cause.
     */

      Throwable cause, Class<X> exceptionClass) throws X {
    if (cause instanceof Error) {
      throw new ExecutionError((Error) cause);
    }
    if (cause instanceof RuntimeException) {
      throw new UncheckedExecutionException(cause);
    }
    throw newWithCause(exceptionClass, cause);
  }

  /*

   */
  override fun close() {
    close(ErrorCode.NO_ERROR, ErrorCode.CANCEL, null)
  }

  internal fun close(
    connectionCode: ErrorCode,
    streamCode: ErrorCode,
    cause: IOException?,
  ) {
    assertLockNotHeld()

    ignoreIoExceptions {
      shutdown(connectionCode)
    }

    var streamsToClose: Array<Http2Stream>? = null
    withLock {

    /**
     * Constructs a new storage exception with the specified detail message and cause.
     *
     * @param message The detail message.
     * @param cause   The cause of the exception.
     */
    public StorageException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new storage exception with the specified detail message.
     *

    /**
     * Creates a new DictionaryException with the specified message and cause.
     *
     * @param message the detail message
     * @param cause the underlying cause of the exception
     */
    public DictionaryException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Creates a new DictionaryException with the specified message.
     *

        if (cause != null) {
          initCause(cause)
        }
      }

    @Throws(IOException::class)
    fun exitAndThrowIfTimedOut() {
      if (exit()) throw newTimeoutException(null)
    }
  }