assertEquals(nameBytes.length, SMBUtil.readInt4(buffer, 8));
        assertEquals(0x1, buffer[12]); // Timeout specified

        // Verify pipe name
        byte[] encodedName = new byte[nameBytes.length];
        System.arraycopy(buffer, 14, encodedName, 0, nameBytes.length);
        assertArrayEquals(nameBytes, encodedName);
    }

    @Test

        byte[] nameBytes = originalFileName.getBytes(StandardCharsets.UTF_16LE);

        byte[] buffer = new byte[100];
        buffer[0] = 1; // replaceIfExists = true
        // Skip 7 reserved bytes (1-7)
        // Skip 8 bytes for RootDirectory (8-15)
        SMBUtil.writeInt4(nameBytes.length, buffer, 16);
        System.arraycopy(nameBytes, 0, buffer, 20, nameBytes.length);

        dstIndex += 8;
        SMBUtil.writeInt4(this.nameBytes.length, dst, dstIndex);
        dstIndex += 4;

        dst[dstIndex] = (byte) (this.timeoutSpecified ? 0x1 : 0x0);
        dstIndex++;
        dstIndex++; // Padding

        System.arraycopy(this.nameBytes, 0, dst, dstIndex, this.nameBytes.length);
        dstIndex += this.nameBytes.length;

        return dstIndex - start;
    }

    /**

        int bufferIndex = 0;
        int start = 0;

        // Write server name (16 bytes, null padded)
        byte[] nameBytes = serverName.getBytes(StandardCharsets.US_ASCII);
        System.arraycopy(nameBytes, 0, buffer, bufferIndex, Math.min(nameBytes.length, 15));
        bufferIndex += 16;

        // Write version major (1 byte)
        buffer[bufferIndex++] = (byte) versionMajor;

class MIENameTest {

    // Helper to build a valid buffer according to the expected layout.
    private static byte[] buildBuffer(byte[] oidDer, byte[] nameBytes) {
        byte[] tokId = new byte[] { 0x04, 0x01 };
        int oidLen = oidDer.length;
        int nameLen = nameBytes.length;

        byte[] buf = new byte[2 + 2 + oidLen + 4 + nameLen];
        int i = 0;
        // TOK_ID
        buf[i++] = tokId[0];

        // filename bytes, then null terminator
        byte[] nameBytes = name.getBytes();
        for (int i = 0; i < nameBytes.length; i++) {
            assertEquals(nameBytes[i], dst[12 + i], "Filename byte mismatch at index " + i);
        }
        assertEquals((byte) 0x00, dst[12 + nameBytes.length], "Filename must be null-terminated");
    }

    /**

    BigInteger result = randomPositiveBigInteger(numBits);
    return RANDOM_SOURCE.nextBoolean() ? result : result.negate();
  }

  /**
   * Chooses a number in (-2^numBits, 2^numBits) at random, with density concentrated in numbers of
   * lower magnitude.
   */
  static BigInteger randomBigInteger(int numBits) {
    while (true) {
      if (RANDOM_SOURCE.nextBoolean()) {

  public Hasher putString(CharSequence charSequence, Charset charset) {
    return putBytes(charSequence.toString().getBytes(charset));
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(byte[] bytes) {
    return putBytes(bytes, 0, bytes.length);
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(byte[] bytes, int off, int len) {

        dstIndex += 8; // RootDirectory = 0

        final byte[] nameBytes = this.fileName.getBytes(StandardCharsets.UTF_16LE);

        SMBUtil.writeInt4(nameBytes.length, dst, dstIndex);
        dstIndex += 4;

        System.arraycopy(nameBytes, 0, dst, dstIndex, nameBytes.length);
        dstIndex += nameBytes.length;

        return dstIndex - start;
    }

    /**
     * {@inheritDoc}

        return this;
      }

      @Override
      public Hasher putBytes(byte[] bytes) {
        for (Hasher hasher : hashers) {
          hasher.putBytes(bytes);
        }
        return this;
      }

      @Override
      public Hasher putBytes(byte[] bytes, int off, int len) {
        for (Hasher hasher : hashers) {
          hasher.putBytes(bytes, off, len);
        }
        return this;
      }