// Test with alternating pattern
        byte[] alternatingFileId = new byte[16];
        for (int i = 0; i < 16; i++) {
            alternatingFileId[i] = (byte) (i % 2 == 0 ? 0xAA : 0x55);
        }
        Smb2FlushRequest alternatingRequest = new Smb2FlushRequest(mockConfig, alternatingFileId);
        testFileIdInRequest(alternatingRequest, alternatingFileId);
    }

	if err != nil {
		return
	}
	err = en.WriteInt64(z.Total)
	if err != nil {
		err = msgp.WrapError(err, "Total")
		return
	}
	// write "Used"
	err = en.Append(0xa4, 0x55, 0x73, 0x65, 0x64)
	if err != nil {
		return
	}
	err = en.WriteInt64(z.Used)
	if err != nil {
		err = msgp.WrapError(err, "Used")
		return
	}
	return
}

        fp = 0L;
    }

    /**
     * Reads a single byte from the file at the current file pointer position.
     *
     * @return the byte read as an integer (0-255), or -1 if end of file is reached
     * @throws SmbException if an I/O error occurs
     */
    public int read() throws SmbException {
        if (read(tmp, 0, 1) == -1) {
            return -1;
        }

	if err != nil {
		return
	}
	err = en.WriteString(z.ID)
	if err != nil {
		err = msgp.WrapError(err, "ID")
		return
	}
	// write "User"
	err = en.Append(0xa4, 0x55, 0x73, 0x65, 0x72)
	if err != nil {
		return
	}
	err = en.WriteString(z.User)
	if err != nil {
		err = msgp.WrapError(err, "User")
		return
	}
	// write "Started"

	if err != nil {
		return
	}
	err = en.WriteTime(z.Started)
	if err != nil {
		err = msgp.WrapError(err, "Started")
		return
	}
	// write "LastUpdate"
	err = en.Append(0xaa, 0x4c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65)
	if err != nil {
		return
	}
	err = en.WriteTime(z.LastUpdate)
	if err != nil {
		err = msgp.WrapError(err, "LastUpdate")
		return
	}
	// write "ObjectsTotalCount"

        int flags = NegTokenInit.DELEGATION | NegTokenInit.MUTUAL_AUTHENTICATION | NegTokenInit.INTEGRITY;
        byte[] mechToken = new byte[] { 0x01, 0x02, 0x03 };
        byte[] mic = new byte[] { (byte) 0xFE, 0x55 };

        NegTokenInit init = new NegTokenInit(mechs, flags, mechToken, mic);
        byte[] bytes = init.toByteArray();

        NegTokenInit parsed = new NegTokenInit(bytes);

    // Read a delimiter.
    if (b != addressOffset) {
      if (input[i] != '.') return false // Wrong delimiter.
      i++
    }

    // Read 1 or more decimal digits for a value in 0..255.
    var value = 0
    val groupOffset = i
    while (i < limit) {
      val c = input[i]
      if (c < '0' || c > '9') break

	b, err := json.Marshal(m)
	if err != nil {
		t.Fatal(err)
	}

	if err = os.MkdirAll(pathJoin(rootPath, minioMetaBucket), os.FileMode(0o755)); err != nil {
		t.Fatal(err)
	}

	if err = os.WriteFile(pathJoin(rootPath, minioMetaBucket, formatConfigFile), b, os.FileMode(0o644)); err != nil {
		t.Fatal(err)
	}

        var result = prefixMask
        var shift = 0
        while (true) {
          val b = readByte()
          if (b and 0x80 != 0) { // Equivalent to (b >= 128) since b is in [0..255].
            result += b and 0x7f shl shift
            shift += 7
          } else {
            result += b shl shift // Last byte.
            break
          }
        }
        return result

        serverData.serverTime = System.currentTimeMillis();
        serverData.serverTimeZone = -480; // PST
        serverData.encryptionKeyLength = 8;
        serverData.encryptionKey = new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, (byte) 0x88 };
        serverData.guid = new byte[16];

        // Then - verify all values are set correctly
        assertEquals((byte) 0x98, serverData.sflags);