*
     * @param src the source data array
     * @param soff the offset in the source array
     * @param slen the length of data to process
     * @param dst the destination array for the result
     * @param doff the offset in the destination array
     */
    public void update(final byte[] src, int soff, final int slen, final byte[] dst, int doff) {

            verify(mockMd5, times(1)).update((byte) 0x01);
        }
    }

    @Test
    void testEngineUpdateByteArray() throws NoSuchAlgorithmException {
        // Test engineUpdate(byte[] input, int offset, int len)
        try (MockedStatic<Crypto> mockedCrypto = mockStatic(Crypto.class)) {
            mockedCrypto.when(Crypto::getMD5).thenReturn(mockMd5);
            HMACT64 hmac = new HMACT64(TEST_KEY);

    }

    private String readNullTerminatedString(byte[] buffer, int offset) {
        int end = offset;
        while (end < buffer.length && buffer[end] != 0) {
            end++;
        }
        return new String(buffer, offset, end - offset);
    }

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

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.exception;

/**
 * This exception is thrown when the requested result offset exceeds the limit.
 */
public class ResultOffsetExceededException extends FessSystemException {
    private static final long serialVersionUID = 1L;

    /**
     * Constructor.

    }

    // 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]);
            }
        }

            // Then
            assertEquals(EXPECTED_SIZE, bytesWritten);

            // Verify source offset
            assertEquals(sourceOffset, SMBUtil.readInt8(buffer, startIndex));

            // Verify target offset
            assertEquals(targetOffset, SMBUtil.readInt8(buffer, startIndex + 8));

            // Verify length

        // Verify by writing to buffer and checking the fileId position
        byte[] buffer = new byte[1024];
        request.writeBytesWireFormat(buffer, Smb2Constants.SMB2_HEADER_LENGTH);

        // FileId is at offset 8 in the request structure
        for (int i = 0; i < 16; i++) {
            assertEquals(fileId[i], buffer[Smb2Constants.SMB2_HEADER_LENGTH + 8 + i]);
        }
    }

    @Test

    @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() {