dstIndex += ((AndXServerMessageBlock) andx).writeAndXWireFormat(dst, dstIndex);
        } else {
            // the andx smb is not of type andx so lets just write it here and
            // were done.
            final int andxStart = dstIndex;
            andx.wordCount = andx.writeParameterWordsWireFormat(dst, dstIndex);
            dstIndex += andx.wordCount + 1;
            andx.wordCount /= 2;

 * <i>type</i> offering meaningful behavioral guarantees. This is substantially different from the
 * case of (say) {@link HashSet}, which is an <i>implementation</i>, with semantics that were
 * largely defined by its supertype.
 *
 * <p>For field types and method return types, you should generally use the immutable type (such as

   * escaper escapes all non-ASCII characters, even though <a
   * href="https://url.spec.whatwg.org/#url-code-points">many of these are accepted in modern
   * URLs</a>. (<a href="https://url.spec.whatwg.org/#path-state">If the escaper were to leave these
   * characters unescaped, they would be escaped by the consumer at parse time, anyway.</a>)
   * Additionally, the escaper escapes the slash character ("/"). While slashes are acceptable in

        // notify listeners about "soft" project build failures only
        if (t instanceof Exception exception && !(t instanceof RuntimeException)) {
            eventCatapult.fire(ExecutionEvent.Type.ProjectFailed, currentSession, null, exception);
        }

        // reactor failure modes
        if (t instanceof RuntimeException || !(t instanceof Exception)) {

   * will be handled within the boundaries of a single [callStart] and [callEnd]/[callFailed] pair.
   */
  open fun callStart(call: Call) {
  }

  /**
   * Invoked for calls that were not executed immediately because resources weren't available. The
   * call will remain in the queue until resources are available.
   *
   * Use [Dispatcher.maxRequests] and [Dispatcher.maxRequestsPerHost] to configure how many calls

      assertThat(queueSize).isBetween(0L, messageCount * message.size)
      // Expect to fail before enqueueing 32 MiB.
      assertThat(messageCount).isLessThan(32L)
    }

    // Confirm all sent messages were received, followed by a client-initiated close.
    val server = serverListener.assertOpen()
    for (i in 0 until messageCount) {
      serverListener.assertBinaryMessage(message)
    }

            // to). Our contract promises:
            //
            // 1. not to execute a new callable until the old one has returned
            //
            // If we were to cancel taskFuture, that would let the next task start while the old
            // one is still running.
            //
            // Now, maybe we could tweak our implementation to not start the next task until the

     * @return the username
     */
    public String getUsername() {
        return username;
    }

    /**
     * Returns the password in plain text or {@code null} if the raw password
     * hashes were used to construct this {@code NtlmPasswordAuthentication}
     * object which will be the case when NTLM HTTP Authentication is
     * used. There is no way to retrieve a users password in plain text unless

    private PrefixQueryCommand queryCommand;
    private QueryFieldConfig queryFieldConfig;

    @Override
    protected void setUpChild() throws Exception {
        // Get the queryProcessor and queryFieldConfig that were registered in parent class
        queryProcessor = ComponentUtil.getComponent("queryProcessor");
        queryFieldConfig = ComponentUtil.getComponent("queryFieldConfig");

        // Initialize and register PrefixQueryCommand

 * It is public so we can access it reflectively across class loaders in secure environments.
 *
 * <p>This class can't depend on other Guava code. If we were to load this class in the same class
 * loader as the rest of Guava, this thread would keep an indirect strong reference to the class
 * loader and prevent it from being garbage collected. This poses a problem for environments where