@Test
        @DisplayName("Should decode with non-zero buffer offset")
        void testDecodeWithOffset() {
            byte[] testBuffer = new byte[20];
            int offset = 5;
            ByteBuffer bb = ByteBuffer.wrap(testBuffer).order(ByteOrder.LITTLE_ENDIAN);

            // Add padding before actual data
            bb.position(offset);
            bb.putShort((short) 24); // pathConsumed

     * @param token the input token bytes
     * @param offset offset into the token array
     * @param len length of token data
     * @return the output token bytes
     * @throws SmbException if an error occurs during context initialization
     */
    public byte[] initSecContext(byte[] token, final int offset, final int len) throws SmbException {
        switch (state) {
        case 1:

        return this.action;
    }

    @Override
    public String getFileName() {
        return this.fileName;
    }

    /**
     * Gets the offset to the next entry.
     *
     * @return the next entry offset in bytes
     */
    public int getNextEntryOffset() {
        return this.nextEntryOffset;
    }

    /**
     * Constructs a file notify information from the given buffer.

        assertEquals(0, used, "readBytesWireFormat is unimplemented and must return 0");
    }

    private static byte[] subArray(byte[] src, int offset, int length) {
        byte[] dst = new byte[length];
        System.arraycopy(src, offset, dst, 0, length);
        return dst;
    }

        data[18] = 0;
        data[19] = 0; // remark offset

        // Entry 2: IPC$, type 3 (IPC), remark "Inter-Process Communication"
        System.arraycopy("IPC$".getBytes(StandardCharsets.US_ASCII), 0, data, 20, 4);
        data[34] = 0x03;
        data[35] = 0x00; // type = 3
        data[36] = 60;
        data[37] = 0;
        data[38] = 0;
        data[39] = 0; // remark offset

        // Remarks data

/**
 * UUID type wrapper
 *
 */
public class UUID extends rpc.uuid_t {

    private static int hex_to_bin(final char[] arr, final int offset, final int length) {
        int value = 0;
        int ai, count;

        count = 0;
        for (ai = offset; ai < arr.length && count < length; ai++) {
            value <<= 4;
            switch (arr[ai]) {
            case '0':
            case '1':

    /// Squash bytes down to ints.
    /**
     * Converts bytes to integers for internal DES processing
     * @param inBytes the input byte array
     * @param inOff the offset into the input array
     * @param outInts the output integer array
     * @param outOff the offset into the output array
     * @param intLen the number of integers to convert
     */

     * Constructs a new PacUnicodeString instance.
     *
     * @param length the actual length of the string in bytes
     * @param maxLength the maximum allocated length for the string in bytes
     * @param pointer the pointer/offset to the string data
     */
    public PacUnicodeString(final short length, final short maxLength, final int pointer) {
        this.length = length;
        this.maxLength = maxLength;
        this.pointer = pointer;

     * @param dest The destination array in which the user session key will be
     * placed.
     * @param offset The offset in the destination array at which the
     * session key will start.
     */
    void getUserSessionKey(final byte[] challenge, final byte[] dest, final int offset) throws SmbException {
        if (hashesExternal) {
            return;
        }
        try {

      .optionalStart()
      .appendFraction(NANO_OF_SECOND, 3, 3, true)
      .toFormatter()

  private val offset = ZoneOffset.systemDefault()

  override fun format(record: LogRecord): String {
    val message = formatMessage(record)

    val time = Instant.ofEpochMilli(record.millis).atZone(offset)

    return if (record.thrown != null) {
      val sw = StringWriter(4096)
      val pw = PrintWriter(sw)