* {@code view} returned by this method will be invalidated, and will throw {@code
   * IllegalStateException} if it is accessed in any way, with the following exceptions:
   *
   * <ul>
   *   <li>{@code view.equals(view)} evaluates to {@code true} (but any other {@code equals()}
   *       expression involving {@code view} will throw)
   *   <li>{@code hashCode()} does not throw

            if (exitValue == 143 && mt.isTeminated()) {
                throw new ExecutionTimeoutException("The command execution is timeout: " + cmdList);
            }
        } catch (final CrawlerSystemException e) {
            throw e;
        } catch (final InterruptedException e) {
            if (mt != null && mt.isTeminated()) {
                throw new ExecutionTimeoutException("The command execution is timeout: " + cmdList, e);

            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new IOException("Interrupted waiting for send credit", e);
            }
        }
        
        if (!rdmaConnection.canSend()) {
            throw new IOException("Timeout waiting for RDMA send credit");
        }
    }
    
    @Override

     * PotentialDeadlockException} indicating the potential deadlock, which includes stack traces
     * illustrating the cycle in lock acquisition order.
     */
    THROW {
      @Override
      public void handlePotentialDeadlock(PotentialDeadlockException e) {
        throw e;
      }
    },

    /**
     * When potential deadlock is detected, this policy results in the logging of a {@link

      override fun fromDer(reader: DerReader): Pair<DerAdapter<*>, Any?> {
        val peekedHeader =
          reader.peekHeader()
            ?: throw ProtocolException("expected a value at $reader")

        val choice =
          choices.firstOrNull { it.matches(peekedHeader) }
            ?: throw ProtocolException(
              "expected a matching choice but was $peekedHeader at $reader",
            )

        if (transliteratorId == null) {
            throw new IllegalArgumentException("transliteratorId must not be null");
        }
        try {
            this.transliterator = Transliterator.getInstance(transliteratorId);
        } catch (final IllegalArgumentException e) {
            throw new IllegalArgumentException("Invalid transliterator ID: " + transliteratorId, e);
        }
    }

  internal val delegate = QueueDispatcher()

  @Throws(InterruptedException::class)
  override fun dispatch(request: RecordedRequest): MockResponse = throw UnsupportedOperationException("unexpected call")

  override fun peek(): MockResponse = throw UnsupportedOperationException("unexpected call")

  fun enqueueResponse(response: MockResponse) {
    delegate.enqueue(response.wrap())
  }

  override fun shutdown() {

                    }
                    throw new FessUserNotFoundException(username);
                });
            } else {
                logger.warn("Password change not applied by authentication manager: username={}", username);
            }
        } catch (final FessUserNotFoundException e) {
            throw e;
        } catch (final Exception e) {

    }

    @Override
    public int getPriority() {
        return 1;
    }

    @Override
    public void setName(String name) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void setPriority(int priority) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String getDescription() {

    private static void checkVertex(MetadataGraphVertex v) throws MetadataResolutionException {
        if (v == null) {
            throw new MetadataResolutionException("null vertex");
        }
        if (v.getMd() == null) {
            throw new MetadataResolutionException("vertex without metadata");
        }
    }
    // ------------------------------------------------------------------------