*/
    public static class FileInfo {
        private final String name;
        private final long size;
        private final long lastModified;
        private final boolean isDirectory;
        private final long attributes;
        private final long creationTime;
        private final long lastAccessTime;

        /**
         * Create file info from name and attributes
         *

   * 0} and {@code 2^64 - 1} inclusive.
   *
   * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated; use the
   * equivalent {@link Long#compareUnsigned(long, long)} method instead.
   *
   * @param a the first unsigned {@code long} to compare
   * @param b the second unsigned {@code long} to compare

        regOBD("_id");
        return this;
    }

    public void setEndTime_Equal(Long endTime) {
        setEndTime_Term(endTime, null);
    }

    public void setEndTime_Equal(Long endTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setEndTime_Term(endTime, opLambda);
    }

    public void setEndTime_Term(Long endTime) {
        setEndTime_Term(endTime, null);
    }

            private long docCount = 0;

            @Override
            public void store(DataStoreParams paramMap, Map<String, Object> dataMap) {
                docCount++;
            }

            @Override
            public long getDocumentSize() {
                return docCount;
            }

            @Override
            public long getExecuteTime() {
                return 0L;

        private final int attributes;
        private final long createTime;
        private final long lastModified;
        private final long lastAccess;
        private final long length;
        private final int fileIndex;

        TestFileEntry(String name, int type, int attributes, long createTime, long lastModified, long lastAccess, long length,
                int fileIndex) {
            this.name = name;

      byte[] bytes, int offset, long seedA, long seedB, long[] output) {
    long part1 = load64(bytes, offset);
    long part2 = load64(bytes, offset + 8);
    long part3 = load64(bytes, offset + 16);
    long part4 = load64(bytes, offset + 24);

    seedA += part1;
    seedB = rotateRight(seedB + seedA + part4, 51);
    long c = seedA;
    seedA += part2;
    seedA += part3;

        // Test various boundary values
        long[] testValues = { 0L, // Zero
                1L, // One
                -1L, // Negative one
                0x00000000FFFFFFFFL, // 32-bit max as long
                0xFFFFFFFF00000000L, // High 32 bits set
                0x7FFFFFFFFFFFFFFFL, // Long.MAX_VALUE
                0x8000000000000000L, // Long.MIN_VALUE
                0x0101010101010101L, // Repeating pattern

        return this;
    }

    public void setGidNumber_Equal(Long gidNumber) {
        setGidNumber_Term(gidNumber, null);
    }

    public void setGidNumber_Equal(Long gidNumber, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setGidNumber_Term(gidNumber, opLambda);
    }

    public void setGidNumber_Term(Long gidNumber) {
        setGidNumber_Term(gidNumber, null);
    }

            assertNotNull(lock);
        }

        @Test
        @DisplayName("Should create lock with maximum values")
        void testConstructorWithMaxValues() {
            long maxOffset = Long.MAX_VALUE;
            long maxLength = Long.MAX_VALUE;
            int flags = 0xFFFFFFFF;

            lock = new Smb2Lock(maxOffset, maxLength, flags);

            assertNotNull(lock);
        }

        @Test

            if (!timings.isEmpty()) {
                double avgTime = timings.stream().mapToLong(Long::longValue).average().orElse(0.0);
                long maxTime = timings.stream().mapToLong(Long::longValue).max().orElse(0L);
                long minTime = timings.stream().mapToLong(Long::longValue).min().orElse(0L);

                double variance = (maxTime - minTime) / avgTime;