}
    }
    return new MacHasher(getMac(prototype.getAlgorithm(), key));
  }

  @Override
  public String toString() {
    return toString;
  }

  /** Hasher that updates a {@link Mac} (message authentication code). */
  private static final class MacHasher extends AbstractByteHasher {
    private final Mac mac;
    private boolean done;

    private MacHasher(Mac mac) {
      this.mac = mac;
    }

     * @return the numberOfMessages
     */
    public int getNumberOfMessages() {
        return this.numberOfMessages;
    }

    /**
     * Gets the length of the first message in the pipe
     * @return the messageLength
     */
    public int getMessageLength() {
        return this.messageLength;
    }

    /**
     * Gets the data peeked from the pipe
     * @return the data

import jcifs.Configuration;
import jcifs.internal.Request;
import jcifs.internal.smb1.SMB1SigningDigest;
import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Close file request message.
 *
 * This command is used to close a file that was previously opened
 * with an Open command.
 */
public class SmbComClose extends ServerMessageBlock implements Request<SmbComBlankResponse> {

    void testConstructorInitialization() {
        // Verify level is set to 200 for DFS root enumeration
        assertEquals(200, dfsRootEnum.level);

        // Verify DCE/RPC message properties
        assertEquals(0, dfsRootEnum.getPtype());
        assertEquals(DcerpcConstants.DCERPC_FIRST_FRAG | DcerpcConstants.DCERPC_LAST_FRAG, dfsRootEnum.getFlags());

        // Verify DFS enumeration structure

        assertContentType("application/x-lharc", "extractor/lha/test.lzh", "hoge.lzh"); // TODO is it correct?

        assertContentType("application/xml", "extractor/test.mm", "hoge.mm");

        assertContentType("message/rfc822", "extractor/eml/sample1.eml", "sample1.eml");

        assertContentType("application/octet-stream", null, "hoge");

        assertContentType("application/vnd.ms-powerpoint", "extractor/msoffice/test.ppt", "h&oge.ppt");

      // We've discovered a leaked call. This is an application bug.
      val callReference = reference as CallReference
      val message =
        "A connection to ${connection.route().address.url} was leaked. " +
          "Did you forget to close a response body?"
      Platform.get().logCloseableLeak(message, callReference.callStackTrace)

      references.removeAt(i)

import jcifs.Configuration;
import jcifs.internal.smb1.AndXServerMessageBlock;
import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Read AndX request message.
 *
 * This command is used to read data from a file that has been
 * previously opened with an Open command.
 */
public class SmbComReadAndX extends AndXServerMessageBlock {

    private long offset;

  }

  @Test
  fun hasBody() {
    val request = Request.Builder().url("http://example.com").build()
    val response =
      Response
        .Builder()
        .code(200)
        .message("OK")
        .request(request)
        .protocol(Protocol.HTTP_2)
        .build()
    assertTrue(hasBody(response))
  }

      key = "has_space "
      cache.edit(key)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("keys must match regex [a-z0-9_-]{1,120}: \"$key\"")
    }
    assertFailsWith<IllegalArgumentException> {
      key = "has_CR\r"
      cache.edit(key)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("keys must match regex [a-z0-9_-]{1,120}: \"$key\"")
    }

        synchronized (BUF) {
            ServerMessageBlock smb = (ServerMessageBlock) request;
            final int n = smb.encode(BUF, 4);
            Encdec.enc_uint32be(n & 0xFFFF, BUF, 0); /* 4 byte session message header */
            if (LogStream.level >= 4) {
                do {
                    log.println(smb);