// Expected size: 2 (info level) + 4 (reserved) + filename length + 1 (null terminator)
        byte[] dst = new byte[2 + 4 + filename.length() + 1];

        // When
        int bytesWritten = trans.writeParametersWireFormat(dst, 0);

        // Then
        assertEquals(dst.length, bytesWritten, "The number of bytes written should match the expected length.");
        // Check informationLevel

        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}
     *
     * @see jcifs.Encodable#size()
     */

     */
    MIEName(final byte[] buf) {
        int i;
        int len;
        if (buf.length < TOK_ID_SIZE + MECH_OID_LEN_SIZE) {
            throw new IllegalArgumentException();
        }
        // TOK_ID
        for (i = 0; i < TOK_ID.length; i++) {
            if (TOK_ID[i] != buf[i]) {
                throw new IllegalArgumentException();
            }
        }

    }

    @Override
    public int indexIn(CharSequence sequence) {
      return (sequence.length() == 0) ? -1 : 0;
    }

    @Override
    public int indexIn(CharSequence sequence, int start) {
      int length = sequence.length();
      checkPositionIndex(start, length);
      return (start == length) ? -1 : start;
    }

    @Override
    public int lastIndexIn(CharSequence sequence) {

        byte[] buffer = new byte[offset + notificationData.length];
        System.arraycopy(notificationData, 0, buffer, offset, notificationData.length);

        int result = response.readParametersWireFormat(buffer, offset, notificationData.length);

        assertTrue(result > 0);
        List<FileNotifyInformation> notifications = response.getNotifyInformation();

            if (strings.length > 1) {
                for (int i = 0; i < strings.length - 1; i++) {
                    if (buf.length() != 0) {
                        buf.append('.');
                    }
                    buf.append(strings[i]);
                }
                filePrefix = buf.toString();
                extention = strings[strings.length - 1];
            } else {

      implements TestMultimapGenerator<String, String, M> {

    @Override
    public String[] createKeyArray(int length) {
      return new String[length];
    }

    @Override
    public String[] createValueArray(int length) {
      return new String[length];
    }

    @Override
    public SampleElements<String> sampleKeys() {

      if (initialBytes == null) {
        return checkNotNull(bytes);
      } else {
        byte[] result = new byte[initialBytes.length + bytes.length];
        System.arraycopy(initialBytes, 0, result, 0, initialBytes.length);
        System.arraycopy(bytes, 0, result, initialBytes.length, bytes.length);
        return result;
      }
    }

    @Override
    public byte[] getSinkContents() throws IOException {

    inbound: Boolean,
    streamId: Int,
    length: Int,
    type: Int,
    flags: Int,
  ): String {
    val formattedType = formattedType(type)
    val formattedFlags = formatFlags(type, flags)
    val direction = if (inbound) "<<" else ">>"
    return format(
      "%s 0x%08x %5d %-13s %s",
      direction,
      streamId,
      length,
      formattedType,
      formattedFlags,
    )
  }

                ip = i = 0;
                for (; i < data.length && c == '.'; i++) {
                    int b = 0x00;

                    for (; i < data.length && (c = data[i]) >= 48 && c <= 57; i++) {
                        b = b * 10 + c - '0';
                    }
                    ip = (ip << 8) + b;
                }
                while (i < data.length && Character.isWhitespace(data[i])) {
                    i++;