// Then
            assertEquals(24, bytesConsumed);
            // Note: multiplication may overflow, but that's expected behavior
            long expectedCapacity = Long.MAX_VALUE * (long) Integer.MAX_VALUE * (long) Integer.MAX_VALUE;
            assertEquals(expectedCapacity, fileFsSizeInfo.getCapacity());
        }

        @Test
        @DisplayName("Should decode buffer with offset correctly")

    }

    /**
     * @return the lastWriteTime
     */
    @Override
    public final long getLastWriteTime() {
        return this.lastWriteTime;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.SmbBasicFileInfo#getCreateTime()
     */
    @Override
    public long getCreateTime() {
        return 0;
    }

    /**
     * {@inheritDoc}
     *

     * @param operation the operation name
     * @throws ArithmeticException if operation would overflow
     */
    public static void validateIntegerAddition(int a, int b, String operation) {
        long result = (long) a + (long) b;
        if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
            throw new ArithmeticException(operation + " would cause integer overflow: " + a + " + " + b);
        }
    }

    /** Total execution time for all operations */
    protected volatile long executeTime = 0;

    /** List of documents waiting to be indexed */
    protected final DocList docList = new DocList();

    /** Maximum size of document requests in bytes */
    protected long maxDocumentRequestSize;

    /** Maximum number of documents to cache before indexing */

                    int safeShift = Math.min(MAX_BACKOFF_SHIFT, Math.max(0, retryCount - 1));
                    long multiplier = 1L << safeShift;
                    // Check for potential overflow before multiplication
                    long delay = (retryDelayMs > Long.MAX_VALUE / multiplier) ? MAX_RETRY_DELAY
                            : Math.min(MAX_RETRY_DELAY, retryDelayMs * multiplier);

    /**
     * Maximum number of URLs to access during crawling.
     */
    protected long maxAccessCount = Long.MAX_VALUE;

    /**
     * Interval time in milliseconds between crawling executions.
     */
    protected long crawlingExecutionInterval = Constants.DEFAULT_CRAWLING_EXECUTION_INTERVAL;

    /**
     * Thread priority for index updater operations.
     */

        dst[++dstIndex] = (byte) (val >> 8);
    }

    static long readTime(final byte[] src, final int srcIndex) {
        final int low = readInt4(src, srcIndex);
        final int hi = readInt4(src, srcIndex + 4);
        final long t = (long) hi << 32L | low & 0xFFFFFFFFL;
        return t / 10000L - MILLISECONDS_BETWEEN_1970_AND_1601;
    }

    static void writeTime(long t, final byte[] dst, final int dstIndex) {
        if (t != 0L) {

/**
 * @param <ENTITY> The type of entity.
 * @author ESFlute (using FreeGen)
 */
public class EsPagingResultBean<ENTITY> extends PagingResultBean<ENTITY> {

    private static final long serialVersionUID = 1L;

    protected long took;
    private int totalShards;
    private int successfulShards;
    private int failedShards;
    private TotalHits totalHits;
    private Aggregations aggregations;

        murmur3_128(0).hashString("The quick brown fox jumps over the lazy dog", UTF_8);
    assertEquals("6c1b07bc7bbc4be347939ac4a93c437a", foxHash.toString());
  }

  private static void assertHash(int seed, long expected1, long expected2, String stringInput) {
    HashCode expected = toHashCode(expected1, expected2);
    byte[] input = HashTestUtils.ascii(stringInput);
    assertEquals(expected, murmur3_128(seed).hashBytes(input));

     *
     * @return current position
     */
    long getFilePointer();

    /**
     * Seek to new position
     *
     * @param pos the new position to seek to
     */
    void seek(long pos);

    /**
     * Get the current file length
     *
     * @return file length
     * @throws SmbException if an I/O error occurs
     */
    long length() throws SmbException;

    /**