@BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);
    }

    @Test
    void testConstructor() {
        // Test constructor with positive timezone offset
        long serverTimeZoneOffset = 3600000L; // 1 hour in milliseconds
        response = new SmbComQueryInformationResponse(mockConfig, serverTimeZoneOffset);

        assertNotNull(response);

    return (UnmodifiableListIterator<E>) delegateList.listIterator(index);
  }

  @GwtIncompatible // not present in emulated superclass
  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    return delegateList.copyIntoArray(dst, offset);
  }

  @Override
  @Nullable Object @Nullable [] internalArray() {
    return delegateList.internalArray();
  }

  @Override
  int internalArrayStart() {

        @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

    /// 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
     */

     * @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:

        } else {
            resp = negotitate(inputBuf, offset, len);
        }

        if (resp == null) {
            return null;
        }
        return resp.toByteArray();
    }

    private SpnegoToken negotitate(final byte[] inputBuf, final int offset, final int len) throws CIFSException {
        final SpnegoToken spToken = getToken(inputBuf, offset, len);
        byte[] inputToken = null;

    }

    // Helper method to read string from buffer
    private String readStringFromBuffer(byte[] buffer, int offset, int length) {
        // Simple ASCII string reading for test purposes
        StringBuilder sb = new StringBuilder();
        for (int i = offset; i < offset + length && buffer[i] != 0; i++) {
            if (buffer[i] != 0) {
                sb.append((char) buffer[i]);
            }
        }

     * @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 {

/**
 * 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':

     * 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;