From 480e984417c17915b31e33de193ff08e118fcec9 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Mar 2025 16:04:06 +0000
Subject: [PATCH 01/90] gh-249 Remove MDB_UNSIGNEDKEY, let CursorIterable call
 mdb_cmp

There are now essentially three ways of configuring comparators
when creating a Dbi.

**null comparator**
LMDB will use its own comparator & CursorIterable will call down
to mdb_cmp for comparisons between the current cursor key and the
range start/stop key.

**provided comparator**
LMDB will use its own comparator & CursorIterable will use the
provided comparator for comparisons between the current cursor
key and the range start/stop key.

**provided comparator with nativeCb==true**
LMDB will call back to java for all comparator duties.
CursorIterable will use the same provided comparator for
comparisons between the current cursor key and the range
start/stop key.

The methods `getSignedComparator()` and `getUnsignedComparator()`
have been made public so users of this library can access them.
---
 src/main/java/org/lmdbjava/BufferProxy.java   |  40 +-
 .../java/org/lmdbjava/ByteArrayProxy.java     |   4 +-
 src/main/java/org/lmdbjava/ByteBufProxy.java  |   4 +-
 .../java/org/lmdbjava/ByteBufferProxy.java    |   4 +-
 src/main/java/org/lmdbjava/Cursor.java        |   4 +
 .../java/org/lmdbjava/CursorIterable.java     | 403 +++++++++++-------
 src/main/java/org/lmdbjava/Dbi.java           |  15 +-
 src/main/java/org/lmdbjava/DbiFlags.java      |  21 +-
 .../java/org/lmdbjava/DirectBufferProxy.java  |   4 +-
 src/main/java/org/lmdbjava/Env.java           |  21 +-
 src/main/java/org/lmdbjava/Key.java           |  74 ++++
 src/main/java/org/lmdbjava/KeyRangeType.java  |  48 +--
 src/main/java/org/lmdbjava/Library.java       |   2 +
 .../java/org/lmdbjava/RangeComparator.java    |  19 +
 .../java/org/lmdbjava/ComparatorTest.java     |   8 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  | 163 +++++++
 .../java/org/lmdbjava/CursorIterableTest.java | 238 ++++++++---
 src/test/java/org/lmdbjava/DbiTest.java       |   4 +-
 src/test/java/org/lmdbjava/KeyRangeTest.java  |   5 +-
 src/test/java/org/lmdbjava/TestUtils.java     |   2 +
 20 files changed, 768 insertions(+), 315 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/Key.java
 create mode 100644 src/main/java/org/lmdbjava/RangeComparator.java
 create mode 100644 src/test/java/org/lmdbjava/CursorIterablePerfTest.java

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index e66031d2..26d9db74 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -16,10 +16,6 @@
 package org.lmdbjava;
 
 import static java.lang.Long.BYTES;
-import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
-import static org.lmdbjava.DbiFlags.MDB_UNSIGNEDKEY;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -70,36 +66,25 @@ protected BufferProxy() {}
    */
   protected abstract byte[] getBytes(T buffer);
 
-  /**
-   * Get a suitable default {@link Comparator} given the provided flags.
-   *
-   * <p>The provided comparator must strictly match the lexicographical order of keys in the native
-   * LMDB database.
-   *
-   * @param flags for the database
-   * @return a comparator that can be used (never null)
-   */
-  protected Comparator<T> getComparator(DbiFlags... flags) {
-    final int intFlag = mask(flags);
-
-    return isSet(intFlag, MDB_INTEGERKEY) || isSet(intFlag, MDB_UNSIGNEDKEY)
-        ? getUnsignedComparator()
-        : getSignedComparator();
-  }
-
   /**
    * Get a suitable default {@link Comparator} to compare numeric key values as signed.
    *
+   * <p>
+   * Note: LMDB's default comparator is unsigned so if this is used only for the {@link CursorIterable}
+   * start/stop key comparisons then its behaviour will differ from the iteration order. Use
+   * with caution.
+   * </p>
+   *
    * @return a comparator that can be used (never null)
    */
-  protected abstract Comparator<T> getSignedComparator();
+  public abstract Comparator<T> getSignedComparator();
 
   /**
    * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
    *
    * @return a comparator that can be used (never null)
    */
-  protected abstract Comparator<T> getUnsignedComparator();
+  public abstract Comparator<T> getUnsignedComparator();
 
   /**
    * Called when the <code>MDB_val</code> should be set to reflect the passed buffer. This buffer
@@ -140,4 +125,13 @@ protected Comparator<T> getComparator(DbiFlags... flags) {
   final KeyVal<T> keyVal() {
     return new KeyVal<>(this);
   }
+
+  /**
+   * Create a new {@link Key} to hold pointers for this buffer proxy.
+   *
+   * @return a non-null key holder
+   */
+  final Key<T> key() {
+    return new Key<>(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 4a22ab83..3aeba047 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -104,12 +104,12 @@ protected byte[] getBytes(final byte[] buffer) {
   }
 
   @Override
-  protected Comparator<byte[]> getSignedComparator() {
+  public Comparator<byte[]> getSignedComparator() {
     return signedComparator;
   }
 
   @Override
-  protected Comparator<byte[]> getUnsignedComparator() {
+  public Comparator<byte[]> getUnsignedComparator() {
     return unsignedComparator;
   }
 
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index cac5b97b..933b52a4 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -114,12 +114,12 @@ protected ByteBuf allocate() {
   }
 
   @Override
-  protected Comparator<ByteBuf> getSignedComparator() {
+  public Comparator<ByteBuf> getSignedComparator() {
     return comparator;
   }
 
   @Override
-  protected Comparator<ByteBuf> getUnsignedComparator() {
+  public Comparator<ByteBuf> getUnsignedComparator() {
     return comparator;
   }
 
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 2b7cdf0d..1fce090a 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -182,12 +182,12 @@ protected final ByteBuffer allocate() {
     }
 
     @Override
-    protected Comparator<ByteBuffer> getSignedComparator() {
+    public Comparator<ByteBuffer> getSignedComparator() {
       return signedComparator;
     }
 
     @Override
-    protected Comparator<ByteBuffer> getUnsignedComparator() {
+    public Comparator<ByteBuffer> getUnsignedComparator() {
       return unsignedComparator;
     }
 
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index d49a9bed..9070cff6 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -196,6 +196,10 @@ public T key() {
     return kv.key();
   }
 
+  KeyVal<T> keyVal() {
+    return kv;
+  }
+
   /**
    * Position at last key/data item.
    *
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 6a03bd90..6b92a9cd 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -21,10 +21,14 @@
 import static org.lmdbjava.CursorIterable.State.REQUIRES_NEXT_OP;
 import static org.lmdbjava.CursorIterable.State.TERMINATED;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
+import static org.lmdbjava.Library.LIB;
 
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.function.Supplier;
+import jnr.ffi.Pointer;
 import org.lmdbjava.KeyRangeType.CursorOp;
 import org.lmdbjava.KeyRangeType.IteratorOp;
 
@@ -38,185 +42,266 @@
  */
 public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T>>, AutoCloseable {
 
-  private final Comparator<T> comparator;
-  private final Cursor<T> cursor;
-  private final KeyVal<T> entry;
-  private boolean iteratorReturned;
-  private final KeyRange<T> range;
-  private State state = REQUIRES_INITIAL_OP;
-
-  CursorIterable(
-      final Txn<T> txn, final Dbi<T> dbi, final KeyRange<T> range, final Comparator<T> comparator) {
-    this.cursor = dbi.openCursor(txn);
-    this.range = range;
-    this.comparator = comparator;
-    this.entry = new KeyVal<>();
-  }
-
-  @Override
-  public void close() {
-    cursor.close();
-  }
-
-  /**
-   * Obtain an iterator.
-   *
-   * <p>As iteration of the returned iterator will cause movement of the underlying LMDB cursor, an
-   * {@link IllegalStateException} is thrown if an attempt is made to obtain the iterator more than
-   * once. For advanced cursor control (such as being able to iterate over the same data multiple
-   * times etc) please instead refer to {@link Dbi#openCursor(org.lmdbjava.Txn)}.
-   *
-   * @return an iterator
-   */
-  @Override
-  public Iterator<KeyVal<T>> iterator() {
-    if (iteratorReturned) {
-      throw new IllegalStateException("Iterator can only be returned once");
-    }
-    iteratorReturned = true;
+    //  private final Comparator<T> comparator;
+    private final RangeComparator rangeComparator;
+    private final Cursor<T> cursor;
+    private final Dbi<T> dbi;
+    private final KeyVal<T> entry;
+    private boolean iteratorReturned;
+    private final KeyRange<T> range;
+    private State state = REQUIRES_INITIAL_OP;
+    private final Key<T> startKey;
+    private final Key<T> stopKey;
 
-    return new Iterator<KeyVal<T>>() {
-      @Override
-      public boolean hasNext() {
-        while (state != RELEASED && state != TERMINATED) {
-          update();
-        }
-        return state == RELEASED;
-      }
+    CursorIterable(
+            final Txn<T> txn,
+            final Dbi<T> dbi,
+            final KeyRange<T> range,
+            final Comparator<T> comparator,
+            final BufferProxy<T> proxy) {
+        this.cursor = dbi.openCursor(txn);
+        this.dbi = dbi;
+        this.range = range;
+        this.entry = new KeyVal<>();
 
-      @Override
-      public KeyVal<T> next() {
-        if (!hasNext()) {
-          throw new NoSuchElementException();
+        if (comparator != null) {
+            // User supplied java-side comparator so use that
+            this.rangeComparator = createJavaRangeComparator(range, comparator, entry::key);
+            this.startKey = null;
+            this.stopKey = null;
+        } else {
+            // No java-side comparator so call down to LMDB to do the comparison
+            this.rangeComparator = createLmdbDbiComparator(txn.pointer(), dbi.pointer());
+            // Allocate buffers for use with the start/stop keys if required.
+            // Saves us copying bytes on each comparison
+            this.startKey = createKey(range.getStart(), proxy);
+            this.stopKey = createKey(range.getStop(), proxy);
         }
-        state = REQUIRES_NEXT_OP;
-        return entry;
-      }
-
-      @Override
-      public void remove() {
-        cursor.delete();
-      }
-    };
-  }
-
-  private void executeCursorOp(final CursorOp op) {
-    final boolean found;
-    switch (op) {
-      case FIRST:
-        found = cursor.first();
-        break;
-      case LAST:
-        found = cursor.last();
-        break;
-      case NEXT:
-        found = cursor.next();
-        break;
-      case PREV:
-        found = cursor.prev();
-        break;
-      case GET_START_KEY:
-        found = cursor.get(range.getStart(), MDB_SET_RANGE);
-        break;
-      case GET_START_KEY_BACKWARD:
-        found = cursor.get(range.getStart(), MDB_SET_RANGE) || cursor.last();
-        break;
-      default:
-        throw new IllegalStateException("Unknown cursor operation");
     }
-    entry.setK(found ? cursor.key() : null);
-    entry.setV(found ? cursor.val() : null);
-  }
-
-  private void executeIteratorOp() {
-    final IteratorOp op =
-        range.getType().iteratorOp(range.getStart(), range.getStop(), entry.key(), comparator);
-    switch (op) {
-      case CALL_NEXT_OP:
-        executeCursorOp(range.getType().nextOp());
-        state = REQUIRES_ITERATOR_OP;
-        break;
-      case TERMINATE:
-        state = TERMINATED;
-        break;
-      case RELEASE:
-        state = RELEASED;
-        break;
-      default:
-        throw new IllegalStateException("Unknown operation");
+
+    private Key<T> createKey(final T keyBuffer, final BufferProxy<T> proxy) {
+        if (keyBuffer != null) {
+            final Key<T> key = proxy.key();
+            key.keyIn(keyBuffer);
+            return key;
+        } else {
+            return null;
+        }
     }
-  }
-
-  private void update() {
-    switch (state) {
-      case REQUIRES_INITIAL_OP:
-        executeCursorOp(range.getType().initialOp());
-        state = REQUIRES_ITERATOR_OP;
-        break;
-      case REQUIRES_NEXT_OP:
-        executeCursorOp(range.getType().nextOp());
-        state = REQUIRES_ITERATOR_OP;
-        break;
-      case REQUIRES_ITERATOR_OP:
-        executeIteratorOp();
-        break;
-      case TERMINATED:
-        break;
-      default:
-        throw new IllegalStateException("Unknown state");
+
+    static <T> RangeComparator createJavaRangeComparator(
+            final KeyRange<T> range,
+            final Comparator<T> comparator,
+            final Supplier<T> currentKeySupplier) {
+        final T start = range.getStart();
+        final T stop = range.getStop();
+        return new RangeComparator() {
+            @Override
+            public int compareToStartKey() {
+                return comparator.compare(currentKeySupplier.get(), start);
+            }
+
+            @Override
+            public int compareToStopKey() {
+                return comparator.compare(currentKeySupplier.get(), stop);
+            }
+        };
     }
-  }
 
-  /**
-   * Holder for a key and value pair.
-   *
-   * <p>The same holder instance will always be returned for a given iterator. The returned keys and
-   * values may change or point to different memory locations following changes in the iterator,
-   * cursor or transaction.
-   *
-   * @param <T> buffer type
-   */
-  public static final class KeyVal<T> {
+    /**
+     * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order.
+     *
+     * @param txnPointer The pointer to the transaction.
+     * @param dbiPointer The pointer to the Dbi so LMDB can use the comparator of the Dbi
+     */
+    private RangeComparator createLmdbDbiComparator(
+            final Pointer txnPointer, final Pointer dbiPointer) {
+        Objects.requireNonNull(txnPointer);
+        Objects.requireNonNull(dbiPointer);
+        Objects.requireNonNull(cursor);
+
+        return new RangeComparator() {
+            @Override
+            public int compareToStartKey() {
+                return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(), startKey.pointerKey());
+            }
 
-    private T k;
-    private T v;
+            @Override
+            public int compareToStopKey() {
+                return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(), stopKey.pointerKey());
+            }
+        };
+    }
 
-    /** Explicitly-defined default constructor to avoid warnings. */
-    public KeyVal() {}
+    @Override
+    public void close() {
+        cursor.close();
+    }
 
     /**
-     * The key.
+     * Obtain an iterator.
+     *
+     * <p>As iteration of the returned iterator will cause movement of the underlying LMDB cursor, an
+     * {@link IllegalStateException} is thrown if an attempt is made to obtain the iterator more than
+     * once. For advanced cursor control (such as being able to iterate over the same data multiple
+     * times etc) please instead refer to {@link Dbi#openCursor(org.lmdbjava.Txn)}.
      *
-     * @return key
+     * @return an iterator
      */
-    public T key() {
-      return k;
+    @Override
+    public Iterator<KeyVal<T>> iterator() {
+        if (iteratorReturned) {
+            throw new IllegalStateException("Iterator can only be returned once");
+        }
+        iteratorReturned = true;
+
+        return new Iterator<KeyVal<T>>() {
+            @Override
+            public boolean hasNext() {
+                while (state != RELEASED && state != TERMINATED) {
+                    update();
+                }
+                return state == RELEASED;
+            }
+
+            @Override
+            public KeyVal<T> next() {
+                if (!hasNext()) {
+                    throw new NoSuchElementException();
+                }
+                state = REQUIRES_NEXT_OP;
+                return entry;
+            }
+
+            @Override
+            public void remove() {
+                cursor.delete();
+            }
+        };
+    }
+
+    private void executeCursorOp(final CursorOp op) {
+        final boolean found;
+        switch (op) {
+            case FIRST:
+                found = cursor.first();
+                break;
+            case LAST:
+                found = cursor.last();
+                break;
+            case NEXT:
+                found = cursor.next();
+                break;
+            case PREV:
+                found = cursor.prev();
+                break;
+            case GET_START_KEY:
+                found = cursor.get(range.getStart(), MDB_SET_RANGE);
+                break;
+            case GET_START_KEY_BACKWARD:
+                found = cursor.get(range.getStart(), MDB_SET_RANGE) || cursor.last();
+                break;
+            default:
+                throw new IllegalStateException("Unknown cursor operation");
+        }
+        entry.setK(found ? cursor.key() : null);
+        entry.setV(found ? cursor.val() : null);
+    }
+
+    private void executeIteratorOp() {
+        final IteratorOp op =
+                range.getType().iteratorOp(range.getStart(), range.getStop(), entry.key(), rangeComparator);
+        switch (op) {
+            case CALL_NEXT_OP:
+                executeCursorOp(range.getType().nextOp());
+                state = REQUIRES_ITERATOR_OP;
+                break;
+            case TERMINATE:
+                state = TERMINATED;
+                break;
+            case RELEASE:
+                state = RELEASED;
+                break;
+            default:
+                throw new IllegalStateException("Unknown operation");
+        }
+    }
+
+    private void update() {
+        switch (state) {
+            case REQUIRES_INITIAL_OP:
+                executeCursorOp(range.getType().initialOp());
+                state = REQUIRES_ITERATOR_OP;
+                break;
+            case REQUIRES_NEXT_OP:
+                executeCursorOp(range.getType().nextOp());
+                state = REQUIRES_ITERATOR_OP;
+                break;
+            case REQUIRES_ITERATOR_OP:
+                executeIteratorOp();
+                break;
+            case TERMINATED:
+                break;
+            default:
+                throw new IllegalStateException("Unknown state");
+        }
     }
 
     /**
-     * The value.
+     * Holder for a key and value pair.
+     *
+     * <p>The same holder instance will always be returned for a given iterator. The returned keys and
+     * values may change or point to different memory locations following changes in the iterator,
+     * cursor or transaction.
      *
-     * @return value
+     * @param <T> buffer type
      */
-    public T val() {
-      return v;
-    }
+    public static final class KeyVal<T> {
+
+        private T k;
+        private T v;
+
+        /**
+         * Explicitly-defined default constructor to avoid warnings.
+         */
+        public KeyVal() {
+        }
+
+        /**
+         * The key.
+         *
+         * @return key
+         */
+        public T key() {
+            return k;
+        }
+
+        /**
+         * The value.
+         *
+         * @return value
+         */
+        public T val() {
+            return v;
+        }
 
-    void setK(final T key) {
-      this.k = key;
+        void setK(final T key) {
+            this.k = key;
+        }
+
+        void setV(final T val) {
+            this.v = val;
+        }
     }
 
-    void setV(final T val) {
-      this.v = val;
+    /**
+     * Represents the internal {@link CursorIterable} state.
+     */
+    enum State {
+        REQUIRES_INITIAL_OP,
+        REQUIRES_NEXT_OP,
+        REQUIRES_ITERATOR_OP,
+        RELEASED,
+        TERMINATED
     }
-  }
-
-  /** Represents the internal {@link CursorIterable} state. */
-  enum State {
-    REQUIRES_INITIAL_OP,
-    REQUIRES_NEXT_OP,
-    REQUIRES_ITERATOR_OP,
-    RELEASED,
-    TERMINATED
-  }
 }
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index ad1bb5a7..c622462b 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -54,6 +54,7 @@ public final class Dbi<T> {
   private final Env<T> env;
   private final byte[] name;
   private final Pointer ptr;
+  private final BufferProxy<T> proxy;
 
   Dbi(
       final Env<T> env,
@@ -69,16 +70,14 @@ public final class Dbi<T> {
     }
     this.env = env;
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
-    if (comparator == null) {
-      this.comparator = proxy.getComparator(flags);
-    } else {
-      this.comparator = comparator;
-    }
+    this.proxy = proxy;
+    this.comparator = comparator;
     final int flagsMask = mask(true, flags);
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
     checkRc(LIB.mdb_dbi_open(txn.pointer(), name, flagsMask, dbiPtr));
     ptr = dbiPtr.getPointer(0);
     if (nativeCb) {
+      requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
       this.ccb =
           (keyA, keyB) -> {
             final T compKeyA = proxy.allocate();
@@ -96,6 +95,10 @@ public final class Dbi<T> {
     }
   }
 
+  Pointer pointer() {
+    return ptr;
+  }
+
   /**
    * Close the database handle (normally unnecessary; use with caution).
    *
@@ -275,7 +278,7 @@ public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
       env.checkNotClosed();
       txn.checkReady();
     }
-    return new CursorIterable<>(txn, this, range, comparator);
+    return new CursorIterable<>(txn, this, range, comparator, proxy);
   }
 
   /**
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 123ec9fd..2f5eadf6 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -55,14 +55,6 @@ public enum DbiFlags implements MaskedFlag {
    * #MDB_INTEGERKEY} keys.
    */
   MDB_INTEGERDUP(0x20),
-  /**
-   * Compare the <b>numeric</b> keys in native byte order and as unsigned.
-   *
-   * <p>This option is applied only to {@link java.nio.ByteBuffer}, {@link org.agrona.DirectBuffer}
-   * and byte array keys. {@link io.netty.buffer.ByteBuf} keys are always compared in native byte
-   * order and as unsigned.
-   */
-  MDB_UNSIGNEDKEY(0x30, false),
   /**
    * With {@link #MDB_DUPSORT}, use reverse string dups.
    *
@@ -78,24 +70,13 @@ public enum DbiFlags implements MaskedFlag {
   MDB_CREATE(0x4_0000);
 
   private final int mask;
-  private final boolean propagatedToLmdb;
-
-  DbiFlags(final int mask, final boolean propagatedToLmdb) {
-    this.mask = mask;
-    this.propagatedToLmdb = propagatedToLmdb;
-  }
 
   DbiFlags(final int mask) {
-    this(mask, true);
+    this.mask = mask;
   }
 
   @Override
   public int getMask() {
     return mask;
   }
-
-  @Override
-  public boolean isPropagatedToLmdb() {
-    return propagatedToLmdb;
-  }
 }
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 156e60e9..5022ed02 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -111,12 +111,12 @@ protected DirectBuffer allocate() {
   }
 
   @Override
-  protected Comparator<DirectBuffer> getSignedComparator() {
+  public Comparator<DirectBuffer> getSignedComparator() {
     return signedComparator;
   }
 
   @Override
-  protected Comparator<DirectBuffer> getUnsignedComparator() {
+  public Comparator<DirectBuffer> getUnsignedComparator() {
     return unsignedComparator;
   }
 
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 3db16119..1543282c 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -256,10 +256,17 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
 
   /**
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator} that is not invoked from native code.
+   * Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
+   * <p>
+   * It is very important that the passed comparator behaves in the same way as the comparator
+   * LMDB uses for its insertion order (for the type of data that will be stored in the database),
+   * or you fully understand the implications of them behaving differently.
+   * LMDB's comparator is unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is used.
+   * </p>
    *
    * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use default)
+   * @param comparator custom comparator for cursor start/stop key comparisons. If null,
+   *                   LMDB's comparator will be used.
    * @param flags to open the database with
    * @return a database that is ready to use
    */
@@ -271,11 +278,15 @@ public Dbi<T> openDbi(
 
   /**
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator} that may be invoked from native code if specified.
+   * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop keys
+   * as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to determine
+   * insertion/iteration order. Calling back to a java comparator may significantly impact performance.
    *
    * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use default)
-   * @param nativeCb whether native code calls back to the Java comparator
+   * @param comparator custom comparator for cursor start/stop key comparisons and optionally for
+   *                   LMDB to call back to. If null,
+   *                   LMDB's comparator will be used.
+   * @param nativeCb whether LMDB native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
    */
diff --git a/src/main/java/org/lmdbjava/Key.java b/src/main/java/org/lmdbjava/Key.java
new file mode 100644
index 00000000..7fd8bbe2
--- /dev/null
+++ b/src/main/java/org/lmdbjava/Key.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static java.util.Objects.requireNonNull;
+import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
+import static org.lmdbjava.Library.RUNTIME;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.provider.MemoryManager;
+
+/**
+ * Represents off-heap memory holding a key only.
+ *
+ * @param <T> buffer type
+ */
+final class Key<T> implements AutoCloseable {
+
+  private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
+  private boolean closed;
+  private T k;
+  private final BufferProxy<T> proxy;
+  private final Pointer ptrArray;
+  private final Pointer ptrKey;
+  private final long ptrKeyAddr;
+
+  Key(final BufferProxy<T> proxy) {
+    requireNonNull(proxy);
+    this.proxy = proxy;
+    this.k = proxy.allocate();
+    ptrKey = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE, false);
+    ptrKeyAddr = ptrKey.address();
+    ptrArray = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE * 2, false);
+  }
+
+  @Override
+  public void close() {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    proxy.deallocate(k);
+  }
+
+  T key() {
+    return k;
+  }
+
+  void keyIn(final T key) {
+    proxy.in(key, ptrKey, ptrKeyAddr);
+  }
+
+  T keyOut() {
+    k = proxy.out(k, ptrKey, ptrKeyAddr);
+    return k;
+  }
+
+  Pointer pointerKey() {
+    return ptrKey;
+  }
+}
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index ad67286d..07123e9a 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -322,12 +322,12 @@ CursorOp initialOp() {
    * @param start start buffer
    * @param stop stop buffer
    * @param buffer current key returned by LMDB (may be null)
-   * @param c comparator (required)
+   * @param rangeComparator comparator (required)
    * @return response to this key
    */
   <T, C extends Comparator<T>> IteratorOp iteratorOp(
-      final T start, final T stop, final T buffer, final C c) {
-    requireNonNull(c, "Comparator required");
+      final T start, final T stop, final T buffer, final RangeComparator rangeComparator) {
+    requireNonNull(rangeComparator, "Comparator required");
     if (buffer == null) {
       return TERMINATE;
     }
@@ -337,55 +337,55 @@ <T, C extends Comparator<T>> IteratorOp iteratorOp(
       case FORWARD_AT_LEAST:
         return RELEASE;
       case FORWARD_AT_MOST:
-        return c.compare(buffer, stop) > 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() > 0 ? TERMINATE : RELEASE;
       case FORWARD_CLOSED:
-        return c.compare(buffer, stop) > 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() > 0 ? TERMINATE : RELEASE;
       case FORWARD_CLOSED_OPEN:
-        return c.compare(buffer, stop) >= 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() >= 0 ? TERMINATE : RELEASE;
       case FORWARD_GREATER_THAN:
-        return c.compare(buffer, start) == 0 ? CALL_NEXT_OP : RELEASE;
+        return rangeComparator.compareToStartKey() == 0 ? CALL_NEXT_OP : RELEASE;
       case FORWARD_LESS_THAN:
-        return c.compare(buffer, stop) >= 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() >= 0 ? TERMINATE : RELEASE;
       case FORWARD_OPEN:
-        if (c.compare(buffer, start) == 0) {
+        if (rangeComparator.compareToStartKey() == 0) {
           return CALL_NEXT_OP;
         }
-        return c.compare(buffer, stop) >= 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() >= 0 ? TERMINATE : RELEASE;
       case FORWARD_OPEN_CLOSED:
-        if (c.compare(buffer, start) == 0) {
+        if (rangeComparator.compareToStartKey() == 0) {
           return CALL_NEXT_OP;
         }
-        return c.compare(buffer, stop) > 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() > 0 ? TERMINATE : RELEASE;
       case BACKWARD_ALL:
         return RELEASE;
       case BACKWARD_AT_LEAST:
-        return c.compare(buffer, start) > 0 ? CALL_NEXT_OP : RELEASE; // rewind
+        return rangeComparator.compareToStartKey() > 0 ? CALL_NEXT_OP : RELEASE; // rewind
       case BACKWARD_AT_MOST:
-        return c.compare(buffer, stop) >= 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() >= 0 ? RELEASE : TERMINATE;
       case BACKWARD_CLOSED:
-        if (c.compare(buffer, start) > 0) {
+        if (rangeComparator.compareToStartKey() > 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) >= 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() >= 0 ? RELEASE : TERMINATE;
       case BACKWARD_CLOSED_OPEN:
-        if (c.compare(buffer, start) > 0) {
+        if (rangeComparator.compareToStartKey() > 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) > 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() > 0 ? RELEASE : TERMINATE;
       case BACKWARD_GREATER_THAN:
-        return c.compare(buffer, start) >= 0 ? CALL_NEXT_OP : RELEASE;
+        return rangeComparator.compareToStartKey() >= 0 ? CALL_NEXT_OP : RELEASE;
       case BACKWARD_LESS_THAN:
-        return c.compare(buffer, stop) > 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() > 0 ? RELEASE : TERMINATE;
       case BACKWARD_OPEN:
-        if (c.compare(buffer, start) >= 0) {
+        if (rangeComparator.compareToStartKey() >= 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) > 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() > 0 ? RELEASE : TERMINATE;
       case BACKWARD_OPEN_CLOSED:
-        if (c.compare(buffer, start) >= 0) {
+        if (rangeComparator.compareToStartKey() >= 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) >= 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() >= 0 ? RELEASE : TERMINATE;
       default:
         throw new IllegalStateException("Invalid type");
     }
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index ef9b9b35..6d8122d2 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -235,6 +235,8 @@ public interface Lmdb {
 
     void mdb_txn_reset(@In Pointer txn);
 
+    int mdb_cmp(@In Pointer txn, @In Pointer dbi, @In Pointer key1, @In Pointer key2);
+
     Pointer mdb_version(IntByReference major, IntByReference minor, IntByReference patch);
   }
 }
diff --git a/src/main/java/org/lmdbjava/RangeComparator.java b/src/main/java/org/lmdbjava/RangeComparator.java
new file mode 100644
index 00000000..162584b1
--- /dev/null
+++ b/src/main/java/org/lmdbjava/RangeComparator.java
@@ -0,0 +1,19 @@
+package org.lmdbjava;
+
+/**
+ * For comparing a cursor's current key against a {@link KeyRange}'s start/stop key.
+ */
+interface RangeComparator {
+
+    /**
+     * Compare the cursor's current key to the range start key. Equivalent to compareTo(currentKey,
+     * startKey)
+     */
+    int compareToStartKey();
+
+    /**
+     * Compare the cursor's current key to the range stop key. Equivalent to compareTo(currentKey,
+     * stopKey)
+     */
+    int compareToStopKey();
+}
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 3e265cee..dad84ed2 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -135,7 +135,7 @@ private static final class ByteArrayRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final Comparator<byte[]> c = PROXY_BA.getComparator();
+      final Comparator<byte[]> c = PROXY_BA.getUnsignedComparator();
       return c.compare(o1, o2);
     }
   }
@@ -145,7 +145,7 @@ private static final class ByteBufferRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getComparator();
+      final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getUnsignedComparator();
 
       // Convert arrays to buffers that are larger than the array, with
       // limit set at the array length. One buffer bigger than the other.
@@ -189,7 +189,7 @@ private static final class DirectBufferRunner implements ComparatorRunner {
     public int compare(final byte[] o1, final byte[] o2) {
       final DirectBuffer o1b = new UnsafeBuffer(o1);
       final DirectBuffer o2b = new UnsafeBuffer(o2);
-      final Comparator<DirectBuffer> c = PROXY_DB.getComparator();
+      final Comparator<DirectBuffer> c = PROXY_DB.getUnsignedComparator();
       return c.compare(o1b, o2b);
     }
   }
@@ -223,7 +223,7 @@ public int compare(final byte[] o1, final byte[] o2) {
       final ByteBuf o2b = DEFAULT.directBuffer(o2.length);
       o1b.writeBytes(o1);
       o2b.writeBytes(o2);
-      final Comparator<ByteBuf> c = PROXY_NETTY.getComparator();
+      final Comparator<ByteBuf> c = PROXY_NETTY.getUnsignedComparator();
       return c.compare(o1b, o2b);
     }
   }
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
new file mode 100644
index 00000000..a9647d56
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -0,0 +1,163 @@
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.GIBIBYTES;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.PutFlags.MDB_APPEND;
+import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+public class CursorIterablePerfTest {
+
+    @Rule
+    public final TemporaryFolder tmp = new TemporaryFolder();
+
+//    private static final int ITERATIONS = 5_000_000;
+    private static final int ITERATIONS = 100_000;
+//    private static final int ITERATIONS = 10;
+
+    private Dbi<ByteBuffer> dbJavaComparator;
+    private Dbi<ByteBuffer> dbLmdbComparator;
+    private Dbi<ByteBuffer> dbCallbackComparator;
+    private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+    private Env<ByteBuffer> env;
+    private List<Integer> data = new ArrayList<>(ITERATIONS);
+
+    @Before
+    public void before() throws IOException {
+        final File path = tmp.newFile();
+        final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+        env =
+                create(bufferProxy)
+                        .setMapSize(GIBIBYTES.toBytes(1))
+                        .setMaxReaders(1)
+                        .setMaxDbs(3)
+                        .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+        // Use a java comparator for start/stop keys only
+        dbJavaComparator = env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
+        // Use LMDB comparator for start/stop keys
+        dbLmdbComparator = env.openDbi("LmdbComparator", MDB_CREATE);
+        // Use a java comparator for start/stop keys and as a callback comparator
+        dbCallbackComparator = env.openDbi(
+                "CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+
+        dbs.add(dbJavaComparator);
+        dbs.add(dbLmdbComparator);
+        dbs.add(dbCallbackComparator);
+
+        populateList();
+    }
+
+    private void populateList() {
+        for (int i = 0; i < ITERATIONS * 2; i+=2) {
+            data.add(i);
+        }
+    }
+
+    private void populateDatabases(final boolean randomOrder) {
+        System.out.println("Clear then populate databases");
+
+        final List<Integer> data;
+        if (randomOrder) {
+            data = new ArrayList<>(this.data);
+            Collections.shuffle(data);
+        } else {
+            data = this.data;
+        }
+
+        for (int round = 0; round < 3; round++) {
+            System.out.println("round: " + round + " -----------------------------------------");
+
+            for (final Dbi<ByteBuffer> db : dbs) {
+                // Clean out the db first
+                try (Txn<ByteBuffer> txn = env.txnWrite();
+                     final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
+                    while (cursor.next()) {
+                        cursor.delete();
+                    }
+                }
+
+                final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+                final Instant start = Instant.now();
+                try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                    for (final Integer i : data) {
+                        if (randomOrder) {
+                            db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE);
+                        } else {
+                            db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE, MDB_APPEND);
+                        }
+                    }
+                    txn.commit();
+                }
+                final Duration duration = Duration.between(start, Instant.now());
+                System.out.println("DB: " + dbName
+                        + " - Loaded in duration: " + duration
+                        + ", millis: " + duration.toMillis());
+            }
+        }
+    }
+
+    @After
+    public void after() {
+        env.close();
+        tmp.delete();
+    }
+
+    @Test
+    public void comparePerf_sequential() {
+        comparePerf(false);
+    }
+
+    @Test
+    public void comparePerf_random() {
+        comparePerf(true);
+    }
+
+    public void comparePerf(final boolean randomOrder) {
+        populateDatabases(randomOrder);
+        final ByteBuffer startKeyBuf = bb(data.getFirst());
+        final ByteBuffer stopKeyBuf = bb(data.getLast());
+        final KeyRange<ByteBuffer> keyRange = KeyRange.closed(startKeyBuf, stopKeyBuf);
+
+        System.out.println("\nIterating over all entries");
+        for (int round = 0; round < 3; round++) {
+            System.out.println("round: " + round + " -----------------------------------------");
+            for (final Dbi<ByteBuffer> db : dbs) {
+                final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+
+                final Instant start = Instant.now();
+                int cnt = 0;
+                // Exercise the stop key comparator on every entry
+                try (Txn<ByteBuffer> txn = env.txnRead();
+                     CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+                    for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+                        cnt++;
+                    }
+                }
+                final Duration duration = Duration.between(start, Instant.now());
+                System.out.println("DB: " + dbName
+                        + " - Iterated in duration: " + duration
+                        + ", millis: " + duration.toMillis()
+                        + ", cnt: " + cnt);
+            }
+        }
+    }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index bd23bc55..96be0816 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -43,6 +43,8 @@
 import static org.lmdbjava.KeyRange.openClosedBackward;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
 import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.DB_2;
+import static org.lmdbjava.TestUtils.DB_3;
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
@@ -69,7 +71,10 @@
 public final class CursorIterableTest {
 
   @Rule public final TemporaryFolder tmp = new TemporaryFolder();
-  private Dbi<ByteBuffer> db;
+  private Dbi<ByteBuffer> dbJavaComparator;
+  private Dbi<ByteBuffer> dbLmdbComparator;
+  private Dbi<ByteBuffer> dbCallbackComparator;
+  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
@@ -116,19 +121,39 @@ public void atMostTest() {
   @Before
   public void before() throws IOException {
     final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env =
-        create()
+        create(bufferProxy)
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
-            .setMaxDbs(1)
+            .setMaxDbs(3)
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
-    db = env.openDbi(DB_1, MDB_CREATE);
-    populateDatabase(db);
+
+    // Use a java comparator for start/stop keys only
+    dbJavaComparator = env.openDbi(DB_1, bufferProxy.getUnsignedComparator(), MDB_CREATE);
+    // Use LMDB comparator for start/stop keys
+    dbLmdbComparator = env.openDbi(DB_2, MDB_CREATE);
+    // Use a java comparator for start/stop keys and as a callback comparaotr
+    dbCallbackComparator = env.openDbi(
+            DB_3, bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+
+    populateList();
+
+    populateDatabase(dbJavaComparator);
+    populateDatabase(dbLmdbComparator);
+    populateDatabase(dbCallbackComparator);
+
+    dbs.add(dbJavaComparator);
+    dbs.add(dbLmdbComparator);
+    dbs.add(dbCallbackComparator);
   }
 
-  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+  private void populateList() {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       c.put(bb(2), bb(3), MDB_NOOVERWRITE);
@@ -166,6 +191,14 @@ public void closedTest() {
     verify(closed(bb(1), bb(7)), 2, 4, 6);
   }
 
+  public void closedTest1() {
+    verify(dbLmdbComparator, closed(bb(3), bb(7)), 4, 6);
+  }
+
+  public void closedTest2() {
+    verify(dbJavaComparator, closed(bb(3), bb(7)), 4, 6);
+  }
+
   @Test
   public void greaterThanBackwardTest() {
     verify(greaterThanBackward(bb(6)), 4, 2);
@@ -181,30 +214,39 @@ public void greaterThanTest() {
 
   @Test(expected = IllegalStateException.class)
   public void iterableOnlyReturnedOnce() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-      c.iterator(); // ok
-      c.iterator(); // fails
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        c.iterator(); // ok
+        c.iterator(); // fails
+      }
     }
   }
 
   @Test
   public void iterate() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-      for (final KeyVal<ByteBuffer> kv : c) {
-        assertThat(kv.key().getInt(), is(list.pollFirst()));
-        assertThat(kv.val().getInt(), is(list.pollFirst()));
+    for (final Dbi<ByteBuffer> db : dbs) {
+      populateList();
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+
+        int cnt = 0;
+        for (final KeyVal<ByteBuffer> kv : c) {
+          assertThat(kv.key().getInt(), is(list.pollFirst()));
+          assertThat(kv.val().getInt(), is(list.pollFirst()));
+        }
       }
     }
   }
 
   @Test(expected = IllegalStateException.class)
   public void iteratorOnlyReturnedOnce() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-      c.iterator(); // ok
-      c.iterator(); // fails
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        c.iterator(); // ok
+        c.iterator(); // fails
+      }
     }
   }
 
@@ -222,16 +264,19 @@ public void lessThanTest() {
 
   @Test(expected = NoSuchElementException.class)
   public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-      final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
-      while (i.hasNext()) {
-        final KeyVal<ByteBuffer> kv = i.next();
-        assertThat(kv.key().getInt(), is(list.pollFirst()));
-        assertThat(kv.val().getInt(), is(list.pollFirst()));
+    for (final Dbi<ByteBuffer> db : dbs) {
+      populateList();
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+        while (i.hasNext()) {
+          final KeyVal<ByteBuffer> kv = i.next();
+          assertThat(kv.key().getInt(), is(list.pollFirst()));
+          assertThat(kv.val().getInt(), is(list.pollFirst()));
+        }
+        assertThat(i.hasNext(), is(false));
+        i.next();
       }
-      assertThat(i.hasNext(), is(false));
-      i.next();
     }
   }
 
@@ -284,81 +329,148 @@ public void openTest() {
 
   @Test
   public void removeOddElements() {
-    verify(all(), 2, 4, 6, 8);
-    int idx = -1;
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-        while (c.hasNext()) {
-          c.next();
-          idx++;
-          if (idx % 2 == 0) {
-            c.remove();
+    for (final Dbi<ByteBuffer> db : dbs) {
+      verify(db, all(), 2, 4, 6, 8);
+      int idx = -1;
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+          while (c.hasNext()) {
+            c.next();
+            idx++;
+            if (idx % 2 == 0) {
+              c.remove();
+            }
           }
         }
+        txn.commit();
       }
-      txn.commit();
+      verify(db, all(), 4, 8);
     }
-    verify(all(), 4, 8);
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void nextWithClosedEnvTest() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-        env.close();
-        c.next();
+          env.close();
+          c.next();
+        }
       }
     }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void removeWithClosedEnvTest() {
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-        final KeyVal<ByteBuffer> keyVal = c.next();
-        assertThat(keyVal, Matchers.notNullValue());
+          final KeyVal<ByteBuffer> keyVal = c.next();
+          assertThat(keyVal, Matchers.notNullValue());
 
-        env.close();
-        c.remove();
+          env.close();
+          c.remove();
+        }
       }
     }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void hasNextWithClosedEnvTest() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-        env.close();
-        c.hasNext();
+          env.close();
+          c.hasNext();
+        }
       }
     }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void forEachRemainingWithClosedEnvTest() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-        env.close();
-        c.forEachRemaining(keyVal -> {});
+          env.close();
+          c.forEachRemaining(keyVal -> {});
+        }
+      }
+    }
+  }
+
+  @Test
+  public void testSignedVsUnsigned() {
+    final ByteBuffer val1 = bb(1);
+    final ByteBuffer val2 = bb(2);
+    final ByteBuffer val110 = bb(110);
+    final ByteBuffer val111 = bb(111);
+    final ByteBuffer val150 = bb(150);
+
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
+    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
+
+    // Compare the same
+    assertThat(
+            unsignedComparator.compare(val1, val2),
+            Matchers.is(signedComparator.compare(val1, val2)));
+
+    // Compare differently
+    assertThat(
+            unsignedComparator.compare(val110, val150),
+            Matchers.not(signedComparator.compare(val110, val150)));
+
+    // Compare differently
+    assertThat(
+            unsignedComparator.compare(val111, val150),
+            Matchers.not(signedComparator.compare(val111, val150)));
+
+    // This will fail if the db is using a signed comparator for the start/stop keys
+    for (final Dbi<ByteBuffer> db : dbs) {
+      db.put(val110, val110);
+      db.put(val150, val150);
+
+      final ByteBuffer startKeyBuf = val111;
+      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
+
+      try (Txn<ByteBuffer> txn = env.txnRead();
+           CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+        for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+          final int key = kv.key().getInt();
+          final int val = kv.val().getInt();
+//          System.out.println("key: " + key + " val: " + val);
+          assertThat(key, is(110));
+          break;
+        }
       }
     }
   }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
-    verify(range, db, expected);
+    // Verify using all comparator types
+    for (final Dbi<ByteBuffer> db : dbs) {
+      verify(range, db, expected);
+    }
+  }
+
+  private void verify(
+      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expected) {
+    verify(range, dbi, expected);
   }
 
   private void verify(
       final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
+
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 1fa80f6e..9c5cdb2e 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -111,7 +111,7 @@ public void close() {
   public void customComparator() {
     final Comparator<ByteBuffer> reverseOrder =
         (o1, o2) -> {
-          final int lexical = PROXY_OPTIMAL.getComparator().compare(o1, o2);
+          final int lexical = PROXY_OPTIMAL.getUnsignedComparator().compare(o1, o2);
           if (lexical == 0) {
             return 0;
           }
@@ -144,7 +144,7 @@ public void dbOpenMaxDatabases() {
   @Test
   public void dbiWithComparatorThreadSafety() {
     final DbiFlags[] flags = new DbiFlags[] {MDB_CREATE, MDB_INTEGERKEY};
-    final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getComparator(flags);
+    final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getUnsignedComparator();
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, c, true, flags);
 
     final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index 6e104bbf..0197bf11 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -195,7 +195,10 @@ private void verify(final KeyRange<Integer> range, final int... expected) {
 
     IteratorOp op;
     do {
-      op = range.getType().iteratorOp(range.getStart(), range.getStop(), buff, Integer::compare);
+      final Integer finalBuff = buff;
+      final RangeComparator rangeComparator =
+          CursorIterable.createJavaRangeComparator(range, Integer::compareTo, () -> finalBuff);
+      op = range.getType().iteratorOp(range.getStart(), range.getStop(), buff, rangeComparator);
       switch (op) {
         case CALL_NEXT_OP:
           buff = cursor.apply(range.getType().nextOp(), range.getStart());
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 42dcf052..f3d3974b 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -30,6 +30,8 @@
 final class TestUtils {
 
   public static final String DB_1 = "test-db-1";
+  public static final String DB_2 = "test-db-2";
+  public static final String DB_3 = "test-db-3";
 
   public static final int POSIX_MODE = 0664;
 

From 46f8d08194d989529f87b447f48fad0214c10e80 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Mar 2025 17:27:25 +0000
Subject: [PATCH 02/90] gh-249 Remove non-J8 features, use indent size 2

---
 .../org/lmdbjava/CursorIterablePerfTest.java  | 220 +++++++++---------
 1 file changed, 110 insertions(+), 110 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index a9647d56..ab94f85f 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -29,135 +29,135 @@ public class CursorIterablePerfTest {
     @Rule
     public final TemporaryFolder tmp = new TemporaryFolder();
 
-//    private static final int ITERATIONS = 5_000_000;
-    private static final int ITERATIONS = 100_000;
-//    private static final int ITERATIONS = 10;
-
-    private Dbi<ByteBuffer> dbJavaComparator;
-    private Dbi<ByteBuffer> dbLmdbComparator;
-    private Dbi<ByteBuffer> dbCallbackComparator;
-    private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
-    private Env<ByteBuffer> env;
-    private List<Integer> data = new ArrayList<>(ITERATIONS);
-
-    @Before
-    public void before() throws IOException {
-        final File path = tmp.newFile();
-        final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-        env =
-                create(bufferProxy)
-                        .setMapSize(GIBIBYTES.toBytes(1))
-                        .setMaxReaders(1)
-                        .setMaxDbs(3)
-                        .open(path, POSIX_MODE, MDB_NOSUBDIR);
-
-        // Use a java comparator for start/stop keys only
+  //    private static final int ITERATIONS = 5_000_000;
+  private static final int ITERATIONS = 100_000;
+  //    private static final int ITERATIONS = 10;
+
+  private Dbi<ByteBuffer> dbJavaComparator;
+  private Dbi<ByteBuffer> dbLmdbComparator;
+  private Dbi<ByteBuffer> dbCallbackComparator;
+  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private Env<ByteBuffer> env;
+  private List<Integer> data = new ArrayList<>(ITERATIONS);
+
+  @Before
+  public void before() throws IOException {
+    final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(GIBIBYTES.toBytes(1))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+    // Use a java comparator for start/stop keys only
         dbJavaComparator = env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
-        // Use LMDB comparator for start/stop keys
-        dbLmdbComparator = env.openDbi("LmdbComparator", MDB_CREATE);
-        // Use a java comparator for start/stop keys and as a callback comparator
+    // Use LMDB comparator for start/stop keys
+    dbLmdbComparator = env.openDbi("LmdbComparator", MDB_CREATE);
+    // Use a java comparator for start/stop keys and as a callback comparator
         dbCallbackComparator = env.openDbi(
                 "CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
 
-        dbs.add(dbJavaComparator);
-        dbs.add(dbLmdbComparator);
-        dbs.add(dbCallbackComparator);
+    dbs.add(dbJavaComparator);
+    dbs.add(dbLmdbComparator);
+    dbs.add(dbCallbackComparator);
 
-        populateList();
+    populateList();
+  }
+
+  private void populateList() {
+    for (int i = 0; i < ITERATIONS * 2; i += 2) {
+      data.add(i);
     }
+  }
 
-    private void populateList() {
-        for (int i = 0; i < ITERATIONS * 2; i+=2) {
-            data.add(i);
-        }
+  private void populateDatabases(final boolean randomOrder) {
+    System.out.println("Clear then populate databases");
+
+    final List<Integer> data;
+    if (randomOrder) {
+      data = new ArrayList<>(this.data);
+      Collections.shuffle(data);
+    } else {
+      data = this.data;
     }
 
-    private void populateDatabases(final boolean randomOrder) {
-        System.out.println("Clear then populate databases");
+    for (int round = 0; round < 3; round++) {
+      System.out.println("round: " + round + " -----------------------------------------");
 
-        final List<Integer> data;
-        if (randomOrder) {
-            data = new ArrayList<>(this.data);
-            Collections.shuffle(data);
-        } else {
-            data = this.data;
+      for (final Dbi<ByteBuffer> db : dbs) {
+        // Clean out the db first
+        try (Txn<ByteBuffer> txn = env.txnWrite();
+            final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
+          while (cursor.next()) {
+            cursor.delete();
+          }
         }
 
-        for (int round = 0; round < 3; round++) {
-            System.out.println("round: " + round + " -----------------------------------------");
-
-            for (final Dbi<ByteBuffer> db : dbs) {
-                // Clean out the db first
-                try (Txn<ByteBuffer> txn = env.txnWrite();
-                     final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
-                    while (cursor.next()) {
-                        cursor.delete();
-                    }
-                }
-
-                final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
-                final Instant start = Instant.now();
-                try (Txn<ByteBuffer> txn = env.txnWrite()) {
-                    for (final Integer i : data) {
-                        if (randomOrder) {
-                            db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE);
-                        } else {
-                            db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE, MDB_APPEND);
-                        }
-                    }
-                    txn.commit();
-                }
-                final Duration duration = Duration.between(start, Instant.now());
+        final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+        final Instant start = Instant.now();
+        try (Txn<ByteBuffer> txn = env.txnWrite()) {
+          for (final Integer i : data) {
+            if (randomOrder) {
+              db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE);
+            } else {
+              db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE, MDB_APPEND);
+            }
+          }
+          txn.commit();
+        }
+        final Duration duration = Duration.between(start, Instant.now());
                 System.out.println("DB: " + dbName
                         + " - Loaded in duration: " + duration
                         + ", millis: " + duration.toMillis());
-            }
-        }
-    }
-
-    @After
-    public void after() {
-        env.close();
-        tmp.delete();
+      }
     }
-
-    @Test
-    public void comparePerf_sequential() {
-        comparePerf(false);
-    }
-
-    @Test
-    public void comparePerf_random() {
-        comparePerf(true);
-    }
-
-    public void comparePerf(final boolean randomOrder) {
-        populateDatabases(randomOrder);
-        final ByteBuffer startKeyBuf = bb(data.getFirst());
-        final ByteBuffer stopKeyBuf = bb(data.getLast());
-        final KeyRange<ByteBuffer> keyRange = KeyRange.closed(startKeyBuf, stopKeyBuf);
-
-        System.out.println("\nIterating over all entries");
-        for (int round = 0; round < 3; round++) {
-            System.out.println("round: " + round + " -----------------------------------------");
-            for (final Dbi<ByteBuffer> db : dbs) {
-                final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
-
-                final Instant start = Instant.now();
-                int cnt = 0;
-                // Exercise the stop key comparator on every entry
-                try (Txn<ByteBuffer> txn = env.txnRead();
-                     CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
-                    for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
-                        cnt++;
-                    }
-                }
-                final Duration duration = Duration.between(start, Instant.now());
+  }
+
+  @After
+  public void after() {
+    env.close();
+    tmp.delete();
+  }
+
+  @Test
+  public void comparePerf_sequential() {
+    comparePerf(false);
+  }
+
+  @Test
+  public void comparePerf_random() {
+    comparePerf(true);
+  }
+
+  public void comparePerf(final boolean randomOrder) {
+    populateDatabases(randomOrder);
+    final ByteBuffer startKeyBuf = bb(data.get(0));
+    final ByteBuffer stopKeyBuf = bb(data.get(data.size() - 1));
+    final KeyRange<ByteBuffer> keyRange = KeyRange.closed(startKeyBuf, stopKeyBuf);
+
+    System.out.println("\nIterating over all entries");
+    for (int round = 0; round < 3; round++) {
+      System.out.println("round: " + round + " -----------------------------------------");
+      for (final Dbi<ByteBuffer> db : dbs) {
+        final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+
+        final Instant start = Instant.now();
+        int cnt = 0;
+        // Exercise the stop key comparator on every entry
+        try (Txn<ByteBuffer> txn = env.txnRead();
+            CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+          for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+            cnt++;
+          }
+        }
+        final Duration duration = Duration.between(start, Instant.now());
                 System.out.println("DB: " + dbName
                         + " - Iterated in duration: " + duration
                         + ", millis: " + duration.toMillis()
                         + ", cnt: " + cnt);
-            }
-        }
+      }
     }
+  }
 }

From f92012ecc079149b2414925e0a077a75f82ba043 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Mar 2025 17:33:40 +0000
Subject: [PATCH 03/90] gh-249 Fix indents

---
 .../org/lmdbjava/CursorIterablePerfTest.java  | 28 +++++++++----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index ab94f85f..99667b1d 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -26,8 +26,8 @@
 
 public class CursorIterablePerfTest {
 
-    @Rule
-    public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
 
   //    private static final int ITERATIONS = 5_000_000;
   private static final int ITERATIONS = 100_000;
@@ -52,12 +52,12 @@ public void before() throws IOException {
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
     // Use a java comparator for start/stop keys only
-        dbJavaComparator = env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
+    dbJavaComparator = env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
     // Use LMDB comparator for start/stop keys
     dbLmdbComparator = env.openDbi("LmdbComparator", MDB_CREATE);
     // Use a java comparator for start/stop keys and as a callback comparator
-        dbCallbackComparator = env.openDbi(
-                "CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+    dbCallbackComparator = env.openDbi(
+        "CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
 
     dbs.add(dbJavaComparator);
     dbs.add(dbLmdbComparator);
@@ -89,7 +89,7 @@ private void populateDatabases(final boolean randomOrder) {
       for (final Dbi<ByteBuffer> db : dbs) {
         // Clean out the db first
         try (Txn<ByteBuffer> txn = env.txnWrite();
-            final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
+             final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
           while (cursor.next()) {
             cursor.delete();
           }
@@ -108,9 +108,9 @@ private void populateDatabases(final boolean randomOrder) {
           txn.commit();
         }
         final Duration duration = Duration.between(start, Instant.now());
-                System.out.println("DB: " + dbName
-                        + " - Loaded in duration: " + duration
-                        + ", millis: " + duration.toMillis());
+        System.out.println("DB: " + dbName
+            + " - Loaded in duration: " + duration
+            + ", millis: " + duration.toMillis());
       }
     }
   }
@@ -147,16 +147,16 @@ public void comparePerf(final boolean randomOrder) {
         int cnt = 0;
         // Exercise the stop key comparator on every entry
         try (Txn<ByteBuffer> txn = env.txnRead();
-            CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+             CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
           for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
             cnt++;
           }
         }
         final Duration duration = Duration.between(start, Instant.now());
-                System.out.println("DB: " + dbName
-                        + " - Iterated in duration: " + duration
-                        + ", millis: " + duration.toMillis()
-                        + ", cnt: " + cnt);
+        System.out.println("DB: " + dbName
+            + " - Iterated in duration: " + duration
+            + ", millis: " + duration.toMillis()
+            + ", cnt: " + cnt);
       }
     }
   }

From e1756d633d7cbd1d23a33ffa0fcaaaa44c06aacd Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Mar 2025 19:02:46 +0000
Subject: [PATCH 04/90] gh-249 Tidy code and refactor RangeComparator impls

---
 src/main/java/org/lmdbjava/BufferProxy.java   |   8 +-
 .../java/org/lmdbjava/CursorIterable.java     | 544 ++++++++++--------
 src/main/java/org/lmdbjava/Env.java           |  23 +-
 src/main/java/org/lmdbjava/Key.java           |   4 +-
 src/main/java/org/lmdbjava/KeyRangeType.java  |   4 +-
 .../java/org/lmdbjava/RangeComparator.java    |  26 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  |  37 +-
 .../java/org/lmdbjava/CursorIterableTest.java |  18 +-
 src/test/java/org/lmdbjava/KeyRangeTest.java  |   4 +-
 9 files changed, 376 insertions(+), 292 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index 26d9db74..ab7ba3a4 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -69,11 +69,9 @@ protected BufferProxy() {}
   /**
    * Get a suitable default {@link Comparator} to compare numeric key values as signed.
    *
-   * <p>
-   * Note: LMDB's default comparator is unsigned so if this is used only for the {@link CursorIterable}
-   * start/stop key comparisons then its behaviour will differ from the iteration order. Use
-   * with caution.
-   * </p>
+   * <p>Note: LMDB's default comparator is unsigned so if this is used only for the {@link
+   * CursorIterable} start/stop key comparisons then its behaviour will differ from the iteration
+   * order. Use with caution.
    *
    * @return a comparator that can be used (never null)
    */
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 6b92a9cd..7c487bae 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -42,266 +42,352 @@
  */
 public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T>>, AutoCloseable {
 
-    //  private final Comparator<T> comparator;
-    private final RangeComparator rangeComparator;
-    private final Cursor<T> cursor;
-    private final Dbi<T> dbi;
-    private final KeyVal<T> entry;
-    private boolean iteratorReturned;
-    private final KeyRange<T> range;
-    private State state = REQUIRES_INITIAL_OP;
-    private final Key<T> startKey;
-    private final Key<T> stopKey;
+  //  private final Comparator<T> comparator;
+  private final RangeComparator rangeComparator;
+  private final Cursor<T> cursor;
+  private final KeyVal<T> entry;
+  private boolean iteratorReturned;
+  private final KeyRange<T> range;
+  private State state = REQUIRES_INITIAL_OP;
 
-    CursorIterable(
-            final Txn<T> txn,
-            final Dbi<T> dbi,
-            final KeyRange<T> range,
-            final Comparator<T> comparator,
-            final BufferProxy<T> proxy) {
-        this.cursor = dbi.openCursor(txn);
-        this.dbi = dbi;
-        this.range = range;
-        this.entry = new KeyVal<>();
-
-        if (comparator != null) {
-            // User supplied java-side comparator so use that
-            this.rangeComparator = createJavaRangeComparator(range, comparator, entry::key);
-            this.startKey = null;
-            this.stopKey = null;
-        } else {
-            // No java-side comparator so call down to LMDB to do the comparison
-            this.rangeComparator = createLmdbDbiComparator(txn.pointer(), dbi.pointer());
-            // Allocate buffers for use with the start/stop keys if required.
-            // Saves us copying bytes on each comparison
-            this.startKey = createKey(range.getStart(), proxy);
-            this.stopKey = createKey(range.getStop(), proxy);
-        }
+  CursorIterable(
+      final Txn<T> txn,
+      final Dbi<T> dbi,
+      final KeyRange<T> range,
+      final Comparator<T> comparator,
+      final BufferProxy<T> proxy) {
+    this.cursor = dbi.openCursor(txn);
+    this.range = range;
+    this.entry = new KeyVal<>();
+
+    if (comparator != null) {
+      // User supplied java-side comparator so use that
+      this.rangeComparator = new JavaRangeComparator<>(range, comparator, entry::key);
+    } else {
+      // No java-side comparator so call down to LMDB to do the comparison
+      this.rangeComparator = new LmdbRangeComparator<>(txn, dbi, cursor, range, proxy);
     }
+  }
 
-    private Key<T> createKey(final T keyBuffer, final BufferProxy<T> proxy) {
-        if (keyBuffer != null) {
-            final Key<T> key = proxy.key();
-            key.keyIn(keyBuffer);
-            return key;
-        } else {
-            return null;
+  //  static <T> RangeComparator createJavaRangeComparator(
+  //      final KeyRange<T> range,
+  //      final Comparator<T> comparator,
+  //      final Supplier<T> currentKeySupplier) {
+  //    final T start = range.getStart();
+  //    final T stop = range.getStop();
+  //    return new RangeComparator() {
+  //      @Override
+  //      public int compareToStartKey() {
+  //        return comparator.compare(currentKeySupplier.get(), start);
+  //      }
+  //
+  //      @Override
+  //      public int compareToStopKey() {
+  //        return comparator.compare(currentKeySupplier.get(), stop);
+  //      }
+  //    };
+  //  }
+
+  //  /**
+  //   * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order.
+  //   *
+  //   * @param txnPointer The pointer to the transaction.
+  //   * @param dbiPointer The pointer to the Dbi so LMDB can use the comparator of the Dbi
+  //   * @param proxy
+  //   */
+  //  private RangeComparator createLmdbDbiComparator(final Pointer txnPointer,
+  //                                                  final Pointer dbiPointer,
+  //                                                  final Pointer cursorKeyPointer,
+  //                                                  final KeyRange<T> range,
+  //                                                  final BufferProxy<T> proxy) {
+  //    Objects.requireNonNull(txnPointer);
+  //    Objects.requireNonNull(dbiPointer);
+  //    Objects.requireNonNull(range);
+  //    Objects.requireNonNull(cursor);
+  //    // Allocate buffers for use with the start/stop keys if required.
+  //    // Saves us copying bytes on each comparison
+  //    final Key<T> startKey = createKey(range.getStart(), proxy);
+  //    final Key<T> stopKey = createKey(range.getStop(), proxy);
+  //
+  //    return new RangeComparator() {
+  //      @Override
+  //      public int compareToStartKey() {
+  //        return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(),
+  // startKey.pointer());
+  //      }
+  //
+  //      @Override
+  //      public int compareToStopKey() {
+  //        return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(),
+  // stopKey.pointer());
+  //      }
+  //    };
+  //  }
+
+  @Override
+  public void close() {
+    cursor.close();
+    try {
+      rangeComparator.close();
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * Obtain an iterator.
+   *
+   * <p>As iteration of the returned iterator will cause movement of the underlying LMDB cursor, an
+   * {@link IllegalStateException} is thrown if an attempt is made to obtain the iterator more than
+   * once. For advanced cursor control (such as being able to iterate over the same data multiple
+   * times etc) please instead refer to {@link Dbi#openCursor(org.lmdbjava.Txn)}.
+   *
+   * @return an iterator
+   */
+  @Override
+  public Iterator<KeyVal<T>> iterator() {
+    if (iteratorReturned) {
+      throw new IllegalStateException("Iterator can only be returned once");
+    }
+    iteratorReturned = true;
+
+    return new Iterator<KeyVal<T>>() {
+      @Override
+      public boolean hasNext() {
+        while (state != RELEASED && state != TERMINATED) {
+          update();
+        }
+        return state == RELEASED;
+      }
+
+      @Override
+      public KeyVal<T> next() {
+        if (!hasNext()) {
+          throw new NoSuchElementException();
         }
+        state = REQUIRES_NEXT_OP;
+        return entry;
+      }
+
+      @Override
+      public void remove() {
+        cursor.delete();
+      }
+    };
+  }
+
+  private void executeCursorOp(final CursorOp op) {
+    final boolean found;
+    switch (op) {
+      case FIRST:
+        found = cursor.first();
+        break;
+      case LAST:
+        found = cursor.last();
+        break;
+      case NEXT:
+        found = cursor.next();
+        break;
+      case PREV:
+        found = cursor.prev();
+        break;
+      case GET_START_KEY:
+        found = cursor.get(range.getStart(), MDB_SET_RANGE);
+        break;
+      case GET_START_KEY_BACKWARD:
+        found = cursor.get(range.getStart(), MDB_SET_RANGE) || cursor.last();
+        break;
+      default:
+        throw new IllegalStateException("Unknown cursor operation");
     }
+    entry.setK(found ? cursor.key() : null);
+    entry.setV(found ? cursor.val() : null);
+  }
 
-    static <T> RangeComparator createJavaRangeComparator(
-            final KeyRange<T> range,
-            final Comparator<T> comparator,
-            final Supplier<T> currentKeySupplier) {
-        final T start = range.getStart();
-        final T stop = range.getStop();
-        return new RangeComparator() {
-            @Override
-            public int compareToStartKey() {
-                return comparator.compare(currentKeySupplier.get(), start);
-            }
-
-            @Override
-            public int compareToStopKey() {
-                return comparator.compare(currentKeySupplier.get(), stop);
-            }
-        };
+  private void executeIteratorOp() {
+    final IteratorOp op = range.getType().iteratorOp(entry.key(), rangeComparator);
+    switch (op) {
+      case CALL_NEXT_OP:
+        executeCursorOp(range.getType().nextOp());
+        state = REQUIRES_ITERATOR_OP;
+        break;
+      case TERMINATE:
+        state = TERMINATED;
+        break;
+      case RELEASE:
+        state = RELEASED;
+        break;
+      default:
+        throw new IllegalStateException("Unknown operation");
     }
+  }
+
+  private void update() {
+    switch (state) {
+      case REQUIRES_INITIAL_OP:
+        executeCursorOp(range.getType().initialOp());
+        state = REQUIRES_ITERATOR_OP;
+        break;
+      case REQUIRES_NEXT_OP:
+        executeCursorOp(range.getType().nextOp());
+        state = REQUIRES_ITERATOR_OP;
+        break;
+      case REQUIRES_ITERATOR_OP:
+        executeIteratorOp();
+        break;
+      case TERMINATED:
+        break;
+      default:
+        throw new IllegalStateException("Unknown state");
+    }
+  }
+
+  /**
+   * Holder for a key and value pair.
+   *
+   * <p>The same holder instance will always be returned for a given iterator. The returned keys and
+   * values may change or point to different memory locations following changes in the iterator,
+   * cursor or transaction.
+   *
+   * @param <T> buffer type
+   */
+  public static final class KeyVal<T> {
+
+    private T k;
+    private T v;
+
+    /** Explicitly-defined default constructor to avoid warnings. */
+    public KeyVal() {}
 
     /**
-     * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order.
+     * The key.
      *
-     * @param txnPointer The pointer to the transaction.
-     * @param dbiPointer The pointer to the Dbi so LMDB can use the comparator of the Dbi
+     * @return key
      */
-    private RangeComparator createLmdbDbiComparator(
-            final Pointer txnPointer, final Pointer dbiPointer) {
-        Objects.requireNonNull(txnPointer);
-        Objects.requireNonNull(dbiPointer);
-        Objects.requireNonNull(cursor);
-
-        return new RangeComparator() {
-            @Override
-            public int compareToStartKey() {
-                return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(), startKey.pointerKey());
-            }
-
-            @Override
-            public int compareToStopKey() {
-                return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(), stopKey.pointerKey());
-            }
-        };
-    }
-
-    @Override
-    public void close() {
-        cursor.close();
+    public T key() {
+      return k;
     }
 
     /**
-     * Obtain an iterator.
+     * The value.
      *
-     * <p>As iteration of the returned iterator will cause movement of the underlying LMDB cursor, an
-     * {@link IllegalStateException} is thrown if an attempt is made to obtain the iterator more than
-     * once. For advanced cursor control (such as being able to iterate over the same data multiple
-     * times etc) please instead refer to {@link Dbi#openCursor(org.lmdbjava.Txn)}.
-     *
-     * @return an iterator
+     * @return value
      */
-    @Override
-    public Iterator<KeyVal<T>> iterator() {
-        if (iteratorReturned) {
-            throw new IllegalStateException("Iterator can only be returned once");
-        }
-        iteratorReturned = true;
-
-        return new Iterator<KeyVal<T>>() {
-            @Override
-            public boolean hasNext() {
-                while (state != RELEASED && state != TERMINATED) {
-                    update();
-                }
-                return state == RELEASED;
-            }
-
-            @Override
-            public KeyVal<T> next() {
-                if (!hasNext()) {
-                    throw new NoSuchElementException();
-                }
-                state = REQUIRES_NEXT_OP;
-                return entry;
-            }
-
-            @Override
-            public void remove() {
-                cursor.delete();
-            }
-        };
+    public T val() {
+      return v;
     }
 
-    private void executeCursorOp(final CursorOp op) {
-        final boolean found;
-        switch (op) {
-            case FIRST:
-                found = cursor.first();
-                break;
-            case LAST:
-                found = cursor.last();
-                break;
-            case NEXT:
-                found = cursor.next();
-                break;
-            case PREV:
-                found = cursor.prev();
-                break;
-            case GET_START_KEY:
-                found = cursor.get(range.getStart(), MDB_SET_RANGE);
-                break;
-            case GET_START_KEY_BACKWARD:
-                found = cursor.get(range.getStart(), MDB_SET_RANGE) || cursor.last();
-                break;
-            default:
-                throw new IllegalStateException("Unknown cursor operation");
-        }
-        entry.setK(found ? cursor.key() : null);
-        entry.setV(found ? cursor.val() : null);
+    void setK(final T key) {
+      this.k = key;
     }
 
-    private void executeIteratorOp() {
-        final IteratorOp op =
-                range.getType().iteratorOp(range.getStart(), range.getStop(), entry.key(), rangeComparator);
-        switch (op) {
-            case CALL_NEXT_OP:
-                executeCursorOp(range.getType().nextOp());
-                state = REQUIRES_ITERATOR_OP;
-                break;
-            case TERMINATE:
-                state = TERMINATED;
-                break;
-            case RELEASE:
-                state = RELEASED;
-                break;
-            default:
-                throw new IllegalStateException("Unknown operation");
-        }
+    void setV(final T val) {
+      this.v = val;
     }
+  }
 
-    private void update() {
-        switch (state) {
-            case REQUIRES_INITIAL_OP:
-                executeCursorOp(range.getType().initialOp());
-                state = REQUIRES_ITERATOR_OP;
-                break;
-            case REQUIRES_NEXT_OP:
-                executeCursorOp(range.getType().nextOp());
-                state = REQUIRES_ITERATOR_OP;
-                break;
-            case REQUIRES_ITERATOR_OP:
-                executeIteratorOp();
-                break;
-            case TERMINATED:
-                break;
-            default:
-                throw new IllegalStateException("Unknown state");
-        }
+  /** Represents the internal {@link CursorIterable} state. */
+  enum State {
+    REQUIRES_INITIAL_OP,
+    REQUIRES_NEXT_OP,
+    REQUIRES_ITERATOR_OP,
+    RELEASED,
+    TERMINATED
+  }
+
+  static class JavaRangeComparator<T> implements RangeComparator {
+
+    private final Comparator<T> comparator;
+    private final Supplier<T> currentKeySupplier;
+    private final T start;
+    private final T stop;
+
+    JavaRangeComparator(
+        final KeyRange<T> range,
+        final Comparator<T> comparator,
+        final Supplier<T> currentKeySupplier) {
+      this.comparator = comparator;
+      this.currentKeySupplier = currentKeySupplier;
+      this.start = range.getStart();
+      this.stop = range.getStop();
     }
 
-    /**
-     * Holder for a key and value pair.
-     *
-     * <p>The same holder instance will always be returned for a given iterator. The returned keys and
-     * values may change or point to different memory locations following changes in the iterator,
-     * cursor or transaction.
-     *
-     * @param <T> buffer type
-     */
-    public static final class KeyVal<T> {
+    @Override
+    public int compareToStartKey() {
+      return comparator.compare(currentKeySupplier.get(), start);
+    }
 
-        private T k;
-        private T v;
+    @Override
+    public int compareToStopKey() {
+      return comparator.compare(currentKeySupplier.get(), stop);
+    }
 
-        /**
-         * Explicitly-defined default constructor to avoid warnings.
-         */
-        public KeyVal() {
-        }
+    @Override
+    public void close() throws Exception {
+      // Nothing to close
+    }
+  }
 
-        /**
-         * The key.
-         *
-         * @return key
-         */
-        public T key() {
-            return k;
-        }
+  /**
+   * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order. Has a
+   * very slight overhead as compared to {@link JavaRangeComparator}.
+   */
+  private static class LmdbRangeComparator<T> implements RangeComparator {
 
-        /**
-         * The value.
-         *
-         * @return value
-         */
-        public T val() {
-            return v;
-        }
+    private final Pointer txnPointer;
+    private final Pointer dbiPointer;
+    private final Pointer cursorKeyPointer;
+    private final Key<T> startKey;
+    private final Key<T> stopKey;
+    private final Pointer startKeyPointer;
+    private final Pointer stopKeyPointer;
 
-        void setK(final T key) {
-            this.k = key;
-        }
+    public LmdbRangeComparator(
+        final Txn<T> txn,
+        final Dbi<T> dbi,
+        final Cursor<T> cursor,
+        final KeyRange<T> range,
+        final BufferProxy<T> proxy) {
+      txnPointer = Objects.requireNonNull(txn).pointer();
+      dbiPointer = Objects.requireNonNull(dbi).pointer();
+      cursorKeyPointer = Objects.requireNonNull(cursor).keyVal().pointerKey();
+      // Allocate buffers for use with the start/stop keys if required.
+      // Saves us copying bytes on each comparison
+      Objects.requireNonNull(range);
+      startKey = createKey(range.getStart(), proxy);
+      stopKey = createKey(range.getStop(), proxy);
+      startKeyPointer = startKey != null ? startKey.pointer() : null;
+      stopKeyPointer = stopKey != null ? stopKey.pointer() : null;
+    }
 
-        void setV(final T val) {
-            this.v = val;
-        }
+    @Override
+    public int compareToStartKey() {
+      return LIB.mdb_cmp(txnPointer, dbiPointer, cursorKeyPointer, startKeyPointer);
     }
 
-    /**
-     * Represents the internal {@link CursorIterable} state.
-     */
-    enum State {
-        REQUIRES_INITIAL_OP,
-        REQUIRES_NEXT_OP,
-        REQUIRES_ITERATOR_OP,
-        RELEASED,
-        TERMINATED
+    @Override
+    public int compareToStopKey() {
+      return LIB.mdb_cmp(txnPointer, dbiPointer, cursorKeyPointer, stopKeyPointer);
+    }
+
+    @Override
+    public void close() {
+      if (startKey != null) {
+        startKey.close();
+      }
+      if (stopKey != null) {
+        stopKey.close();
+      }
+    }
+
+    private Key<T> createKey(final T keyBuffer, final BufferProxy<T> proxy) {
+      if (keyBuffer != null) {
+        final Key<T> key = proxy.key();
+        key.keyIn(keyBuffer);
+        return key;
+      } else {
+        return null;
+      }
     }
+  }
 }
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 1543282c..2e4822b7 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -257,16 +257,15 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   /**
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
-   * <p>
-   * It is very important that the passed comparator behaves in the same way as the comparator
+   *
+   * <p>It is very important that the passed comparator behaves in the same way as the comparator
    * LMDB uses for its insertion order (for the type of data that will be stored in the database),
-   * or you fully understand the implications of them behaving differently.
-   * LMDB's comparator is unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is used.
-   * </p>
+   * or you fully understand the implications of them behaving differently. LMDB's comparator is
+   * unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is used.
    *
    * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator for cursor start/stop key comparisons. If null,
-   *                   LMDB's comparator will be used.
+   * @param comparator custom comparator for cursor start/stop key comparisons. If null, LMDB's
+   *     comparator will be used.
    * @param flags to open the database with
    * @return a database that is ready to use
    */
@@ -278,14 +277,14 @@ public Dbi<T> openDbi(
 
   /**
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop keys
-   * as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to determine
-   * insertion/iteration order. Calling back to a java comparator may significantly impact performance.
+   * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop
+   * keys as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to
+   * determine insertion/iteration order. Calling back to a java comparator may significantly impact
+   * performance.
    *
    * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator for cursor start/stop key comparisons and optionally for
-   *                   LMDB to call back to. If null,
-   *                   LMDB's comparator will be used.
+   *     LMDB to call back to. If null, LMDB's comparator will be used.
    * @param nativeCb whether LMDB native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
diff --git a/src/main/java/org/lmdbjava/Key.java b/src/main/java/org/lmdbjava/Key.java
index 7fd8bbe2..12c54290 100644
--- a/src/main/java/org/lmdbjava/Key.java
+++ b/src/main/java/org/lmdbjava/Key.java
@@ -33,7 +33,6 @@ final class Key<T> implements AutoCloseable {
   private boolean closed;
   private T k;
   private final BufferProxy<T> proxy;
-  private final Pointer ptrArray;
   private final Pointer ptrKey;
   private final long ptrKeyAddr;
 
@@ -43,7 +42,6 @@ final class Key<T> implements AutoCloseable {
     this.k = proxy.allocate();
     ptrKey = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE, false);
     ptrKeyAddr = ptrKey.address();
-    ptrArray = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE * 2, false);
   }
 
   @Override
@@ -68,7 +66,7 @@ T keyOut() {
     return k;
   }
 
-  Pointer pointerKey() {
+  Pointer pointer() {
     return ptrKey;
   }
 }
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index 07123e9a..26f09636 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -319,14 +319,12 @@ CursorOp initialOp() {
    *
    * @param <T> buffer type
    * @param <C> comparator for the buffers
-   * @param start start buffer
-   * @param stop stop buffer
    * @param buffer current key returned by LMDB (may be null)
    * @param rangeComparator comparator (required)
    * @return response to this key
    */
   <T, C extends Comparator<T>> IteratorOp iteratorOp(
-      final T start, final T stop, final T buffer, final RangeComparator rangeComparator) {
+      final T buffer, final RangeComparator rangeComparator) {
     requireNonNull(rangeComparator, "Comparator required");
     if (buffer == null) {
       return TERMINATE;
diff --git a/src/main/java/org/lmdbjava/RangeComparator.java b/src/main/java/org/lmdbjava/RangeComparator.java
index 162584b1..59d46015 100644
--- a/src/main/java/org/lmdbjava/RangeComparator.java
+++ b/src/main/java/org/lmdbjava/RangeComparator.java
@@ -1,19 +1,17 @@
 package org.lmdbjava;
 
-/**
- * For comparing a cursor's current key against a {@link KeyRange}'s start/stop key.
- */
-interface RangeComparator {
+/** For comparing a cursor's current key against a {@link KeyRange}'s start/stop key. */
+interface RangeComparator extends AutoCloseable {
 
-    /**
-     * Compare the cursor's current key to the range start key. Equivalent to compareTo(currentKey,
-     * startKey)
-     */
-    int compareToStartKey();
+  /**
+   * Compare the cursor's current key to the range start key. Equivalent to compareTo(currentKey,
+   * startKey)
+   */
+  int compareToStartKey();
 
-    /**
-     * Compare the cursor's current key to the range stop key. Equivalent to compareTo(currentKey,
-     * stopKey)
-     */
-    int compareToStopKey();
+  /**
+   * Compare the cursor's current key to the range stop key. Equivalent to compareTo(currentKey,
+   * stopKey)
+   */
+  int compareToStopKey();
 }
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 99667b1d..19e5a9b9 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -26,8 +26,7 @@
 
 public class CursorIterablePerfTest {
 
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
 
   //    private static final int ITERATIONS = 5_000_000;
   private static final int ITERATIONS = 100_000;
@@ -52,12 +51,13 @@ public void before() throws IOException {
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
     // Use a java comparator for start/stop keys only
-    dbJavaComparator = env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
+    dbJavaComparator =
+        env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
     // Use LMDB comparator for start/stop keys
     dbLmdbComparator = env.openDbi("LmdbComparator", MDB_CREATE);
     // Use a java comparator for start/stop keys and as a callback comparator
-    dbCallbackComparator = env.openDbi(
-        "CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+    dbCallbackComparator =
+        env.openDbi("CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
 
     dbs.add(dbJavaComparator);
     dbs.add(dbLmdbComparator);
@@ -89,7 +89,7 @@ private void populateDatabases(final boolean randomOrder) {
       for (final Dbi<ByteBuffer> db : dbs) {
         // Clean out the db first
         try (Txn<ByteBuffer> txn = env.txnWrite();
-             final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
+            final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
           while (cursor.next()) {
             cursor.delete();
           }
@@ -108,9 +108,13 @@ private void populateDatabases(final boolean randomOrder) {
           txn.commit();
         }
         final Duration duration = Duration.between(start, Instant.now());
-        System.out.println("DB: " + dbName
-            + " - Loaded in duration: " + duration
-            + ", millis: " + duration.toMillis());
+        System.out.println(
+            "DB: "
+                + dbName
+                + " - Loaded in duration: "
+                + duration
+                + ", millis: "
+                + duration.toMillis());
       }
     }
   }
@@ -147,16 +151,21 @@ public void comparePerf(final boolean randomOrder) {
         int cnt = 0;
         // Exercise the stop key comparator on every entry
         try (Txn<ByteBuffer> txn = env.txnRead();
-             CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+            CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
           for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
             cnt++;
           }
         }
         final Duration duration = Duration.between(start, Instant.now());
-        System.out.println("DB: " + dbName
-            + " - Iterated in duration: " + duration
-            + ", millis: " + duration.toMillis()
-            + ", cnt: " + cnt);
+        System.out.println(
+            "DB: "
+                + dbName
+                + " - Iterated in duration: "
+                + duration
+                + ", millis: "
+                + duration.toMillis()
+                + ", cnt: "
+                + cnt);
       }
     }
   }
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 96be0816..22cf7361 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -134,8 +134,7 @@ public void before() throws IOException {
     // Use LMDB comparator for start/stop keys
     dbLmdbComparator = env.openDbi(DB_2, MDB_CREATE);
     // Use a java comparator for start/stop keys and as a callback comparaotr
-    dbCallbackComparator = env.openDbi(
-            DB_3, bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+    dbCallbackComparator = env.openDbi(DB_3, bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
 
     populateList();
 
@@ -422,18 +421,17 @@ public void testSignedVsUnsigned() {
 
     // Compare the same
     assertThat(
-            unsignedComparator.compare(val1, val2),
-            Matchers.is(signedComparator.compare(val1, val2)));
+        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
 
     // Compare differently
     assertThat(
-            unsignedComparator.compare(val110, val150),
-            Matchers.not(signedComparator.compare(val110, val150)));
+        unsignedComparator.compare(val110, val150),
+        Matchers.not(signedComparator.compare(val110, val150)));
 
     // Compare differently
     assertThat(
-            unsignedComparator.compare(val111, val150),
-            Matchers.not(signedComparator.compare(val111, val150)));
+        unsignedComparator.compare(val111, val150),
+        Matchers.not(signedComparator.compare(val111, val150)));
 
     // This will fail if the db is using a signed comparator for the start/stop keys
     for (final Dbi<ByteBuffer> db : dbs) {
@@ -444,11 +442,11 @@ public void testSignedVsUnsigned() {
       KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
 
       try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
         for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
           final int key = kv.key().getInt();
           final int val = kv.val().getInt();
-//          System.out.println("key: " + key + " val: " + val);
+          //          System.out.println("key: " + key + " val: " + val);
           assertThat(key, is(110));
           break;
         }
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index 0197bf11..c474e982 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -197,8 +197,8 @@ private void verify(final KeyRange<Integer> range, final int... expected) {
     do {
       final Integer finalBuff = buff;
       final RangeComparator rangeComparator =
-          CursorIterable.createJavaRangeComparator(range, Integer::compareTo, () -> finalBuff);
-      op = range.getType().iteratorOp(range.getStart(), range.getStop(), buff, rangeComparator);
+          new CursorIterable.JavaRangeComparator<>(range, Integer::compareTo, () -> finalBuff);
+      op = range.getType().iteratorOp(buff, rangeComparator);
       switch (op) {
         case CALL_NEXT_OP:
           buff = cursor.apply(range.getType().nextOp(), range.getStart());

From 9509f6bea115c7839e14881e4ecb4459211820d4 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Mar 2025 19:05:48 +0000
Subject: [PATCH 05/90] gh-249 Remove commented code

---
 .../java/org/lmdbjava/CursorIterable.java     | 56 -------------------
 1 file changed, 56 deletions(-)

diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 7c487bae..b0de7d06 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -42,7 +42,6 @@
  */
 public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T>>, AutoCloseable {
 
-  //  private final Comparator<T> comparator;
   private final RangeComparator rangeComparator;
   private final Cursor<T> cursor;
   private final KeyVal<T> entry;
@@ -69,61 +68,6 @@ public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T
     }
   }
 
-  //  static <T> RangeComparator createJavaRangeComparator(
-  //      final KeyRange<T> range,
-  //      final Comparator<T> comparator,
-  //      final Supplier<T> currentKeySupplier) {
-  //    final T start = range.getStart();
-  //    final T stop = range.getStop();
-  //    return new RangeComparator() {
-  //      @Override
-  //      public int compareToStartKey() {
-  //        return comparator.compare(currentKeySupplier.get(), start);
-  //      }
-  //
-  //      @Override
-  //      public int compareToStopKey() {
-  //        return comparator.compare(currentKeySupplier.get(), stop);
-  //      }
-  //    };
-  //  }
-
-  //  /**
-  //   * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order.
-  //   *
-  //   * @param txnPointer The pointer to the transaction.
-  //   * @param dbiPointer The pointer to the Dbi so LMDB can use the comparator of the Dbi
-  //   * @param proxy
-  //   */
-  //  private RangeComparator createLmdbDbiComparator(final Pointer txnPointer,
-  //                                                  final Pointer dbiPointer,
-  //                                                  final Pointer cursorKeyPointer,
-  //                                                  final KeyRange<T> range,
-  //                                                  final BufferProxy<T> proxy) {
-  //    Objects.requireNonNull(txnPointer);
-  //    Objects.requireNonNull(dbiPointer);
-  //    Objects.requireNonNull(range);
-  //    Objects.requireNonNull(cursor);
-  //    // Allocate buffers for use with the start/stop keys if required.
-  //    // Saves us copying bytes on each comparison
-  //    final Key<T> startKey = createKey(range.getStart(), proxy);
-  //    final Key<T> stopKey = createKey(range.getStop(), proxy);
-  //
-  //    return new RangeComparator() {
-  //      @Override
-  //      public int compareToStartKey() {
-  //        return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(),
-  // startKey.pointer());
-  //      }
-  //
-  //      @Override
-  //      public int compareToStopKey() {
-  //        return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(),
-  // stopKey.pointer());
-  //      }
-  //    };
-  //  }
-
   @Override
   public void close() {
     cursor.close();

From 67e2df1002ee86534ad082beb83a1c753e2ab6b5 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Mar 2025 10:31:12 +0000
Subject: [PATCH 06/90] gh-249 Add CursorIterableIntegerKeyTest

---
 .../CursorIterableIntegerKeyTest.java         | 493 ++++++++++++++++++
 .../org/lmdbjava/CursorIterablePerfTest.java  |   2 +-
 src/test/java/org/lmdbjava/TestUtils.java     |  15 +
 3 files changed, 509 insertions(+), 1 deletion(-)
 create mode 100644 src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java

diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
new file mode 100644
index 00000000..431c6e51
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -0,0 +1,493 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasSize;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.KeyRange.all;
+import static org.lmdbjava.KeyRange.allBackward;
+import static org.lmdbjava.KeyRange.atLeast;
+import static org.lmdbjava.KeyRange.atLeastBackward;
+import static org.lmdbjava.KeyRange.atMost;
+import static org.lmdbjava.KeyRange.atMostBackward;
+import static org.lmdbjava.KeyRange.closed;
+import static org.lmdbjava.KeyRange.closedBackward;
+import static org.lmdbjava.KeyRange.closedOpen;
+import static org.lmdbjava.KeyRange.closedOpenBackward;
+import static org.lmdbjava.KeyRange.greaterThan;
+import static org.lmdbjava.KeyRange.greaterThanBackward;
+import static org.lmdbjava.KeyRange.lessThan;
+import static org.lmdbjava.KeyRange.lessThanBackward;
+import static org.lmdbjava.KeyRange.open;
+import static org.lmdbjava.KeyRange.openBackward;
+import static org.lmdbjava.KeyRange.openClosed;
+import static org.lmdbjava.KeyRange.openClosedBackward;
+import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.DB_2;
+import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.bbNative;
+import static org.lmdbjava.TestUtils.getNativeInt;
+
+import com.google.common.primitives.UnsignedBytes;
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.NoSuchElementException;
+import org.hamcrest.Matchers;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.lmdbjava.CursorIterable.KeyVal;
+
+/** Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that
+ * comparators work with native order integer keys. */
+public final class CursorIterableIntegerKeyTest {
+
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
+  private Dbi<ByteBuffer> dbJavaComparator;
+  private Dbi<ByteBuffer> dbLmdbComparator;
+  private Dbi<ByteBuffer> dbCallbackComparator;
+  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private Env<ByteBuffer> env;
+  private Deque<Integer> list;
+
+  @After
+  public void after() {
+    env.close();
+  }
+
+  @Test
+  public void allBackwardTest() {
+    verify(allBackward(), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void allTest() {
+    verify(all(), 2, 4, 6, 8);
+  }
+
+  @Test
+  public void atLeastBackwardTest() {
+    verify(atLeastBackward(bbNative(5)), 4, 2);
+    verify(atLeastBackward(bbNative(6)), 6, 4, 2);
+    verify(atLeastBackward(bbNative(9)), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void atLeastTest() {
+    verify(atLeast(bbNative(5)), 6, 8);
+    verify(atLeast(bbNative(6)), 6, 8);
+  }
+
+  @Test
+  public void atMostBackwardTest() {
+    verify(atMostBackward(bbNative(5)), 8, 6);
+    verify(atMostBackward(bbNative(6)), 8, 6);
+  }
+
+  @Test
+  public void atMostTest() {
+    verify(atMost(bbNative(5)), 2, 4);
+    verify(atMost(bbNative(6)), 2, 4, 6);
+  }
+
+  @Before
+  public void before() throws IOException {
+    final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+    // Use a java comparator for start/stop keys only
+    dbJavaComparator = env.openDbi(DB_1,
+        bufferProxy.getUnsignedComparator(),
+        MDB_CREATE,
+        MDB_INTEGERKEY);
+    // Use LMDB comparator for start/stop keys
+    dbLmdbComparator = env.openDbi(DB_2, MDB_CREATE, MDB_INTEGERKEY);
+    // Use a java comparator for start/stop keys and as a callback comparaotr
+    dbCallbackComparator = env.openDbi(DB_3,
+        bufferProxy.getUnsignedComparator(),
+        true,
+        MDB_CREATE,
+        MDB_INTEGERKEY);
+
+    populateList();
+
+    populateDatabase(dbJavaComparator);
+    populateDatabase(dbLmdbComparator);
+    populateDatabase(dbCallbackComparator);
+
+    dbs.add(dbJavaComparator);
+    dbs.add(dbLmdbComparator);
+    dbs.add(dbCallbackComparator);
+  }
+
+  private void populateList() {
+    list = new LinkedList<>();
+    list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      c.put(bbNative(2), bb(3), MDB_NOOVERWRITE);
+      c.put(bbNative(4), bb(5));
+      c.put(bbNative(6), bb(7));
+      c.put(bbNative(8), bb(9));
+      txn.commit();
+    }
+  }
+
+  @Test
+  public void closedBackwardTest() {
+    verify(closedBackward(bbNative(7), bbNative(3)), 6, 4);
+    verify(closedBackward(bbNative(6), bbNative(2)), 6, 4, 2);
+    verify(closedBackward(bbNative(9), bbNative(3)), 8, 6, 4);
+  }
+
+  @Test
+  public void closedOpenBackwardTest() {
+    verify(closedOpenBackward(bbNative(8), bbNative(3)), 8, 6, 4);
+    verify(closedOpenBackward(bbNative(7), bbNative(2)), 6, 4);
+    verify(closedOpenBackward(bbNative(9), bbNative(3)), 8, 6, 4);
+  }
+
+  @Test
+  public void closedOpenTest() {
+    verify(closedOpen(bbNative(3), bbNative(8)), 4, 6);
+    verify(closedOpen(bbNative(2), bbNative(6)), 2, 4);
+  }
+
+  @Test
+  public void closedTest() {
+    verify(closed(bbNative(3), bbNative(7)), 4, 6);
+    verify(closed(bbNative(2), bbNative(6)), 2, 4, 6);
+    verify(closed(bbNative(1), bbNative(7)), 2, 4, 6);
+  }
+
+  @Test
+  public void greaterThanBackwardTest() {
+    verify(greaterThanBackward(bbNative(6)), 4, 2);
+    verify(greaterThanBackward(bbNative(7)), 6, 4, 2);
+    verify(greaterThanBackward(bbNative(9)), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void greaterThanTest() {
+    verify(greaterThan(bbNative(4)), 6, 8);
+    verify(greaterThan(bbNative(3)), 4, 6, 8);
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void iterableOnlyReturnedOnce() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        c.iterator(); // ok
+        c.iterator(); // fails
+      }
+    }
+  }
+
+  @Test
+  public void iterate() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      populateList();
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+
+        int cnt = 0;
+        for (final KeyVal<ByteBuffer> kv : c) {
+          assertThat(getNativeInt(kv.key()), is(list.pollFirst()));
+          assertThat(kv.val().getInt(), is(list.pollFirst()));
+        }
+      }
+    }
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void iteratorOnlyReturnedOnce() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        c.iterator(); // ok
+        c.iterator(); // fails
+      }
+    }
+  }
+
+  @Test
+  public void lessThanBackwardTest() {
+    verify(lessThanBackward(bbNative(5)), 8, 6);
+    verify(lessThanBackward(bbNative(2)), 8, 6, 4);
+  }
+
+  @Test
+  public void lessThanTest() {
+    verify(lessThan(bbNative(5)), 2, 4);
+    verify(lessThan(bbNative(8)), 2, 4, 6);
+  }
+
+  @Test(expected = NoSuchElementException.class)
+  public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      populateList();
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+        while (i.hasNext()) {
+          final KeyVal<ByteBuffer> kv = i.next();
+          assertThat(TestUtils.getNativeInt(kv.key()), is(list.pollFirst()));
+          assertThat(kv.val().getInt(), is(list.pollFirst()));
+        }
+        assertThat(i.hasNext(), is(false));
+        i.next();
+      }
+    }
+  }
+
+  @Test
+  public void openBackwardTest() {
+    verify(openBackward(bbNative(7), bbNative(2)), 6, 4);
+    verify(openBackward(bbNative(8), bbNative(1)), 6, 4, 2);
+    verify(openBackward(bbNative(9), bbNative(4)), 8, 6);
+  }
+
+  @Test
+  public void openClosedBackwardTest() {
+    verify(openClosedBackward(bbNative(7), bbNative(2)), 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), 6, 4);
+    verify(openClosedBackward(bbNative(9), bbNative(4)), 8, 6, 4);
+  }
+
+  @Test
+  public void openClosedBackwardTestWithGuava() {
+    final Comparator<byte[]> guava = UnsignedBytes.lexicographicalComparator();
+    final Comparator<ByteBuffer> comparator =
+        (bb1, bb2) -> {
+          final byte[] array1 = new byte[bb1.remaining()];
+          final byte[] array2 = new byte[bb2.remaining()];
+          bb1.mark();
+          bb2.mark();
+          bb1.get(array1);
+          bb2.get(array2);
+          bb1.reset();
+          bb2.reset();
+          return guava.compare(array1, array2);
+        };
+    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    populateDatabase(guavaDbi);
+    verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
+  }
+
+  @Test
+  public void openClosedTest() {
+    verify(openClosed(bbNative(3), bbNative(8)), 4, 6, 8);
+    verify(openClosed(bbNative(2), bbNative(6)), 4, 6);
+  }
+
+  @Test
+  public void openTest() {
+    verify(open(bbNative(3), bbNative(7)), 4, 6);
+    verify(open(bbNative(2), bbNative(8)), 4, 6);
+  }
+
+  @Test
+  public void removeOddElements() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      verify(db, all(), 2, 4, 6, 8);
+      int idx = -1;
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+          while (c.hasNext()) {
+            c.next();
+            idx++;
+            if (idx % 2 == 0) {
+              c.remove();
+            }
+          }
+        }
+        txn.commit();
+      }
+      verify(db, all(), 4, 8);
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void nextWithClosedEnvTest() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+          env.close();
+          c.next();
+        }
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void removeWithClosedEnvTest() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+          final KeyVal<ByteBuffer> keyVal = c.next();
+          assertThat(keyVal, Matchers.notNullValue());
+
+          env.close();
+          c.remove();
+        }
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void hasNextWithClosedEnvTest() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+          env.close();
+          c.hasNext();
+        }
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void forEachRemainingWithClosedEnvTest() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+          env.close();
+          c.forEachRemaining(keyVal -> {});
+        }
+      }
+    }
+  }
+
+  @Test
+  public void testSignedVsUnsigned() {
+    final ByteBuffer val1 = bbNative(1);
+    final ByteBuffer val2 = bbNative(2);
+    final ByteBuffer val110 = bbNative(110);
+    final ByteBuffer val111 = bbNative(111);
+    final ByteBuffer val150 = bbNative(150);
+
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
+    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
+
+    // Compare the same
+    assertThat(
+        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
+
+    // Compare differently
+    assertThat(
+        unsignedComparator.compare(val110, val150),
+        Matchers.not(signedComparator.compare(val110, val150)));
+
+    // Compare differently
+    assertThat(
+        unsignedComparator.compare(val111, val150),
+        Matchers.not(signedComparator.compare(val111, val150)));
+
+    // This will fail if the db is using a signed comparator for the start/stop keys
+    for (final Dbi<ByteBuffer> db : dbs) {
+      db.put(val110, val110);
+      db.put(val150, val150);
+
+      final ByteBuffer startKeyBuf = val111;
+      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
+
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+        for (final KeyVal<ByteBuffer> kv : c) {
+          final int key = getNativeInt(kv.key());
+          final int val = kv.val().getInt();
+          //          System.out.println("key: " + key + " val: " + val);
+          assertThat(key, is(110));
+          break;
+        }
+      }
+    }
+  }
+
+  private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
+    // Verify using all comparator types
+    for (final Dbi<ByteBuffer> db : dbs) {
+      verify(range, db, expected);
+    }
+  }
+
+  private void verify(
+      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expected) {
+    verify(range, dbi, expected);
+  }
+
+  private void verify(
+      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
+
+    final List<Integer> results = new ArrayList<>();
+
+    try (Txn<ByteBuffer> txn = env.txnRead();
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
+        final int key = kv.key().order(ByteOrder.nativeOrder()).getInt();
+        final int val = kv.val().getInt();
+        results.add(key);
+        assertThat(val, is(key + 1));
+      }
+    }
+
+    assertThat(results, hasSize(expected.length));
+    for (int idx = 0; idx < results.size(); idx++) {
+      assertThat(results.get(idx), is(expected[idx]));
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 19e5a9b9..257ee705 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -73,7 +73,7 @@ private void populateList() {
   }
 
   private void populateDatabases(final boolean randomOrder) {
-    System.out.println("Clear then populate databases");
+    System.out.println("Clear then populate databases (randomOrder=" + randomOrder + ")");
 
     final List<Integer> data;
     if (randomOrder) {
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index f3d3974b..ff84946f 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -23,6 +23,7 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
 
@@ -49,6 +50,20 @@ static ByteBuffer bb(final int value) {
     return bb;
   }
 
+  static ByteBuffer bbNative(final int value) {
+    final ByteBuffer bb = allocateDirect(Long.BYTES)
+        .order(ByteOrder.nativeOrder());
+    bb.putInt(value).flip();
+    return bb;
+  }
+
+  static int getNativeInt(final ByteBuffer bb) {
+    final int val = bb.order(ByteOrder.nativeOrder())
+        .getInt();
+    bb.rewind();
+    return val;
+  }
+
   static void invokePrivateConstructor(final Class<?> clazz) {
     try {
       final Constructor<?> c = clazz.getDeclaredConstructor();

From 620a89fc4bdc292b3f5cace5631a5af6afd6f11e Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 5 Jun 2025 10:03:12 +0100
Subject: [PATCH 07/90] gh-249 Remove MaskedFlag.isPropagatedToLmdb, add
 DbiBuilder WIP

---
 src/main/java/org/lmdbjava/Cursor.java     |   8 +-
 src/main/java/org/lmdbjava/Dbi.java        |   6 +-
 src/main/java/org/lmdbjava/DbiBuilder.java | 335 +++++++++++++++++++++
 src/main/java/org/lmdbjava/DbiFlags.java   |   3 +
 src/main/java/org/lmdbjava/Env.java        |  27 +-
 src/main/java/org/lmdbjava/MaskedFlag.java |  72 +----
 src/main/java/org/lmdbjava/Txn.java        |   2 +-
 7 files changed, 382 insertions(+), 71 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/DbiBuilder.java

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 9070cff6..69f84c88 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -112,7 +112,7 @@ public void delete(final PutFlags... f) {
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int flags = mask(true, f);
+    final int flags = mask(f);
     checkRc(LIB.mdb_cursor_del(ptrCursor, flags));
   }
 
@@ -249,7 +249,7 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     }
     kv.keyIn(key);
     kv.valIn(val);
-    final int mask = mask(true, op);
+    final int mask = mask(op);
     final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
       if (isSet(mask, MDB_NOOVERWRITE)) {
@@ -287,7 +287,7 @@ public void putMultiple(final T key, final T val, final int elements, final PutF
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int mask = mask(true, op);
+    final int mask = mask(op);
     if (SHOULD_CHECK && !isSet(mask, MDB_MULTIPLE)) {
       throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
     }
@@ -346,7 +346,7 @@ public T reserve(final T key, final int size, final PutFlags... op) {
     }
     kv.keyIn(key);
     kv.valIn(size);
-    final int flags = mask(true, op) | MDB_RESERVE.getMask();
+    final int flags = mask(op) | MDB_RESERVE.getMask();
     checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flags));
     kv.valOut();
     ReferenceUtil.reachabilityFence0(key);
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index c622462b..8560e34c 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -72,7 +72,7 @@ public final class Dbi<T> {
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
     this.proxy = proxy;
     this.comparator = comparator;
-    final int flagsMask = mask(true, flags);
+    final int flagsMask = mask(flags);
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
     checkRc(LIB.mdb_dbi_open(txn.pointer(), name, flagsMask, dbiPtr));
     ptr = dbiPtr.getPointer(0);
@@ -371,7 +371,7 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
     }
     txn.kv().keyIn(key);
     txn.kv().valIn(val);
-    final int mask = mask(true, flags);
+    final int mask = mask(flags);
     final int rc =
         LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
@@ -413,7 +413,7 @@ public T reserve(final Txn<T> txn, final T key, final int size, final PutFlags..
     }
     txn.kv().keyIn(key);
     txn.kv().valIn(size);
-    final int flags = mask(true, op) | MDB_RESERVE.getMask();
+    final int flags = mask(op) | MDB_RESERVE.getMask();
     checkRc(LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flags));
     txn.kv().valOut(); // marked as in,out in LMDB C docs
     ReferenceUtil.reachabilityFence0(key);
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
new file mode 100644
index 00000000..a33ca746
--- /dev/null
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -0,0 +1,335 @@
+package org.lmdbjava;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.EnumSet;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * Staged builder for building a {@link Dbi}
+ *
+ * @param <T> buffer type
+ */
+public class DbiBuilder<T> {
+
+  private final Env<T> env;
+  private final BufferProxy<T> proxy;
+  private final boolean readOnly;
+  private byte[] name;
+
+  DbiBuilder(final Env<T> env,
+             final BufferProxy<T> proxy,
+             final boolean readOnly) {
+    this.env = Objects.requireNonNull(env);
+    this.proxy = Objects.requireNonNull(proxy);
+    this.readOnly = readOnly;
+  }
+
+  /**
+   * <p>
+   * Create the {@link Dbi} with the passed name.
+   * </p>
+   * <p>
+   * The name will be converted into bytes using {@link StandardCharsets#UTF_8}.
+   * </p>
+   */
+  public RequireComparator<T> withDbName(final String name) {
+    // Null name is allowed so no null check
+    final byte[] nameBytes = name == null
+        ? null
+        : name.getBytes(StandardCharsets.UTF_8);
+    return withDbName(nameBytes);
+  }
+
+  /**
+   * Create the {@link Dbi} with the passed name in byte[] form.
+   */
+  public RequireComparator<T> withDbName(final byte[] name) {
+    // Null name is allowed so no null check
+    this.name = name;
+    return new RequireComparator<>(this);
+  }
+
+  /**
+   * <p>
+   * Create the {@link Dbi} without a name.
+   * </p>
+   * <p>
+   * Equivalent to passing null to
+   * {@link DbiBuilder#withDbName(String)} or {@link DbiBuilder#withDbName(byte[])}.
+   * </p>
+   */
+  public RequireComparator<T> withoutDbName() {
+    return withDbName((byte[]) null);
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  /**
+   * Intermediate builder stage for constructing a {@link Dbi}.
+   *
+   * @param <T> buffer type
+   */
+  public static class RequireComparator<T> {
+
+    private final DbiBuilder<T> dbiBuilder;
+
+    private Comparator<T> comparator;
+    private boolean useNativeCallback;
+
+    private RequireComparator(final DbiBuilder<T> dbiBuilder) {
+      this.dbiBuilder = dbiBuilder;
+    }
+
+    /**
+     * <p>
+     * {@link CursorIterable} will call down to LMDB's {@code mdb_cmp} method when
+     * comparing entries to start/stop keys. This ensures LmdbJava is comparing start/stop
+     * keys using the same comparator that is used for insert order into the db.
+     * </p>
+     * <p>
+     * This option may be slightly less performant than when using
+     * {@link RequireComparator#withDefaultJavaComparator()} as it need to call down
+     * to LMDB to perform the comparisons, however it guarantees that {@link CursorIterable}
+     * key comparison matches LMDB key comparison.
+     * </p>
+     * <p>
+     * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
+     * you choose {@link RequireComparator#withNativeComparator()},
+     * {@link RequireComparator#withDefaultJavaComparator()} or
+     * {@link RequireComparator#withIteratorComparator(Comparator)} as these comparators will
+     * never be used.
+     * </p>
+     *
+     * @return this builder instance.
+     */
+    public FinalStage<T> withNativeComparator() {
+      this.comparator = null;
+      this.useNativeCallback = false;
+      return new FinalStage<>(this);
+    }
+
+    /**
+     * <p>
+     * {@link CursorIterable} will make use of the default Java-side comparators when
+     * comparing entries to start/stop keys.
+     * </p>
+     * <p>
+     * This option may be slightly more performant than when using
+     * {@link RequireComparator#withNativeComparator()} but it relies on the default comparator
+     * in LmdbJava behaving identically to the comparator in LMDB.
+     * </p>
+     * <p>
+     * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
+     * you choose {@link RequireComparator#withNativeComparator()},
+     * {@link RequireComparator#withDefaultJavaComparator()} or
+     * {@link RequireComparator#withIteratorComparator(Comparator)} as these comparators will
+     * never be used.
+     * </p>
+     *
+     * @return this builder instance.
+     */
+    public FinalStage<T> withDefaultJavaComparator() {
+      this.comparator = dbiBuilder.proxy.getUnsignedComparator();
+      this.useNativeCallback = false;
+      return new FinalStage<>(this);
+    }
+
+    /**
+     * Provide a java-side {@link Comparator} that LMDB will call back to in order to
+     * manage database insertion/iteration order. It will also be used for {@link CursorIterable}
+     * start/stop key comparisons.
+     * <p>
+     * Due to calling back to java, this will be less performant than using LMDB's
+     * default comparator, but allows for total control over the order in which entries
+     * are stored in the database.
+     * </p>
+     *
+     * @param comparator for all key comparison operations.
+     * @return this builder instance.
+     */
+    public FinalStage<T> withCallbackComparator(final Comparator<T> comparator) {
+      this.comparator = Objects.requireNonNull(comparator);
+      this.useNativeCallback = true;
+      return new FinalStage<>(this);
+    }
+
+    /**
+     * <p>
+     * {@link CursorIterable} will make use of the passed comparator for
+     * comparing entries to start/stop keys. It has NO bearing on the insert/iteration
+     * order of the db.
+     * </p>
+     * <p>
+     * <strong>WARNING:</strong> Only call this method if you fully understand the implications
+     * of using a comparator for the {@link CursorIterable} start/stop keys that behaves
+     * differently to the comparator in LMDB that controls the insert/iteration order.
+     * </p>
+     * <p>
+     * This option may be slightly less performant than when using
+     * {@link RequireComparator#withDefaultJavaComparator()} as it need to call down
+     * to LMDB to perform the comparisons, however it guarantees that {@link CursorIterable}
+     * key comparison matches LMDB key comparison.
+     * </p>
+     * <p>
+     * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
+     * you choose {@link RequireComparator#withNativeComparator()},
+     * {@link RequireComparator#withDefaultJavaComparator()} or
+     * {@link RequireComparator#withIteratorComparator(Comparator)} as these comparators will
+     * never be used.
+     * </p>
+     *
+     * @param comparator The comparator to use with {@link CursorIterable}.
+     * @return this builder instance.
+     */
+    public FinalStage<T> withIteratorComparator(final Comparator<T> comparator) {
+      this.comparator = Objects.requireNonNull(comparator);
+      this.useNativeCallback = false;
+      return new FinalStage<>(this);
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  /**
+   * Final stage builder for constructing a {@link Dbi}.
+   *
+   * @param <T> buffer type
+   */
+  public static class FinalStage<T> {
+
+    private final RequireComparator<T> requireComparator;
+    private Set<DbiFlags> dbiFlags = null;
+    private Txn<T> txn = null;
+
+    private FinalStage(RequireComparator<T> requireComparator) {
+      this.requireComparator = requireComparator;
+    }
+
+    private void initDbiFlags() {
+      if (dbiFlags == null) {
+        dbiFlags = EnumSet.noneOf(DbiFlags.class);
+      }
+    }
+
+    /**
+     * <p>
+     * Apply all the dbi flags supplied in dbiFlags.
+     * </p>
+     * <p>
+     * Replaces any flags applies in previous calls to
+     * {@link FinalStage#withDbiFlags(Collection)}, {@link FinalStage#withDbiFlags(DbiFlags...)}
+     * or {@link FinalStage#addDbiFlag(DbiFlags)}.
+     * </p>
+     *
+     * @param dbiFlags to open the database with.
+     */
+    public FinalStage<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
+      initDbiFlags();
+      if (dbiFlags != null) {
+        this.dbiFlags.addAll(dbiFlags);
+      }
+      return this;
+    }
+
+    /**
+     * <p>
+     * Apply all the dbi flags supplied in dbiFlags.
+     * </p>
+     * <p>
+     * Replaces any flags applies in previous calls to
+     * {@link FinalStage#withDbiFlags(Collection)}, {@link FinalStage#withDbiFlags(DbiFlags...)}
+     * or {@link FinalStage#addDbiFlag(DbiFlags)}.
+     * </p>
+     *
+     * @param dbiFlags to open the database with.
+     */
+    public FinalStage<T> withDbiFlags(final DbiFlags... dbiFlags) {
+      initDbiFlags();
+      if (dbiFlags != null) {
+        Arrays.stream(dbiFlags)
+            .filter(Objects::nonNull)
+            .forEach(this.dbiFlags::add);
+      }
+      return this;
+    }
+
+    /**
+     * Adds dbiFlag to those flags already added to this builder.
+     *
+     * @param dbiFlag to open the database with.
+     * @return this builder instance.
+     */
+    public FinalStage<T> addDbiFlag(final DbiFlags dbiFlag) {
+      initDbiFlags();
+      if (dbiFlags != null) {
+        this.dbiFlags.add(dbiFlag);
+      }
+      return this;
+    }
+
+    /**
+     * Use the supplied transaction to open the {@link Dbi}.
+     * <p>
+     * The caller must commit the transaction after calling {@link FinalStage#open()}
+     * in order to retain the <code>Dbi</code> in the <code>Env</code>.
+     * </p>
+     *
+     * @param txn transaction to use (required; not closed)
+     * @return this builder instance.
+     */
+    public FinalStage<T> withTxn(final Txn<T> txn) {
+      this.txn = Objects.requireNonNull(txn);
+      return this;
+    }
+
+    /**
+     * Construct and open the {@link Dbi}.
+     * <p>
+     * If a {@link Txn} was supplied to the builder, it should be committed upon return from
+     * this method.
+     * </p>
+     *
+     * @return A newly constructed and opened {@link Dbi}.
+     */
+    public Dbi<T> open() {
+      final DbiBuilder<T> dbiBuilder = requireComparator.dbiBuilder;
+      if (txn == null) {
+        try (final Txn<T> txn = getTxn(dbiBuilder)) {
+          return open(txn, dbiBuilder);
+        }
+      } else {
+        return open(txn, dbiBuilder);
+      }
+    }
+
+    private Txn<T> getTxn(final DbiBuilder<T> dbiBuilder) {
+      return dbiBuilder.readOnly
+          ? dbiBuilder.env.txnRead()
+          : dbiBuilder.env.txnWrite();
+    }
+
+    private Dbi<T> open(final Txn<T> txn,
+                        final DbiBuilder<T> dbiBuilder) {
+      final DbiFlags[] dbiFlagsArr = dbiFlags != null && !dbiFlags.isEmpty()
+          ? this.dbiFlags.toArray(new DbiFlags[0])
+          : null;
+
+      return new Dbi<>(
+          dbiBuilder.env,
+          txn,
+          dbiBuilder.name,
+          requireComparator.comparator,
+          requireComparator.useNativeCallback,
+          dbiBuilder.proxy,
+          dbiFlagsArr);
+    }
+  }
+}
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 2f5eadf6..af6eaeaa 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -31,6 +31,9 @@ public enum DbiFlags implements MaskedFlag {
    * <p>Duplicate keys may be used in the database. Or, from another perspective, keys may have
    * multiple data items, stored in sorted order. By default keys must be unique and may have only a
    * single data item.
+   * <p>
+   *
+   * </p>
    */
   MDB_DUPSORT(0x04),
   /**
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 2e4822b7..d7c7b269 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -145,7 +145,7 @@ public void close() {
   public void copy(final File path, final CopyFlags... flags) {
     requireNonNull(path);
     validatePath(path);
-    final int flagsMask = mask(true, flags);
+    final int flagsMask = mask(flags);
     checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flagsMask));
   }
 
@@ -241,6 +241,15 @@ public boolean isReadOnly() {
     return readOnly;
   }
 
+  /**
+   * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set)
+   * a {@link Dbi} using a builder.
+   * @return A new builder instance for creating/opening a {@link Dbi}.
+   */
+  public DbiBuilder<T> buildDbi() {
+    return new DbiBuilder<>(this, proxy, readOnly);
+  }
+
   /**
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
    * Comparator} that is not invoked from native code.
@@ -248,7 +257,9 @@ public boolean isReadOnly() {
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
     return openDbi(nameBytes, null, false, flags);
@@ -268,7 +279,9 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
    *     comparator will be used.
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final String name, final Comparator<T> comparator, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
@@ -288,7 +301,9 @@ public Dbi<T> openDbi(
    * @param nativeCb whether LMDB native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final String name,
       final Comparator<T> comparator,
@@ -305,7 +320,9 @@ public Dbi<T> openDbi(
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
     return openDbi(name, null, false, flags);
   }
@@ -318,7 +335,9 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
    * @param comparator custom comparator callback (or null to use LMDB default)
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final byte[] name, final Comparator<T> comparator, final DbiFlags... flags) {
     return openDbi(name, comparator, false, flags);
@@ -336,7 +355,9 @@ public Dbi<T> openDbi(
    * @param nativeCb whether native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final byte[] name,
       final Comparator<T> comparator,
@@ -375,7 +396,9 @@ public Dbi<T> openDbi(
    * @param nativeCb whether native code should call back to the comparator
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final Txn<T> txn,
       final byte[] name,
@@ -557,7 +580,7 @@ public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
         checkRc(LIB.mdb_env_set_mapsize(ptr, mapSize));
         checkRc(LIB.mdb_env_set_maxdbs(ptr, maxDbs));
         checkRc(LIB.mdb_env_set_maxreaders(ptr, maxReaders));
-        final int flagsMask = mask(true, flags);
+        final int flagsMask = mask(flags);
         final boolean readOnly = isSet(flagsMask, MDB_RDONLY_ENV);
         final boolean noSubDir = isSet(flagsMask, MDB_NOSUBDIR);
         checkRc(LIB.mdb_env_open(ptr, path.getAbsolutePath(), flagsMask, mode));
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 00556ecb..4dc47b20 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -17,11 +17,6 @@
 
 import static java.util.Objects.requireNonNull;
 
-import java.util.Arrays;
-import java.util.Objects;
-import java.util.function.Predicate;
-import java.util.stream.Stream;
-
 /** Indicates an enum that can provide integers for each of its values. */
 public interface MaskedFlag {
 
@@ -32,15 +27,6 @@ public interface MaskedFlag {
    */
   int getMask();
 
-  /**
-   * Indicates if the flag must be propagated to the underlying C code of LMDB or not.
-   *
-   * @return the boolean value indicating the propagation
-   */
-  default boolean isPropagatedToLmdb() {
-    return true;
-  }
-
   /**
    * Fetch the integer mask for all presented flags.
    *
@@ -50,54 +36,18 @@ default boolean isPropagatedToLmdb() {
    */
   @SafeVarargs
   static <M extends MaskedFlag> int mask(final M... flags) {
-    return mask(false, flags);
-  }
-
-  /**
-   * Fetch the integer mask for all presented flags.
-   *
-   * @param <M> flag type
-   * @param flags to mask (null or empty returns zero)
-   * @return the integer mask for use in C
-   */
-  static <M extends MaskedFlag> int mask(final Stream<M> flags) {
-    return mask(false, flags);
-  }
-
-  /**
-   * Fetch the integer mask for the presented flags.
-   *
-   * @param <M> flag type
-   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code
-   *     or all of them
-   * @param flags to mask (null or empty returns zero)
-   * @return the integer mask for use in C
-   */
-  @SafeVarargs
-  static <M extends MaskedFlag> int mask(final boolean onlyPropagatedToLmdb, final M... flags) {
-    return flags == null ? 0 : mask(onlyPropagatedToLmdb, Arrays.stream(flags));
-  }
-
-  /**
-   * Fetch the integer mask for all presented flags.
-   *
-   * @param <M> flag type
-   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code
-   *     or all of them
-   * @param flags to mask
-   * @return the integer mask for use in C
-   */
-  static <M extends MaskedFlag> int mask(
-      final boolean onlyPropagatedToLmdb, final Stream<M> flags) {
-    final Predicate<M> filter = onlyPropagatedToLmdb ? MaskedFlag::isPropagatedToLmdb : f -> true;
+    if (flags == null || flags.length == 0) {
+      return 0;
+    }
 
-    return flags == null
-        ? 0
-        : flags
-            .filter(Objects::nonNull)
-            .filter(filter)
-            .map(M::getMask)
-            .reduce(0, (f1, f2) -> f1 | f2);
+    int result = 0;
+    for (MaskedFlag flag : flags) {
+      if (flag == null) {
+        continue;
+      }
+      result |= flag.getMask();
+    }
+    return result;
   }
 
   /**
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 05e8ce06..1d5d4860 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -49,7 +49,7 @@ public final class Txn<T> implements AutoCloseable {
   Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlags... flags) {
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
-    final int flagsMask = mask(true, flags);
+    final int flagsMask = mask(flags);
     this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
     if (env.isReadOnly() && !this.readOnly) {
       throw new EnvIsReadOnly();

From bfbf223031191e0bb13c7c32a58930c85e880f5c Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 27 Oct 2025 15:23:46 +0000
Subject: [PATCH 08/90] Add FlagSet, DbiFlagSet, PutFlagSet

Refactor DbiBuilder and Dbi ctor to use DbiFlagSet.
---
 src/main/java/org/lmdbjava/Dbi.java           |  29 ++-
 src/main/java/org/lmdbjava/DbiBuilder.java    |  42 ++--
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  32 +++
 src/main/java/org/lmdbjava/Env.java           |   2 +-
 src/main/java/org/lmdbjava/FlagSet.java       | 192 ++++++++++++++++++
 src/main/java/org/lmdbjava/MaskedFlag.java    |  38 +++-
 src/main/java/org/lmdbjava/PutFlagSet.java    |  32 +++
 .../java/org/lmdbjava/DbiFlagSetTest.java     | 101 +++++++++
 .../java/org/lmdbjava/PutFlagSetTest.java     | 101 +++++++++
 9 files changed, 531 insertions(+), 38 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/DbiFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/FlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/PutFlagSet.java
 create mode 100644 src/test/java/org/lmdbjava/DbiFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/PutFlagSetTest.java

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index ba20c1a4..17fa4c46 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -31,6 +31,7 @@
 import static org.lmdbjava.PutFlags.MDB_RESERVE;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
@@ -55,6 +56,7 @@ public final class Dbi<T> {
   private final byte[] name;
   private final Pointer ptr;
   private final BufferProxy<T> proxy;
+  private final DbiFlagSet dbiFlagSet;
 
   Dbi(
       final Env<T> env,
@@ -63,7 +65,7 @@ public final class Dbi<T> {
       final Comparator<T> comparator,
       final boolean nativeCb,
       final BufferProxy<T> proxy,
-      final DbiFlags... flags) {
+      final DbiFlagSet dbiFlagSet) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       txn.checkReady();
@@ -72,9 +74,9 @@ public final class Dbi<T> {
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
     this.proxy = proxy;
     this.comparator = comparator;
-    final int flagsMask = mask(flags);
+    this.dbiFlagSet = dbiFlagSet;
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
-    checkRc(LIB.mdb_dbi_open(txn.pointer(), name, flagsMask, dbiPtr));
+    checkRc(LIB.mdb_dbi_open(txn.pointer(), name, dbiFlagSet.getMask(), dbiPtr));
     ptr = dbiPtr.getPointer(0);
     if (nativeCb) {
       requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
@@ -291,6 +293,7 @@ public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
    * @return the list of flags this Dbi was created with
    */
   public List<DbiFlags> listFlags(final Txn<T> txn) {
+    // TODO we could just return what is in dbiFlagSet, rather than hitting LMDB.
     if (SHOULD_CHECK) {
       env.checkNotClosed();
     }
@@ -457,6 +460,26 @@ private void clean() {
     cleaned = true;
   }
 
+  private String getNameAsString() {
+    if (name == null) {
+      return "";
+    } else {
+      try {
+        return new String(name, StandardCharsets.UTF_8);
+      } catch (Exception e) {
+        return "?";
+      }
+    }
+  }
+
+  @Override
+  public String toString() {
+    return "Dbi{" +
+            "name=" + getNameAsString() +
+            ", dbiFlagSet=" + dbiFlagSet +
+            '}';
+  }
+
   /** The specified DBI was changed unexpectedly. */
   public static final class BadDbiException extends LmdbNativeException {
 
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 5deb2e38..1803d142 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -19,9 +19,7 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Comparator;
-import java.util.EnumSet;
 import java.util.Objects;
-import java.util.Set;
 
 /**
  * Staged builder for building a {@link Dbi}
@@ -224,19 +222,13 @@ public DbiBuilderStage3<T> withIteratorComparator(final Comparator<T> comparator
   public static class DbiBuilderStage3<T> {
 
     private final DbiBuilderStage2<T> dbiBuilderStage2;
-    private Set<DbiFlags> dbiFlags = null;
+    private final FlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder = DbiFlagSet.builder();
     private Txn<T> txn = null;
 
     private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
       this.dbiBuilderStage2 = dbiBuilderStage2;
     }
 
-    private void initDbiFlags() {
-      if (dbiFlags == null) {
-        dbiFlags = EnumSet.noneOf(DbiFlags.class);
-      }
-    }
-
     /**
      * <p>
      * Apply all the dbi flags supplied in dbiFlags.
@@ -244,15 +236,14 @@ private void initDbiFlags() {
      * <p>
      * Replaces any flags applies in previous calls to
      * {@link DbiBuilderStage3#withDbiFlags(Collection)}, {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlags to open the database with.
      */
     public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
-      initDbiFlags();
       if (dbiFlags != null) {
-        this.dbiFlags.stream()
+        dbiFlags.stream()
                 .filter(Objects::nonNull)
                 .forEach(dbiFlags::add);
       }
@@ -265,36 +256,35 @@ public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
      * </p>
      * <p>
      * Replaces any flags applies in previous calls to
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)}, {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * {@link DbiBuilderStage3#withDbiFlags(Collection)},
+     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
+     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlags to open the database with.
      *                 A null array is a no-op. Null items are ignored.
      */
     public DbiBuilderStage3<T> withDbiFlags(final DbiFlags... dbiFlags) {
-      initDbiFlags();
+      flagSetBuilder.clear();
       if (dbiFlags != null) {
         Arrays.stream(dbiFlags)
             .filter(Objects::nonNull)
-            .forEach(this.dbiFlags::add);
+            .forEach(this.flagSetBuilder::setFlag);
       }
       return this;
     }
 
     /**
      * Adds dbiFlag to those flags already added to this builder by
-     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#withDbiFlags(Collection)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)},
+     * {@link DbiBuilderStage3#withDbiFlags(Collection)}
+     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
      *
      * @param dbiFlag to open the database with. A null value is a no-op.
      * @return this builder instance.
      */
-    public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
-      initDbiFlags();
-      if (dbiFlags != null) {
-        this.dbiFlags.add(dbiFlag);
-      }
+    public DbiBuilderStage3<T> setDbiFlag(final DbiFlags dbiFlag) {
+      this.flagSetBuilder.setFlag(dbiFlag);
       return this;
     }
 
@@ -341,9 +331,7 @@ private Txn<T> getTxn(final DbiBuilder<T> dbiBuilder) {
 
     private Dbi<T> open(final Txn<T> txn,
                         final DbiBuilder<T> dbiBuilder) {
-      final DbiFlags[] dbiFlagsArr = dbiFlags != null && !dbiFlags.isEmpty()
-          ? this.dbiFlags.toArray(new DbiFlags[0])
-          : null;
+      final DbiFlagSet dbiFlagSet = flagSetBuilder.build();
 
       return new Dbi<>(
           dbiBuilder.env,
@@ -352,7 +340,7 @@ private Dbi<T> open(final Txn<T> txn,
           dbiBuilderStage2.comparator,
           dbiBuilderStage2.useNativeCallback,
           dbiBuilder.proxy,
-          dbiFlagsArr);
+          dbiFlagSet);
     }
   }
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
new file mode 100644
index 00000000..2c6c5ac7
--- /dev/null
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -0,0 +1,32 @@
+package org.lmdbjava;
+
+import java.util.EnumSet;
+import java.util.Objects;
+
+public class DbiFlagSet extends FlagSet<DbiFlags> {
+
+    public static final DbiFlagSet EMPTY = new DbiFlagSet(EnumSet.noneOf(DbiFlags.class));
+
+    private DbiFlagSet(final EnumSet<DbiFlags> flags) {
+        super(flags);
+    }
+
+    public static DbiFlagSet empty() {
+        return EMPTY;
+    }
+
+    public static DbiFlagSet of(final DbiFlags putFlag) {
+        Objects.requireNonNull(putFlag);
+        return new DbiFlagSet(EnumSet.of(putFlag));
+    }
+
+    public static DbiFlagSet of(final DbiFlags... DbiFlags) {
+        return builder()
+                .withFlags(DbiFlags)
+                .build();
+    }
+
+    public static Builder<DbiFlags, DbiFlagSet> builder() {
+        return new Builder<>(DbiFlags.class, DbiFlagSet::new);
+    }
+}
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index d7c7b269..5de0a7fd 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -405,7 +405,7 @@ public Dbi<T> openDbi(
       final Comparator<T> comparator,
       final boolean nativeCb,
       final DbiFlags... flags) {
-    return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, flags);
+    return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
   }
 
   /**
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
new file mode 100644
index 00000000..21132f8c
--- /dev/null
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -0,0 +1,192 @@
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
+ *
+ * @param <T>
+ */
+public abstract class FlagSet<T extends Enum<T> & MaskedFlag> implements Iterable<T> {
+
+  private final Set<T> flags;
+  private final int mask;
+
+  protected FlagSet(final EnumSet<T> flags) {
+    Objects.requireNonNull(flags);
+    this.mask = MaskedFlag.mask(flags);
+    this.flags = Collections.unmodifiableSet(Objects.requireNonNull(flags));
+  }
+
+  /**
+   * @return THe combined bit mask for all flags in the set.
+   */
+  int getMask() {
+    return mask;
+  }
+
+  /**
+   * @return All flags in the set.
+   */
+  public Set<T> getFlags() {
+    return flags;
+  }
+
+  /**
+   * @return True if flag has been set, i.e. is contained in this set.
+   */
+  public boolean isSet(final T flag) {
+    return flag != null
+        && flags.contains(flag);
+  }
+
+  /**
+   * @return The number of flags in this set.
+   */
+  public int size() {
+    return flags.size();
+  }
+
+  /**
+   * @return True if this set is empty.
+   */
+  public boolean isEmpty() {
+    return flags.isEmpty();
+  }
+
+  /**
+   * @return The {@link Iterator} for this set.
+   */
+  @Override
+  public Iterator<T> iterator() {
+    return flags.iterator();
+  }
+
+  @Override
+  public boolean equals(Object object) {
+    if (this == object) return true;
+    if (object == null || getClass() != object.getClass()) return false;
+    FlagSet<?> flagSet = (FlagSet<?>) object;
+    return mask == flagSet.mask && Objects.equals(flags, flagSet.flags);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(flags, mask);
+  }
+
+  @Override
+  public String toString() {
+    final String flagsStr = flags.stream()
+        .sorted(Comparator.comparing(MaskedFlag::getMask))
+        .map(MaskedFlag::name)
+        .collect(Collectors.joining(", "));
+    return "FlagSet{" +
+        "flags=[" + flagsStr +
+        "], mask=" + mask +
+        '}';
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  /**
+   * A builder for creating a {@link FlagSet}.
+   *
+   * @param <E> The type of flag to be held in the {@link FlagSet}
+   * @param <S> The type of the {@link FlagSet} implementation.
+   */
+  public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>> {
+
+    final Class<E> type;
+    final EnumSet<E> enumSet;
+    final Function<EnumSet<E>, S> constructor;
+
+    protected Builder(final Class<E> type,
+                      final Function<EnumSet<E>, S> constructor) {
+      this.type = type;
+      this.enumSet = EnumSet.noneOf(type);
+      this.constructor = constructor;
+    }
+
+    /**
+     * Replaces any flags already set in the builder with the contents of the passed flags {@link Collection}
+     *
+     * @param flags The flags to set in the builder.
+     * @return this builder instance.
+     */
+    public Builder<E, S> withFlags(final Collection<E> flags) {
+      enumSet.clear();
+      if (flags != null) {
+        for (E flag : flags) {
+          if (flag != null) {
+            enumSet.add(flag);
+          }
+        }
+      }
+      return this;
+    }
+
+    /**
+     * @param flags The flags to set in the builder.
+     * @return this builder instance.
+     */
+    @SafeVarargs
+    public final Builder<E, S> withFlags(final E... flags) {
+      enumSet.clear();
+      if (flags != null) {
+        for (E flag : flags) {
+          if (flag != null) {
+            if (!type.equals(flag.getClass())) {
+              throw new IllegalArgumentException("Unexpected type " + flag.getClass());
+            }
+            enumSet.add(flag);
+          }
+        }
+      }
+      return this;
+    }
+
+    /**
+     * Sets a single flag in the builder.
+     *
+     * @param flag The flag to set in the builder.
+     * @return this builder instance.
+     */
+    public Builder<E, S> setFlag(final E flag) {
+      if (flag != null) {
+        enumSet.add(flag);
+      }
+      return this;
+    }
+
+    /**
+     * Clears any flags already set in this {@link Builder}
+     *
+     * @return this builder instance.
+     */
+    public Builder<E, S> clear() {
+      enumSet.clear();
+      return this;
+    }
+
+    /**
+     * Build the {@link DbiFlagSet}
+     *
+     * @return A
+     */
+    public S build() {
+      return constructor.apply(enumSet);
+    }
+  }
+}
+
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 4dc47b20..f2f08274 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -17,9 +17,13 @@
 
 import static java.util.Objects.requireNonNull;
 
+import java.util.Collection;
+
 /** Indicates an enum that can provide integers for each of its values. */
 public interface MaskedFlag {
 
+  int EMPTY_MASK = 0;
+
   /**
    * Obtains the integer value for this enum which can be included in a mask.
    *
@@ -27,6 +31,11 @@ public interface MaskedFlag {
    */
   int getMask();
 
+  /**
+   * @return The name of the flag.
+   */
+  String name();
+
   /**
    * Fetch the integer mask for all presented flags.
    *
@@ -37,17 +46,32 @@ public interface MaskedFlag {
   @SafeVarargs
   static <M extends MaskedFlag> int mask(final M... flags) {
     if (flags == null || flags.length == 0) {
-      return 0;
+      return EMPTY_MASK;
+    } else {
+      int result = EMPTY_MASK;
+      for (MaskedFlag flag : flags) {
+        if (flag == null) {
+          continue;
+        }
+        result |= flag.getMask();
+      }
+      return result;
     }
+  }
 
-    int result = 0;
-    for (MaskedFlag flag : flags) {
-      if (flag == null) {
-        continue;
+  static <M extends MaskedFlag> int mask(final Collection<M> flags) {
+    if (flags == null || flags.isEmpty()) {
+      return EMPTY_MASK;
+    } else {
+      int result = EMPTY_MASK;
+      for (MaskedFlag flag : flags) {
+        if (flag == null) {
+          continue;
+        }
+        result |= flag.getMask();
       }
-      result |= flag.getMask();
+      return result;
     }
-    return result;
   }
 
   /**
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
new file mode 100644
index 00000000..290f9729
--- /dev/null
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -0,0 +1,32 @@
+package org.lmdbjava;
+
+import java.util.EnumSet;
+import java.util.Objects;
+
+public class PutFlagSet extends FlagSet<PutFlags> {
+
+    public static final PutFlagSet EMPTY = new PutFlagSet(EnumSet.noneOf(PutFlags.class));
+
+    private PutFlagSet(final EnumSet<PutFlags> flags) {
+        super(flags);
+    }
+
+    public static PutFlagSet empty() {
+        return EMPTY;
+    }
+
+    public static PutFlagSet of(final PutFlags putFlag) {
+        Objects.requireNonNull(putFlag);
+        return new org.lmdbjava.PutFlagSet(EnumSet.of(putFlag));
+    }
+
+    public static PutFlagSet of(final PutFlags... putFlags) {
+        return builder()
+                .withFlags(putFlags)
+                .build();
+    }
+
+    public static Builder<PutFlags, PutFlagSet> builder() {
+        return new Builder<>(PutFlags.class, PutFlagSet::new);
+    }
+}
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
new file mode 100644
index 00000000..cfbda600
--- /dev/null
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -0,0 +1,101 @@
+package org.lmdbjava;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import org.junit.Test;
+
+public class DbiFlagSetTest {
+
+    @Test
+    public void testEmpty() {
+        final DbiFlagSet putFlagSet = DbiFlagSet.empty();
+        assertThat(
+                putFlagSet.getMask(),
+                is(0));
+        assertThat(
+                putFlagSet.size(),
+                is(0));
+        assertThat(
+                putFlagSet.isEmpty(),
+                is(true));
+        assertThat(
+                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                is(false));
+    }
+
+    @Test
+    public void testOf() {
+        final DbiFlags putFlag = DbiFlags.MDB_CREATE;
+        final DbiFlagSet putFlagSet = DbiFlagSet.of(putFlag);
+        assertThat(
+                putFlagSet.getMask(),
+                is(MaskedFlag.mask(putFlag)));
+        assertThat(
+                putFlagSet.size(),
+                is(1));
+        assertThat(
+                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                is(false));
+        for (DbiFlags flag : putFlagSet) {
+            assertThat(
+                    putFlagSet.isSet(flag),
+                    is(true));
+        }
+    }
+
+    @Test
+    public void testOf2() {
+        final DbiFlags putFlag1 = DbiFlags.MDB_CREATE;
+        final DbiFlags putFlag2 = DbiFlags.MDB_INTEGERKEY;
+        final DbiFlagSet putFlagSet = DbiFlagSet.of(putFlag1, putFlag2);
+        assertThat(
+                putFlagSet.getMask(),
+                is(MaskedFlag.mask(putFlag1, putFlag2)));
+        assertThat(
+                putFlagSet.size(),
+                is(2));
+        assertThat(
+                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                is(false));
+        for (DbiFlags flag : putFlagSet) {
+            assertThat(
+                    putFlagSet.isSet(flag),
+                    is(true));
+        }
+    }
+
+    @Test
+    public void testBuilder() {
+        final DbiFlags putFlag1 = DbiFlags.MDB_CREATE;
+        final DbiFlags putFlag2 = DbiFlags.MDB_INTEGERKEY;
+        final DbiFlagSet putFlagSet = DbiFlagSet.builder()
+                .setFlag(putFlag1)
+                .setFlag(putFlag2)
+                .build();
+        assertThat(
+                putFlagSet.getMask(),
+                is(MaskedFlag.mask(putFlag1, putFlag2)));
+        assertThat(
+                putFlagSet.size(),
+                is(2));
+        assertThat(
+                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                is(false));
+        for (DbiFlags flag : putFlagSet) {
+            assertThat(
+                    putFlagSet.isSet(flag),
+                    is(true));
+        }
+        final DbiFlagSet putFlagSet2 = DbiFlagSet.builder()
+                .withFlags(putFlag1, putFlag2)
+                .build();
+        final DbiFlagSet putFlagSet3 = DbiFlagSet.builder()
+                .withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2)))
+                .build();
+        assertThat(putFlagSet, is(putFlagSet2));
+        assertThat(putFlagSet, is(putFlagSet3));
+    }
+}
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
new file mode 100644
index 00000000..4826f436
--- /dev/null
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -0,0 +1,101 @@
+package org.lmdbjava;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import org.junit.Test;
+
+public class PutFlagSetTest {
+
+    @Test
+    public void testEmpty() {
+        final PutFlagSet putFlagSet = PutFlagSet.empty();
+        assertThat(
+                putFlagSet.getMask(),
+                is(0));
+        assertThat(
+                putFlagSet.size(),
+                is(0));
+        assertThat(
+                putFlagSet.isEmpty(),
+                is(true));
+        assertThat(
+                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+                is(false));
+    }
+
+    @Test
+    public void testOf() {
+        final PutFlags putFlag = PutFlags.MDB_APPEND;
+        final PutFlagSet putFlagSet = PutFlagSet.of(putFlag);
+        assertThat(
+                putFlagSet.getMask(),
+                is(MaskedFlag.mask(putFlag)));
+        assertThat(
+                putFlagSet.size(),
+                is(1));
+        assertThat(
+                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+                is(false));
+        for (PutFlags flag : putFlagSet) {
+            assertThat(
+                    putFlagSet.isSet(flag),
+                    is(true));
+        }
+    }
+
+    @Test
+    public void testOf2() {
+        final PutFlags putFlag1 = PutFlags.MDB_APPEND;
+        final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
+        final PutFlagSet putFlagSet = PutFlagSet.of(putFlag1, putFlag2);
+        assertThat(
+                putFlagSet.getMask(),
+                is(MaskedFlag.mask(putFlag1, putFlag2)));
+        assertThat(
+                putFlagSet.size(),
+                is(2));
+        assertThat(
+                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+                is(false));
+        for (PutFlags flag : putFlagSet) {
+            assertThat(
+                    putFlagSet.isSet(flag),
+                    is(true));
+        }
+    }
+
+    @Test
+    public void testBuilder() {
+        final PutFlags putFlag1 = PutFlags.MDB_APPEND;
+        final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
+        final PutFlagSet putFlagSet = PutFlagSet.builder()
+                .setFlag(putFlag1)
+                .setFlag(putFlag2)
+                .build();
+        assertThat(
+                putFlagSet.getMask(),
+                is(MaskedFlag.mask(putFlag1, putFlag2)));
+        assertThat(
+                putFlagSet.size(),
+                is(2));
+        assertThat(
+                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+                is(false));
+        for (PutFlags flag : putFlagSet) {
+            assertThat(
+                    putFlagSet.isSet(flag),
+                    is(true));
+        }
+        final PutFlagSet putFlagSet2 = PutFlagSet.builder()
+                .withFlags(putFlag1, putFlag2)
+                .build();
+        final PutFlagSet putFlagSet3 = PutFlagSet.builder()
+                .withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2)))
+                .build();
+        assertThat(putFlagSet, is(putFlagSet2));
+        assertThat(putFlagSet, is(putFlagSet3));
+    }
+}

From 0f66aaf7021ebb25a295dc95ba56a8c78c6370d5 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 27 Oct 2025 15:27:35 +0000
Subject: [PATCH 09/90] Rename FlagSet to AbstractFlagSet

---
 .../{FlagSet.java => AbstractFlagSet.java}         | 14 +++++++-------
 src/main/java/org/lmdbjava/DbiBuilder.java         |  2 +-
 src/main/java/org/lmdbjava/DbiFlagSet.java         |  2 +-
 src/main/java/org/lmdbjava/PutFlagSet.java         |  2 +-
 4 files changed, 10 insertions(+), 10 deletions(-)
 rename src/main/java/org/lmdbjava/{FlagSet.java => AbstractFlagSet.java} (90%)

diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
similarity index 90%
rename from src/main/java/org/lmdbjava/FlagSet.java
rename to src/main/java/org/lmdbjava/AbstractFlagSet.java
index 21132f8c..3c21fb15 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -15,12 +15,12 @@
  *
  * @param <T>
  */
-public abstract class FlagSet<T extends Enum<T> & MaskedFlag> implements Iterable<T> {
+public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements Iterable<T> {
 
   private final Set<T> flags;
   private final int mask;
 
-  protected FlagSet(final EnumSet<T> flags) {
+  protected AbstractFlagSet(final EnumSet<T> flags) {
     Objects.requireNonNull(flags);
     this.mask = MaskedFlag.mask(flags);
     this.flags = Collections.unmodifiableSet(Objects.requireNonNull(flags));
@@ -74,7 +74,7 @@ public Iterator<T> iterator() {
   public boolean equals(Object object) {
     if (this == object) return true;
     if (object == null || getClass() != object.getClass()) return false;
-    FlagSet<?> flagSet = (FlagSet<?>) object;
+    AbstractFlagSet<?> flagSet = (AbstractFlagSet<?>) object;
     return mask == flagSet.mask && Objects.equals(flags, flagSet.flags);
   }
 
@@ -100,12 +100,12 @@ public String toString() {
 
 
   /**
-   * A builder for creating a {@link FlagSet}.
+   * A builder for creating a {@link AbstractFlagSet}.
    *
-   * @param <E> The type of flag to be held in the {@link FlagSet}
-   * @param <S> The type of the {@link FlagSet} implementation.
+   * @param <E> The type of flag to be held in the {@link AbstractFlagSet}
+   * @param <S> The type of the {@link AbstractFlagSet} implementation.
    */
-  public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>> {
+  public static class Builder<E extends Enum<E> & MaskedFlag, S extends AbstractFlagSet<E>> {
 
     final Class<E> type;
     final EnumSet<E> enumSet;
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 1803d142..7d05a51e 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -222,7 +222,7 @@ public DbiBuilderStage3<T> withIteratorComparator(final Comparator<T> comparator
   public static class DbiBuilderStage3<T> {
 
     private final DbiBuilderStage2<T> dbiBuilderStage2;
-    private final FlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder = DbiFlagSet.builder();
+    private final AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder = DbiFlagSet.builder();
     private Txn<T> txn = null;
 
     private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 2c6c5ac7..cd1db934 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -3,7 +3,7 @@
 import java.util.EnumSet;
 import java.util.Objects;
 
-public class DbiFlagSet extends FlagSet<DbiFlags> {
+public class DbiFlagSet extends AbstractFlagSet<DbiFlags> {
 
     public static final DbiFlagSet EMPTY = new DbiFlagSet(EnumSet.noneOf(DbiFlags.class));
 
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 290f9729..8820fe92 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -3,7 +3,7 @@
 import java.util.EnumSet;
 import java.util.Objects;
 
-public class PutFlagSet extends FlagSet<PutFlags> {
+public class PutFlagSet extends AbstractFlagSet<PutFlags> {
 
     public static final PutFlagSet EMPTY = new PutFlagSet(EnumSet.noneOf(PutFlags.class));
 

From aa000a1389755dc8f2de4152d149fa6da09b6d22 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 27 Oct 2025 21:19:27 +0000
Subject: [PATCH 10/90] Add remaining FlagSet impls

Replace Env#copy(File, CopyFlags...) with copy(File, CopyFlagSet).
As there is only one flag this should not be a breaking change.

Deprecate Env#txn(Txn, TxnFlags...) as there is now
Env#txn(Txn)
Env#txn(Txn, TxnFlags)
Env#txn(Txn, TxnFlagSet)
---
 .../java/org/lmdbjava/AbstractFlagSet.java    | 186 +++++++++++++++---
 src/main/java/org/lmdbjava/CopyFlagSet.java   |  59 ++++++
 src/main/java/org/lmdbjava/CopyFlags.java     |  30 ++-
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  63 ++++--
 src/main/java/org/lmdbjava/DbiFlags.java      |  30 ++-
 src/main/java/org/lmdbjava/Env.java           |  77 +++++++-
 src/main/java/org/lmdbjava/EnvFlagSet.java    |  57 ++++++
 src/main/java/org/lmdbjava/EnvFlags.java      |  30 ++-
 src/main/java/org/lmdbjava/FlagSet.java       |  61 ++++++
 src/main/java/org/lmdbjava/PutFlagSet.java    |  53 +++--
 src/main/java/org/lmdbjava/PutFlags.java      |  30 ++-
 src/main/java/org/lmdbjava/Txn.java           |  12 +-
 src/main/java/org/lmdbjava/TxnFlagSet.java    |  63 ++++++
 src/main/java/org/lmdbjava/TxnFlags.java      |  30 ++-
 .../java/org/lmdbjava/CopyFlagSetTest.java    |  88 +++++++++
 .../java/org/lmdbjava/DbiFlagSetTest.java     |  93 +++++----
 .../java/org/lmdbjava/EnvFlagSetTest.java     | 116 +++++++++++
 .../java/org/lmdbjava/PutFlagSetTest.java     |  15 ++
 .../java/org/lmdbjava/TxnFlagSetTest.java     |  88 +++++++++
 19 files changed, 1066 insertions(+), 115 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/CopyFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/EnvFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/FlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/TxnFlagSet.java
 create mode 100644 src/test/java/org/lmdbjava/CopyFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/EnvFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/TxnFlagSetTest.java

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 3c21fb15..7ea413fb 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -2,20 +2,19 @@
 
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Comparator;
 import java.util.EnumSet;
 import java.util.Iterator;
 import java.util.Objects;
 import java.util.Set;
 import java.util.function.Function;
-import java.util.stream.Collectors;
+import java.util.function.Supplier;
 
 /**
  * Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
  *
  * @param <T>
  */
-public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements Iterable<T> {
+public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
 
   private final Set<T> flags;
   private final int mask;
@@ -29,13 +28,15 @@ protected AbstractFlagSet(final EnumSet<T> flags) {
   /**
    * @return THe combined bit mask for all flags in the set.
    */
-  int getMask() {
+  @Override
+  public int getMask() {
     return mask;
   }
 
   /**
    * @return All flags in the set.
    */
+  @Override
   public Set<T> getFlags() {
     return flags;
   }
@@ -43,14 +44,18 @@ public Set<T> getFlags() {
   /**
    * @return True if flag has been set, i.e. is contained in this set.
    */
+  @Override
   public boolean isSet(final T flag) {
+    // Probably cheaper to compare the masks than to use EnumSet.contains()
     return flag != null
-        && flags.contains(flag);
+        && MaskedFlag.isSet(mask, flag);
+
   }
 
   /**
    * @return The number of flags in this set.
    */
+  @Override
   public int size() {
     return flags.size();
   }
@@ -58,6 +63,7 @@ public int size() {
   /**
    * @return True if this set is empty.
    */
+  @Override
   public boolean isEmpty() {
     return flags.isEmpty();
   }
@@ -73,9 +79,8 @@ public Iterator<T> iterator() {
   @Override
   public boolean equals(Object object) {
     if (this == object) return true;
-    if (object == null || getClass() != object.getClass()) return false;
-    AbstractFlagSet<?> flagSet = (AbstractFlagSet<?>) object;
-    return mask == flagSet.mask && Objects.equals(flags, flagSet.flags);
+//    if (object == null || getClass() != object.getClass()) return false;
+    return FlagSet.equals(this, (FlagSet<?>) object);
   }
 
   @Override
@@ -85,14 +90,137 @@ public int hashCode() {
 
   @Override
   public String toString() {
-    final String flagsStr = flags.stream()
-        .sorted(Comparator.comparing(MaskedFlag::getMask))
-        .map(MaskedFlag::name)
-        .collect(Collectors.joining(", "));
-    return "FlagSet{" +
-        "flags=[" + flagsStr +
-        "], mask=" + mask +
-        '}';
+    return FlagSet.asString(this);
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  static abstract class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
+
+    private final T flag;
+    // Only holding this for iterator() and getFlags() so make it lazy.
+    private EnumSet<T> enumSet;
+
+    public AbstractSingleFlagSet(final T flag) {
+      this.flag = Objects.requireNonNull(flag);
+    }
+
+    @Override
+    public int getMask() {
+      return flag.getMask();
+    }
+
+    @Override
+    public Set<T> getFlags() {
+      if (enumSet == null) {
+        return initSet();
+      } else {
+        return this.enumSet;
+      }
+    }
+
+    @Override
+    public boolean isSet(final T flag) {
+      return this.flag == flag;
+    }
+
+    @Override
+    public int size() {
+      return 1;
+    }
+
+    @Override
+    public boolean isEmpty() {
+      return false;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+      if (enumSet == null) {
+        return initSet().iterator();
+      } else {
+        return this.enumSet.iterator();
+      }
+    }
+
+    @Override
+    public String toString() {
+      return FlagSet.asString(this);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+      if (this == object) return true;
+//      if (object == null || getClass() != object.getClass()) return false;
+      return FlagSet.equals(this, (FlagSet<?>) object);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(flag, getFlags());
+    }
+
+    private Set<T> initSet() {
+      final EnumSet<T> set = EnumSet.of(this.flag);
+      this.enumSet = set;
+      return set;
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  static class AbstractEmptyFlagSet<T extends MaskedFlag> implements FlagSet<T> {
+
+    @Override
+    public int getMask() {
+      return MaskedFlag.EMPTY_MASK;
+    }
+
+    @Override
+    public Set<T> getFlags() {
+      return Collections.emptySet();
+    }
+
+    @Override
+    public boolean isSet(final T flag) {
+      return false;
+    }
+
+    @Override
+    public int size() {
+      return 0;
+    }
+
+    @Override
+    public boolean isEmpty() {
+      return true;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+      return Collections.emptyIterator();
+    }
+
+    @Override
+    public String toString() {
+      return FlagSet.asString(this);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+      if (this == object) return true;
+//      if (object == null || getClass() != object.getClass()) return false;
+      return FlagSet.equals(this, (FlagSet<?>) object);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(getMask(), getFlags());
+    }
   }
 
 
@@ -105,17 +233,23 @@ public String toString() {
    * @param <E> The type of flag to be held in the {@link AbstractFlagSet}
    * @param <S> The type of the {@link AbstractFlagSet} implementation.
    */
-  public static class Builder<E extends Enum<E> & MaskedFlag, S extends AbstractFlagSet<E>> {
+  public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>> {
 
     final Class<E> type;
     final EnumSet<E> enumSet;
     final Function<EnumSet<E>, S> constructor;
+    final Function<E, S> singletonSetConstructor;
+    final Supplier<S> emptySetSupplier;
 
     protected Builder(final Class<E> type,
-                      final Function<EnumSet<E>, S> constructor) {
+                      final Function<EnumSet<E>, S> constructor,
+                      final Function<E, S> singletonSetConstructor,
+                      final Supplier<S> emptySetSupplier) {
       this.type = type;
       this.enumSet = EnumSet.noneOf(type);
-      this.constructor = constructor;
+      this.constructor = Objects.requireNonNull(constructor);
+      this.singletonSetConstructor = Objects.requireNonNull(singletonSetConstructor);
+      this.emptySetSupplier = Objects.requireNonNull(emptySetSupplier);
     }
 
     /**
@@ -125,7 +259,7 @@ protected Builder(final Class<E> type,
      * @return this builder instance.
      */
     public Builder<E, S> withFlags(final Collection<E> flags) {
-      enumSet.clear();
+      clear();
       if (flags != null) {
         for (E flag : flags) {
           if (flag != null) {
@@ -142,7 +276,7 @@ public Builder<E, S> withFlags(final Collection<E> flags) {
      */
     @SafeVarargs
     public final Builder<E, S> withFlags(final E... flags) {
-      enumSet.clear();
+      clear();
       if (flags != null) {
         for (E flag : flags) {
           if (flag != null) {
@@ -185,8 +319,14 @@ public Builder<E, S> clear() {
      * @return A
      */
     public S build() {
-      return constructor.apply(enumSet);
+      final int size = enumSet.size();
+      if (size == 0) {
+        return emptySetSupplier.get();
+      } else if (size == 1) {
+        return singletonSetConstructor.apply(enumSet.stream().findFirst().get());
+      } else {
+        return constructor.apply(enumSet);
+      }
     }
   }
 }
-
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
new file mode 100644
index 00000000..62c73c8d
--- /dev/null
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -0,0 +1,59 @@
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface CopyFlagSet extends FlagSet<CopyFlags> {
+
+  static CopyFlagSet EMPTY = CopyFlagSetImpl.EMPTY;
+
+  static CopyFlagSet empty() {
+    return CopyFlagSetImpl.EMPTY;
+  }
+
+  static CopyFlagSet of(final CopyFlags dbiFlag) {
+    Objects.requireNonNull(dbiFlag);
+    return dbiFlag;
+  }
+
+  static CopyFlagSet of(final CopyFlags... CopyFlags) {
+    return builder()
+        .withFlags(CopyFlags)
+        .build();
+  }
+
+  static CopyFlagSet of(final Collection<CopyFlags> CopyFlags) {
+    return builder()
+        .withFlags(CopyFlags)
+        .build();
+  }
+
+  static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        CopyFlags.class,
+        CopyFlagSetImpl::new,
+        copyFlag -> copyFlag,
+        () -> CopyFlagSetImpl.EMPTY);
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
+
+    static final CopyFlagSet EMPTY = new EmptyCopyFlagSet();
+
+    private CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
+      super(flags);
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags> implements CopyFlagSet {
+  }
+}
diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index 4365563c..fbd4d171 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when performing a {@link Env#copy(java.io.File, org.lmdbjava.CopyFlags...)}. */
-public enum CopyFlags implements MaskedFlag {
+public enum CopyFlags implements MaskedFlag, CopyFlagSet {
 
   /** Compacting copy: Omit free space from copy, and renumber all pages sequentially. */
   MDB_CP_COMPACT(0x01);
@@ -31,4 +34,29 @@ public enum CopyFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<CopyFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final CopyFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index cd1db934..e5c97544 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -1,32 +1,57 @@
 package org.lmdbjava;
 
+import java.util.Collection;
 import java.util.EnumSet;
 import java.util.Objects;
 
-public class DbiFlagSet extends AbstractFlagSet<DbiFlags> {
+public interface DbiFlagSet extends FlagSet<DbiFlags> {
 
-    public static final DbiFlagSet EMPTY = new DbiFlagSet(EnumSet.noneOf(DbiFlags.class));
+  static DbiFlagSet empty() {
+    return DbiFlagSetImpl.EMPTY;
+  }
 
-    private DbiFlagSet(final EnumSet<DbiFlags> flags) {
-        super(flags);
-    }
+  static DbiFlagSet of(final DbiFlags dbiFlag) {
+    Objects.requireNonNull(dbiFlag);
+    return dbiFlag;
+  }
 
-    public static DbiFlagSet empty() {
-        return EMPTY;
-    }
+  static DbiFlagSet of(final DbiFlags... DbiFlags) {
+    return builder()
+        .withFlags(DbiFlags)
+        .build();
+  }
 
-    public static DbiFlagSet of(final DbiFlags putFlag) {
-        Objects.requireNonNull(putFlag);
-        return new DbiFlagSet(EnumSet.of(putFlag));
-    }
+  static DbiFlagSet of(final Collection<DbiFlags> DbiFlags) {
+    return builder()
+        .withFlags(DbiFlags)
+        .build();
+  }
+
+  static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        DbiFlags.class,
+        DbiFlagSetImpl::new,
+        dbiFlag -> dbiFlag,
+        () -> DbiFlagSetImpl.EMPTY);
+  }
+
+
+  // --------------------------------------------------------------------------------
 
-    public static DbiFlagSet of(final DbiFlags... DbiFlags) {
-        return builder()
-                .withFlags(DbiFlags)
-                .build();
-    }
 
-    public static Builder<DbiFlags, DbiFlagSet> builder() {
-        return new Builder<>(DbiFlags.class, DbiFlagSet::new);
+  class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
+
+    static final DbiFlagSet EMPTY = new EmptyDbiFlagSet();
+
+    private DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
+      super(flags);
     }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags> implements DbiFlagSet {
+  }
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index af6eaeaa..6e4b723d 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when opening a {@link Dbi}. */
-public enum DbiFlags implements MaskedFlag {
+public enum DbiFlags implements MaskedFlag, DbiFlagSet {
 
   /**
    * Use reverse string keys.
@@ -82,4 +85,29 @@ public enum DbiFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<DbiFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final DbiFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 5de0a7fd..2ad929ad 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -26,7 +26,6 @@
 import static org.lmdbjava.MaskedFlag.isSet;
 import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
-import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
 import java.io.File;
 import java.nio.ByteBuffer;
@@ -124,6 +123,27 @@ public void close() {
     LIB.mdb_env_close(ptr);
   }
 
+  /**
+   * Copies an LMDB environment to the specified destination path.
+   *
+   * <p>This function may be used to make a backup of an existing environment. No lockfile is
+   * created, since it gets recreated at need.
+   *
+   * <p>If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the destination path
+   * must be a directory that exists but contains no files. If {@link EnvFlags#MDB_NOSUBDIR} was
+   * used, the destination path must not exist, but it must be possible to create a file at the
+   * provided path.
+   *
+   * <p>Note: This call can trigger significant file size growth if run in parallel with write
+   * transactions, because it employs a read-only transaction. See long-lived transactions under
+   * "Caveats" in the LMDB native documentation.
+   *
+   * @param path writable destination path as described above
+   */
+  public void copy(final File path) {
+    copy(path, CopyFlagSet.EMPTY);
+  }
+
   /**
    * Copies an LMDB environment to the specified destination path.
    *
@@ -142,11 +162,10 @@ public void close() {
    * @param path writable destination path as described above
    * @param flags special options for this copy
    */
-  public void copy(final File path, final CopyFlags... flags) {
+  public void copy(final File path, final CopyFlagSet flags) {
     requireNonNull(path);
     validatePath(path);
-    final int flagsMask = mask(flags);
-    checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flagsMask));
+    checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flags.getMask()));
   }
 
   /**
@@ -443,16 +462,54 @@ public void sync(final boolean force) {
   }
 
   /**
+   * @deprecated Instead use {@link Env#txn(Txn, TxnFlagSet)}
+   *
    * Obtain a transaction with the requested parent and flags.
    *
    * @param parent parent transaction (may be null if no parent)
    * @param flags applicable flags (eg for a reusable, read-only transaction)
    * @return a transaction (never null)
    */
+  @Deprecated
   public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
-    if (closed) {
-      throw new AlreadyClosedException();
-    }
+    checkNotClosed();
+    return new Txn<>(this, parent, proxy, TxnFlagSet.of(flags));
+  }
+
+  /**
+   * Obtain a transaction with the requested parent and flags.
+   *
+   * @param parent parent transaction (may be null if no parent)
+   * @return a transaction (never null)
+   */
+  public Txn<T> txn(final Txn<T> parent) {
+    checkNotClosed();
+    return new Txn<>(this, parent, proxy, TxnFlagSet.EMPTY);
+  }
+
+  /**
+   * Obtain a transaction with the requested parent and flags.
+   *
+   * @param parent parent transaction (may be null if no parent)
+   * @param flag applicable flag (eg for a reusable, read-only transaction)
+   * @return a transaction (never null)
+   */
+  public Txn<T> txn(final Txn<T> parent, final TxnFlags flag) {
+    checkNotClosed();
+    return new Txn<>(this, parent, proxy, flag);
+  }
+
+  /**
+   * Obtain a transaction with the requested parent and flags.
+   *
+   * @param parent parent transaction (may be null if no parent)
+   * @param flags applicable flags (e.g. for a reusable, read-only transaction).
+   *              If the set of flags is used frequently it is recommended to hold
+   *              a static instance of the {@link TxnFlagSet} for re-use.
+   * @return a transaction (never null)
+   */
+  public Txn<T> txn(final Txn<T> parent, final TxnFlagSet flags) {
+    checkNotClosed();
     return new Txn<>(this, parent, proxy, flags);
   }
 
@@ -462,7 +519,8 @@ public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
    * @return a read-only transaction
    */
   public Txn<T> txnRead() {
-    return txn(null, MDB_RDONLY_TXN);
+    checkNotClosed();
+    return new Txn<>(this, null, proxy, TxnFlags.MDB_RDONLY_TXN);
   }
 
   /**
@@ -471,7 +529,8 @@ public Txn<T> txnRead() {
    * @return a read-write transaction
    */
   public Txn<T> txnWrite() {
-    return txn(null);
+    checkNotClosed();
+    return new Txn<>(this, null, proxy, TxnFlagSet.EMPTY);
   }
 
   Pointer pointer() {
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
new file mode 100644
index 00000000..944496e6
--- /dev/null
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -0,0 +1,57 @@
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface EnvFlagSet extends FlagSet<EnvFlags> {
+
+  static EnvFlagSet empty() {
+    return EnvFlagSetImpl.EMPTY;
+  }
+
+  static EnvFlagSet of(final EnvFlags envFlag) {
+    Objects.requireNonNull(envFlag);
+    return envFlag;
+  }
+
+  static EnvFlagSet of(final EnvFlags... EnvFlags) {
+    return builder()
+        .withFlags(EnvFlags)
+        .build();
+  }
+
+  static EnvFlagSet of(final Collection<EnvFlags> EnvFlags) {
+    return builder()
+        .withFlags(EnvFlags)
+        .build();
+  }
+
+  static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        EnvFlags.class,
+        EnvFlagSetImpl::new,
+        envFlag -> envFlag,
+        () -> EnvFlagSetImpl.EMPTY);
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
+
+    static final EnvFlagSet EMPTY = new EmptyEnvFlagSet();
+
+    private EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
+      super(flags);
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags> implements EnvFlagSet {
+  }
+}
diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index 4ce555a8..7fb4a29b 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when opening the {@link Env}. */
-public enum EnvFlags implements MaskedFlag {
+public enum EnvFlags implements MaskedFlag, EnvFlagSet {
 
   /**
    * Mmap at a fixed address (experimental).
@@ -144,4 +147,29 @@ public enum EnvFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<EnvFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final EnvFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
new file mode 100644
index 00000000..80a4c19e
--- /dev/null
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -0,0 +1,61 @@
+package org.lmdbjava;
+
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * A set of flags, each with a bit mask value.
+ * Flags can be combined in a set such that the set has a combined bit mask value.
+ * @param <T>
+ */
+public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
+
+  int getMask();
+
+  Set<T> getFlags();
+
+  boolean isSet(T flag);
+
+  default int size() {
+    return getFlags().size();
+  }
+
+  default boolean isEmpty() {
+    return getFlags().isEmpty();
+  }
+
+  default Iterator<T> iterator() {
+    return getFlags().iterator();
+  }
+
+  static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
+    Objects.requireNonNull(flagSet);
+    final String flagsStr = flagSet.getFlags()
+        .stream()
+        .sorted(Comparator.comparing(MaskedFlag::getMask))
+        .map(MaskedFlag::name)
+        .collect(Collectors.joining(", "));
+    return "FlagSet{" +
+        "flags=[" + flagsStr +
+        "], mask=" + flagSet.getMask() +
+        '}';
+  }
+
+  static boolean equals(final FlagSet<?> flagSet1,
+                        final FlagSet<?> flagSet2) {
+    if (flagSet1 == flagSet2) {
+      return true;
+    } else if (flagSet1 != null && flagSet2 == null) {
+      return false;
+    } else if (flagSet1 == null) {
+      return false;
+    } else {
+      return flagSet1.getMask() == flagSet2.getMask()
+          && Objects.equals(flagSet1.getFlags(), flagSet2.getFlags());
+    }
+  }
+
+}
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 8820fe92..1eedaf10 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -1,32 +1,57 @@
 package org.lmdbjava;
 
+import java.util.Collection;
 import java.util.EnumSet;
 import java.util.Objects;
 
-public class PutFlagSet extends AbstractFlagSet<PutFlags> {
+public interface PutFlagSet extends FlagSet<PutFlags> {
 
-    public static final PutFlagSet EMPTY = new PutFlagSet(EnumSet.noneOf(PutFlags.class));
-
-    private PutFlagSet(final EnumSet<PutFlags> flags) {
-        super(flags);
-    }
-
-    public static PutFlagSet empty() {
-        return EMPTY;
+    static PutFlagSet empty() {
+        return PutFlagSetImpl.EMPTY;
     }
 
-    public static PutFlagSet of(final PutFlags putFlag) {
+    static PutFlagSet of(final PutFlags putFlag) {
         Objects.requireNonNull(putFlag);
-        return new org.lmdbjava.PutFlagSet(EnumSet.of(putFlag));
+        return putFlag;
     }
 
-    public static PutFlagSet of(final PutFlags... putFlags) {
+    static PutFlagSet of(final PutFlags... putFlags) {
         return builder()
                 .withFlags(putFlags)
                 .build();
     }
 
-    public static Builder<PutFlags, PutFlagSet> builder() {
-        return new Builder<>(PutFlags.class, PutFlagSet::new);
+    static PutFlagSet of(final Collection<PutFlags> putFlags) {
+        return builder()
+            .withFlags(putFlags)
+            .build();
+    }
+
+    static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
+        return new AbstractFlagSet.Builder<>(
+            PutFlags.class,
+            PutFlagSetImpl::new,
+            putFlag -> putFlag,
+            EmptyPutFlagSet::new);
+    }
+
+
+    // --------------------------------------------------------------------------------
+
+
+    class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
+
+        public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
+
+        private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
+            super(flags);
+        }
+    }
+
+
+    // --------------------------------------------------------------------------------
+
+
+    class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags> implements PutFlagSet {
     }
 }
diff --git a/src/main/java/org/lmdbjava/PutFlags.java b/src/main/java/org/lmdbjava/PutFlags.java
index 809103de..03fa916a 100644
--- a/src/main/java/org/lmdbjava/PutFlags.java
+++ b/src/main/java/org/lmdbjava/PutFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when performing a "put". */
-public enum PutFlags implements MaskedFlag {
+public enum PutFlags implements MaskedFlag, PutFlagSet {
 
   /** For put: Don't write if the key already exists. */
   MDB_NOOVERWRITE(0x10),
@@ -49,4 +52,29 @@ public enum PutFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<PutFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(PutFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 1d5d4860..5c8440fd 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -20,8 +20,6 @@
 import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.Library.LIB;
 import static org.lmdbjava.Library.RUNTIME;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 import static org.lmdbjava.Txn.State.DONE;
 import static org.lmdbjava.Txn.State.READY;
@@ -46,11 +44,13 @@ public final class Txn<T> implements AutoCloseable {
   private final Env<T> env;
   private State state;
 
-  Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlags... flags) {
+  Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlagSet flags) {
+    final TxnFlagSet flagSet = flags != null
+        ? flags
+        : TxnFlagSet.EMPTY;
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
-    final int flagsMask = mask(flags);
-    this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
+    this.readOnly = flagSet.isSet(MDB_RDONLY_TXN);
     if (env.isReadOnly() && !this.readOnly) {
       throw new EnvIsReadOnly();
     }
@@ -61,7 +61,7 @@ public final class Txn<T> implements AutoCloseable {
     }
     final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
     final Pointer txnParentPtr = parent == null ? null : parent.ptr;
-    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, flagsMask, txnPtr));
+    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, flagSet.getMask(), txnPtr));
     ptr = txnPtr.getPointer(0);
 
     state = READY;
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
new file mode 100644
index 00000000..6320eece
--- /dev/null
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -0,0 +1,63 @@
+package org.lmdbjava;
+
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface TxnFlagSet extends FlagSet<TxnFlags> {
+
+  TxnFlagSet EMPTY = TxnFlagSetImpl.EMPTY;
+
+  static TxnFlagSet empty() {
+    return TxnFlagSetImpl.EMPTY;
+  }
+
+  static TxnFlagSet of(final TxnFlags putFlag) {
+    Objects.requireNonNull(putFlag);
+    return new SingleTxnFlagSet(putFlag);
+  }
+
+  static TxnFlagSet of(final TxnFlags... TxnFlags) {
+    return builder()
+        .withFlags(TxnFlags)
+        .build();
+  }
+
+  static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        TxnFlags.class,
+        TxnFlagSetImpl::new,
+        SingleTxnFlagSet::new,
+        () -> TxnFlagSetImpl.EMPTY);
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
+
+    static final TxnFlagSet EMPTY = new EmptyTxnFlagSet();
+
+    private TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
+      super(flags);
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags> implements TxnFlagSet {
+
+    SingleTxnFlagSet(final TxnFlags flag) {
+      super(flag);
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags> implements TxnFlagSet {
+  }
+}
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index 26caf6f1..8e4ea757 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when creating a {@link Txn}. */
-public enum TxnFlags implements MaskedFlag {
+public enum TxnFlags implements MaskedFlag, TxnFlagSet {
   /** Read only. */
   MDB_RDONLY_TXN(0x2_0000);
 
@@ -30,4 +33,29 @@ public enum TxnFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<TxnFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final TxnFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
new file mode 100644
index 00000000..1ea44b7e
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -0,0 +1,88 @@
+package org.lmdbjava;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Collections;
+import java.util.HashSet;
+import org.junit.Test;
+
+public class CopyFlagSetTest {
+
+    @Test
+    public void testEmpty() {
+        final CopyFlagSet copyFlagSet = CopyFlagSet.empty();
+        assertThat(
+                copyFlagSet.getMask(),
+                is(0));
+        assertThat(
+                copyFlagSet.size(),
+                is(0));
+        assertThat(
+                copyFlagSet.isEmpty(),
+                is(true));
+        assertThat(
+                copyFlagSet.isSet(CopyFlags.MDB_CP_COMPACT),
+                is(false));
+        final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
+            .build();
+        assertThat(copyFlagSet, is(copyFlagSet2));
+        assertThat(copyFlagSet, not(CopyFlagSet.of(CopyFlags.MDB_CP_COMPACT)));
+        assertThat(copyFlagSet, not(CopyFlagSet.builder()
+            .setFlag(CopyFlags.MDB_CP_COMPACT)
+            .build()));
+    }
+
+    @Test
+    public void testOf() {
+        final CopyFlags copyFlag = CopyFlags.MDB_CP_COMPACT;
+        final CopyFlagSet copyFlagSet = CopyFlagSet.of(copyFlag);
+        assertThat(
+                copyFlagSet.getMask(),
+                is(MaskedFlag.mask(copyFlag)));
+        assertThat(
+                copyFlagSet.size(),
+                is(1));
+        for (CopyFlags flag : copyFlagSet) {
+            assertThat(
+                    copyFlagSet.isSet(flag),
+                    is(true));
+        }
+
+        final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
+            .setFlag(copyFlag)
+            .build();
+        assertThat(copyFlagSet, is(copyFlagSet2));
+    }
+
+    @Test
+    public void testBuilder() {
+        final CopyFlags copyFlag1 = CopyFlags.MDB_CP_COMPACT;
+        final CopyFlagSet copyFlagSet = CopyFlagSet.builder()
+                .setFlag(copyFlag1)
+                .build();
+        assertThat(
+                copyFlagSet.getMask(),
+                is(MaskedFlag.mask(copyFlag1)));
+        assertThat(
+                copyFlagSet.size(),
+                is(1));
+        assertThat(
+                copyFlagSet.isSet(CopyFlags.MDB_CP_COMPACT),
+                is(true));
+        for (CopyFlags flag : copyFlagSet) {
+            assertThat(
+                    copyFlagSet.isSet(flag),
+                    is(true));
+        }
+        final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
+                .withFlags(copyFlag1)
+                .build();
+        final CopyFlagSet copyFlagSet3 = CopyFlagSet.builder()
+                .withFlags(new HashSet<>(Collections.singletonList(copyFlag1)))
+                .build();
+        assertThat(copyFlagSet, is(copyFlagSet2));
+        assertThat(copyFlagSet, is(copyFlagSet3));
+    }
+}
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index cfbda600..323a2ed4 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -1,6 +1,7 @@
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import java.util.Arrays;
@@ -11,91 +12,105 @@ public class DbiFlagSetTest {
 
     @Test
     public void testEmpty() {
-        final DbiFlagSet putFlagSet = DbiFlagSet.empty();
+        final DbiFlagSet dbiFlagSet = DbiFlagSet.empty();
         assertThat(
-                putFlagSet.getMask(),
+                dbiFlagSet.getMask(),
                 is(0));
         assertThat(
-                putFlagSet.size(),
+                dbiFlagSet.size(),
                 is(0));
         assertThat(
-                putFlagSet.isEmpty(),
+                dbiFlagSet.isEmpty(),
                 is(true));
         assertThat(
-                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
                 is(false));
+        final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder()
+            .build();
+        assertThat(dbiFlagSet, is(dbiFlagSet2));
+        assertThat(dbiFlagSet, not(DbiFlagSet.of(DbiFlags.MDB_CREATE)));
+        assertThat(dbiFlagSet, not(DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_DUPSORT)));
+        assertThat(dbiFlagSet, not(DbiFlagSet.builder()
+            .setFlag(DbiFlags.MDB_CREATE)
+            .setFlag(DbiFlags.MDB_DUPFIXED)
+            .build()));
     }
 
     @Test
     public void testOf() {
-        final DbiFlags putFlag = DbiFlags.MDB_CREATE;
-        final DbiFlagSet putFlagSet = DbiFlagSet.of(putFlag);
+        final DbiFlags dbiFlag = DbiFlags.MDB_CREATE;
+        final DbiFlagSet dbiFlagSet = DbiFlagSet.of(dbiFlag);
         assertThat(
-                putFlagSet.getMask(),
-                is(MaskedFlag.mask(putFlag)));
+                dbiFlagSet.getMask(),
+                is(MaskedFlag.mask(dbiFlag)));
         assertThat(
-                putFlagSet.size(),
+                dbiFlagSet.size(),
                 is(1));
         assertThat(
-                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
                 is(false));
-        for (DbiFlags flag : putFlagSet) {
+        for (DbiFlags flag : dbiFlagSet) {
             assertThat(
-                    putFlagSet.isSet(flag),
+                    dbiFlagSet.isSet(flag),
                     is(true));
         }
+
+        final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder()
+            .setFlag(dbiFlag)
+            .build();
+        assertThat(dbiFlagSet, is(dbiFlagSet2));
     }
 
     @Test
     public void testOf2() {
-        final DbiFlags putFlag1 = DbiFlags.MDB_CREATE;
-        final DbiFlags putFlag2 = DbiFlags.MDB_INTEGERKEY;
-        final DbiFlagSet putFlagSet = DbiFlagSet.of(putFlag1, putFlag2);
+        final DbiFlags dbiFlag1 = DbiFlags.MDB_CREATE;
+        final DbiFlags dbiFlag2 = DbiFlags.MDB_INTEGERKEY;
+        final DbiFlagSet dbiFlagSet = DbiFlagSet.of(dbiFlag1, dbiFlag2);
         assertThat(
-                putFlagSet.getMask(),
-                is(MaskedFlag.mask(putFlag1, putFlag2)));
+                dbiFlagSet.getMask(),
+                is(MaskedFlag.mask(dbiFlag1, dbiFlag2)));
         assertThat(
-                putFlagSet.size(),
+                dbiFlagSet.size(),
                 is(2));
         assertThat(
-                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
                 is(false));
-        for (DbiFlags flag : putFlagSet) {
+        for (DbiFlags flag : dbiFlagSet) {
             assertThat(
-                    putFlagSet.isSet(flag),
+                    dbiFlagSet.isSet(flag),
                     is(true));
         }
     }
 
     @Test
     public void testBuilder() {
-        final DbiFlags putFlag1 = DbiFlags.MDB_CREATE;
-        final DbiFlags putFlag2 = DbiFlags.MDB_INTEGERKEY;
-        final DbiFlagSet putFlagSet = DbiFlagSet.builder()
-                .setFlag(putFlag1)
-                .setFlag(putFlag2)
+        final DbiFlags dbiFlag1 = DbiFlags.MDB_CREATE;
+        final DbiFlags dbiFlag2 = DbiFlags.MDB_INTEGERKEY;
+        final DbiFlagSet dbiFlagSet = DbiFlagSet.builder()
+                .setFlag(dbiFlag1)
+                .setFlag(dbiFlag2)
                 .build();
         assertThat(
-                putFlagSet.getMask(),
-                is(MaskedFlag.mask(putFlag1, putFlag2)));
+                dbiFlagSet.getMask(),
+                is(MaskedFlag.mask(dbiFlag1, dbiFlag2)));
         assertThat(
-                putFlagSet.size(),
+                dbiFlagSet.size(),
                 is(2));
         assertThat(
-                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
                 is(false));
-        for (DbiFlags flag : putFlagSet) {
+        for (DbiFlags flag : dbiFlagSet) {
             assertThat(
-                    putFlagSet.isSet(flag),
+                    dbiFlagSet.isSet(flag),
                     is(true));
         }
-        final DbiFlagSet putFlagSet2 = DbiFlagSet.builder()
-                .withFlags(putFlag1, putFlag2)
+        final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder()
+                .withFlags(dbiFlag1, dbiFlag2)
                 .build();
-        final DbiFlagSet putFlagSet3 = DbiFlagSet.builder()
-                .withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2)))
+        final DbiFlagSet dbiFlagSet3 = DbiFlagSet.builder()
+                .withFlags(new HashSet<>(Arrays.asList(dbiFlag1, dbiFlag2)))
                 .build();
-        assertThat(putFlagSet, is(putFlagSet2));
-        assertThat(putFlagSet, is(putFlagSet3));
+        assertThat(dbiFlagSet, is(dbiFlagSet2));
+        assertThat(dbiFlagSet, is(dbiFlagSet3));
     }
 }
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
new file mode 100644
index 00000000..ed6a0fea
--- /dev/null
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -0,0 +1,116 @@
+package org.lmdbjava;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import org.junit.Test;
+
+public class EnvFlagSetTest {
+
+    @Test
+    public void testEmpty() {
+        final EnvFlagSet envFlagSet = EnvFlagSet.empty();
+        assertThat(
+                envFlagSet.getMask(),
+                is(0));
+        assertThat(
+                envFlagSet.size(),
+                is(0));
+        assertThat(
+                envFlagSet.isEmpty(),
+                is(true));
+        assertThat(
+                envFlagSet.isSet(EnvFlags.MDB_NOSUBDIR),
+                is(false));
+        final EnvFlagSet envFlagSet2 = EnvFlagSet.builder()
+            .build();
+        assertThat(envFlagSet, is(envFlagSet2));
+        assertThat(envFlagSet, not(EnvFlagSet.of(EnvFlags.MDB_FIXEDMAP)));
+        assertThat(envFlagSet, not(EnvFlagSet.of(EnvFlags.MDB_FIXEDMAP, EnvFlags.MDB_NORDAHEAD)));
+        assertThat(envFlagSet, not(EnvFlagSet.builder()
+            .setFlag(EnvFlags.MDB_FIXEDMAP)
+            .setFlag(EnvFlags.MDB_NORDAHEAD)
+            .build()));
+    }
+
+    @Test
+    public void testOf() {
+        final EnvFlags envFlag = EnvFlags.MDB_FIXEDMAP;
+        final EnvFlagSet envFlagSet = EnvFlagSet.of(envFlag);
+        assertThat(
+                envFlagSet.getMask(),
+                is(MaskedFlag.mask(envFlag)));
+        assertThat(
+                envFlagSet.size(),
+                is(1));
+        assertThat(
+                envFlagSet.isSet(EnvFlags.MDB_NOSUBDIR),
+                is(false));
+        for (EnvFlags flag : envFlagSet) {
+            assertThat(
+                    envFlagSet.isSet(flag),
+                    is(true));
+        }
+
+        final EnvFlagSet envFlagSet2 = EnvFlagSet.builder()
+            .setFlag(envFlag)
+            .build();
+        assertThat(envFlagSet, is(envFlagSet2));
+    }
+
+    @Test
+    public void testOf2() {
+        final EnvFlags envFlag1 = EnvFlags.MDB_FIXEDMAP;
+        final EnvFlags envFlag2 = EnvFlags.MDB_NORDAHEAD;
+        final EnvFlagSet envFlagSet = EnvFlagSet.of(envFlag1, envFlag2);
+        assertThat(
+                envFlagSet.getMask(),
+                is(MaskedFlag.mask(envFlag1, envFlag2)));
+        assertThat(
+                envFlagSet.size(),
+                is(2));
+        assertThat(
+                envFlagSet.isSet(EnvFlags.MDB_WRITEMAP),
+                is(false));
+        for (EnvFlags flag : envFlagSet) {
+            assertThat(
+                    envFlagSet.isSet(flag),
+                    is(true));
+        }
+    }
+
+    @Test
+    public void testBuilder() {
+        final EnvFlags envFlag1 = EnvFlags.MDB_FIXEDMAP;
+        final EnvFlags envFlag2 = EnvFlags.MDB_NORDAHEAD;
+        final EnvFlagSet envFlagSet = EnvFlagSet.builder()
+                .setFlag(envFlag1)
+                .setFlag(envFlag2)
+                .build();
+        assertThat(
+                envFlagSet.getMask(),
+                is(MaskedFlag.mask(envFlag1, envFlag2)));
+        assertThat(
+                envFlagSet.size(),
+                is(2));
+        assertThat(
+                envFlagSet.isSet(EnvFlags.MDB_NOTLS),
+                is(false));
+        for (EnvFlags flag : envFlagSet) {
+            assertThat(
+                    envFlagSet.isSet(flag),
+                    is(true));
+        }
+        final EnvFlagSet envFlagSet2 = EnvFlagSet.builder()
+                .withFlags(envFlag1, envFlag2)
+                .build();
+        final EnvFlagSet envFlagSet3 = EnvFlagSet.builder()
+                .withFlags(new HashSet<>(Arrays.asList(envFlag1, envFlag2)))
+                .build();
+        assertThat(envFlagSet, is(envFlagSet2));
+        assertThat(envFlagSet, is(envFlagSet3));
+    }
+}
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 4826f436..8cf1efe0 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -1,6 +1,7 @@
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import java.util.Arrays;
@@ -24,6 +25,15 @@ public void testEmpty() {
         assertThat(
                 putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
                 is(false));
+        final PutFlagSet putFlagSet2 = PutFlagSet.builder()
+            .build();
+        assertThat(putFlagSet, is(putFlagSet2));
+        assertThat(putFlagSet, not(PutFlagSet.of(PutFlags.MDB_APPEND)));
+        assertThat(putFlagSet, not(PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_RESERVE)));
+        assertThat(putFlagSet, not(PutFlagSet.builder()
+            .setFlag(PutFlags.MDB_CURRENT)
+            .setFlag(PutFlags.MDB_MULTIPLE)
+            .build()));
     }
 
     @Test
@@ -44,6 +54,11 @@ public void testOf() {
                     putFlagSet.isSet(flag),
                     is(true));
         }
+
+        final PutFlagSet putFlagSet2 = PutFlagSet.builder()
+            .setFlag(putFlag)
+            .build();
+        assertThat(putFlagSet, is(putFlagSet2));
     }
 
     @Test
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
new file mode 100644
index 00000000..b526ceeb
--- /dev/null
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -0,0 +1,88 @@
+package org.lmdbjava;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Collections;
+import java.util.HashSet;
+import org.junit.Test;
+
+public class TxnFlagSetTest {
+
+    @Test
+    public void testEmpty() {
+        final TxnFlagSet txnFlagSet = TxnFlagSet.empty();
+        assertThat(
+                txnFlagSet.getMask(),
+                is(0));
+        assertThat(
+                txnFlagSet.size(),
+                is(0));
+        assertThat(
+                txnFlagSet.isEmpty(),
+                is(true));
+        assertThat(
+                txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN),
+                is(false));
+        final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+            .build();
+        assertThat(txnFlagSet, is(txnFlagSet2));
+        assertThat(txnFlagSet, not(TxnFlagSet.of(TxnFlags.MDB_RDONLY_TXN)));
+        assertThat(txnFlagSet, not(TxnFlagSet.builder()
+            .setFlag(TxnFlags.MDB_RDONLY_TXN)
+            .build()));
+    }
+
+    @Test
+    public void testOf() {
+        final TxnFlags txnFlag = TxnFlags.MDB_RDONLY_TXN;
+        final TxnFlagSet txnFlagSet = TxnFlagSet.of(txnFlag);
+        assertThat(
+                txnFlagSet.getMask(),
+                is(MaskedFlag.mask(txnFlag)));
+        assertThat(
+                txnFlagSet.size(),
+                is(1));
+        for (TxnFlags flag : txnFlagSet) {
+            assertThat(
+                    txnFlagSet.isSet(flag),
+                    is(true));
+        }
+
+        final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+            .setFlag(txnFlag)
+            .build();
+        assertThat(txnFlagSet, is(txnFlagSet2));
+    }
+
+    @Test
+    public void testBuilder() {
+        final TxnFlags txnFlag1 = TxnFlags.MDB_RDONLY_TXN;
+        final TxnFlagSet txnFlagSet = TxnFlagSet.builder()
+                .setFlag(txnFlag1)
+                .build();
+        assertThat(
+                txnFlagSet.getMask(),
+                is(MaskedFlag.mask(txnFlag1)));
+        assertThat(
+                txnFlagSet.size(),
+                is(1));
+        assertThat(
+                txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN),
+                is(true));
+        for (TxnFlags flag : txnFlagSet) {
+            assertThat(
+                    txnFlagSet.isSet(flag),
+                    is(true));
+        }
+        final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+                .withFlags(txnFlag1)
+                .build();
+        final TxnFlagSet txnFlagSet3 = TxnFlagSet.builder()
+                .withFlags(new HashSet<>(Collections.singletonList(txnFlag1)))
+                .build();
+        assertThat(txnFlagSet, is(txnFlagSet2));
+        assertThat(txnFlagSet, is(txnFlagSet3));
+    }
+}

From 667dab37ccce1c8d79307c01ab1f1d130082cd84 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 27 Oct 2025 21:25:11 +0000
Subject: [PATCH 11/90] Fix Javadoc

---
 src/main/java/org/lmdbjava/CopyFlags.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index fbd4d171..b45dc87c 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -15,10 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.io.File;
 import java.util.EnumSet;
 import java.util.Set;
 
-/** Flags for use when performing a {@link Env#copy(java.io.File, org.lmdbjava.CopyFlags...)}. */
+/** Flags for use when performing a {@link Env#copy(File, CopyFlagSet)}. */
 public enum CopyFlags implements MaskedFlag, CopyFlagSet {
 
   /** Compacting copy: Omit free space from copy, and renumber all pages sequentially. */

From b46c9164c4154bcb0dc78b675556b25d85390b1d Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Tue, 28 Oct 2025 11:40:20 +0000
Subject: [PATCH 12/90] Add more cursor tests to protect against future
 regression

---
 .../org/lmdbjava/CursorIterableRangeTest.java | 188 ++++++++++++++++++
 .../java/org/lmdbjava/CursorIterableTest.java |  52 ++---
 .../testSignedComparator.actual               |  49 +++++
 .../testSignedComparator.expected             |  49 +++++
 .../testSignedComparatorDupsort.actual        |  49 +++++
 .../testSignedComparatorDupsort.expected      |  49 +++++
 .../testUnsignedComparator.actual             |  49 +++++
 .../testUnsignedComparator.expected           |  49 +++++
 .../testUnsignedComparatorDupsort.actual      |  49 +++++
 .../testUnsignedComparatorDupsort.expected    |  49 +++++
 .../CursorIterableRangeTest/tests.csv         |  49 +++++
 11 files changed, 655 insertions(+), 26 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/CursorIterableRangeTest.java
 create mode 100644 src/test/resources/CursorIterableRangeTest/testSignedComparator.actual
 create mode 100644 src/test/resources/CursorIterableRangeTest/testSignedComparator.expected
 create mode 100644 src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.actual
 create mode 100644 src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.expected
 create mode 100644 src/test/resources/CursorIterableRangeTest/testUnsignedComparator.actual
 create mode 100644 src/test/resources/CursorIterableRangeTest/testUnsignedComparator.expected
 create mode 100644 src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.actual
 create mode 100644 src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.expected
 create mode 100644 src/test/resources/CursorIterableRangeTest/tests.csv

diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
new file mode 100644
index 00000000..03f9a82d
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.lmdbjava;
+
+import org.junit.Test;
+import org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy;
+import org.lmdbjava.CursorIterable.KeyVal;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Comparator;
+import java.util.stream.Stream;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+
+/**
+ * Test {@link CursorIterable}.
+ */
+public final class CursorIterableRangeTest {
+
+    @Test
+    public void testSignedComparator() throws IOException {
+        test(ByteBuffer::compareTo, true, "testSignedComparator", 1, MDB_CREATE);
+    }
+
+    @Test
+    public void testUnsignedComparator() throws IOException {
+        test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparator", 1, MDB_CREATE);
+    }
+
+    @Test
+    public void testSignedComparatorDupsort() throws IOException {
+        test(ByteBuffer::compareTo, true, "testSignedComparatorDupsort", 2,MDB_CREATE, MDB_DUPSORT);
+    }
+
+    @Test
+    public void testUnsignedComparatorDupsort() throws IOException {
+        test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparatorDupsort",2, MDB_CREATE, MDB_DUPSORT);
+    }
+
+    private void test(final Comparator<ByteBuffer> comparator,
+                      final boolean nativeCb,
+                      final String testName,
+                      final int copies,
+                      final DbiFlags... flags) throws IOException {
+        final Path dbPath = Files.createTempFile("test", "db");
+        try (final Env<ByteBuffer> env =
+                create()
+                        .setMapSize(KIBIBYTES.toBytes(256))
+                        .setMaxReaders(1)
+                        .setMaxDbs(1)
+                        .open(dbPath.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
+            final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, comparator, nativeCb, flags);
+            populateDatabase(env, dbi, copies);
+
+            final File tests = new File("src/test/resources/CursorIterableRangeTest/tests.csv");
+            final File actual = tests.getParentFile().toPath().resolve(testName + ".actual").toFile();
+            final File expected = tests.getParentFile().toPath().resolve(testName + ".expected").toFile();
+            final String csv = readFile(tests);
+            final String[] parts = csv.split("\n");
+            try (final Writer writer = new FileWriter(actual)) {
+                for (final String part : parts) {
+                    writer.append(part);
+                    writer.append(" =>");
+
+                    final String[] params = part.split(",");
+                    final KeyRangeType keyRangeType = KeyRangeType.valueOf(params[0].trim());
+                    ByteBuffer start = null;
+                    ByteBuffer stop = null;
+                    if (params.length > 1 && params[1].trim().length() > 0) {
+                        start = bb(Integer.parseInt(params[1].trim()));
+                    }
+                    if (params.length > 2 && params[2].trim().length() > 0) {
+                        stop = bb(Integer.parseInt(params[2].trim()));
+                    }
+                    final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
+                    boolean first = true;
+                    try (Txn<ByteBuffer> txn = env.txnRead();
+                            CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
+                        for (final KeyVal<ByteBuffer> kv : c) {
+                            if (first) {
+                                first = false;
+                            } else {
+                                writer.append(",");
+                            }
+
+                            final int key = kv.key().getInt();
+                            final int val = kv.val().getInt();
+                            writer.append(" [");
+                            writer.append(String.valueOf(key));
+                            writer.append(",");
+                            writer.append(String.valueOf(val));
+                            writer.append("]");
+                        }
+                    }
+                    writer.append("\n");
+                }
+            }
+
+            // Compare files.
+            final String act = readFile(actual);
+            final String exp = readFile(expected);
+            assertThat("Files are not equal", act.equals(exp));
+        } finally {
+            deleteFile(dbPath);
+        }
+    }
+
+    private void populateDatabase(final Env<ByteBuffer> env,
+                                  final Dbi<ByteBuffer> dbi,
+                                  final int copies) {
+        try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+            for (int i = 0; i < copies; i++) {
+                c.put(bb(0), bb(1 + i));
+                c.put(bb(2), bb(3 + i));
+                c.put(bb(4), bb(5 + i));
+                c.put(bb(6), bb(7 + i));
+                c.put(bb(8), bb(9 + i));
+                c.put(bb(-2), bb(-1 + i));
+            }
+            txn.commit();
+        }
+    }
+
+    private String readFile(final File file) throws IOException {
+        final StringBuilder result = new StringBuilder();
+        try (final Reader reader = new FileReader(file)) {
+            final char[] cbuf = new char[4096];
+            int nread;
+            while ((nread = reader.read(cbuf, 0, cbuf.length)) != -1) {
+                result.append(cbuf, 0, nread);
+            }
+        }
+        return result.toString();
+    }
+
+    private boolean recursiveDeleteFiles(Path file) {
+        if (deleteFile(file)) {
+            return true;
+        } else {
+            try (final Stream<Path> stream = Files.list(file)) {
+                stream.forEach(this::recursiveDeleteFiles);
+            } catch (final IOException e) {
+                return false;
+            }
+            return deleteFile(file);
+        }
+    }
+
+    private boolean deleteFile(Path file) {
+        try {
+            Files.delete(file);
+        } catch (final IOException e) {
+            return false;
+        }
+        return true;
+    }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index bd23bc55..595898e2 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -73,6 +73,32 @@ public final class CursorIterableTest {
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
+    @Before
+    public void before() throws IOException {
+        final File path = tmp.newFile();
+        env =
+                create()
+                        .setMapSize(KIBIBYTES.toBytes(256))
+                        .setMaxReaders(1)
+                        .setMaxDbs(1)
+                        .open(path, POSIX_MODE, MDB_NOSUBDIR);
+        db = env.openDbi(DB_1, MDB_CREATE);
+        populateDatabase(db);
+    }
+
+    private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+        list = new LinkedList<>();
+        list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
+        try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+            c.put(bb(2), bb(3), MDB_NOOVERWRITE);
+            c.put(bb(4), bb(5));
+            c.put(bb(6), bb(7));
+            c.put(bb(8), bb(9));
+            txn.commit();
+        }
+    }
+
   @After
   public void after() {
     env.close();
@@ -113,32 +139,6 @@ public void atMostTest() {
     verify(atMost(bb(6)), 2, 4, 6);
   }
 
-  @Before
-  public void before() throws IOException {
-    final File path = tmp.newFile();
-    env =
-        create()
-            .setMapSize(KIBIBYTES.toBytes(256))
-            .setMaxReaders(1)
-            .setMaxDbs(1)
-            .open(path, POSIX_MODE, MDB_NOSUBDIR);
-    db = env.openDbi(DB_1, MDB_CREATE);
-    populateDatabase(db);
-  }
-
-  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
-    list = new LinkedList<>();
-    list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-      c.put(bb(2), bb(3), MDB_NOOVERWRITE);
-      c.put(bb(4), bb(5));
-      c.put(bb(6), bb(7));
-      c.put(bb(8), bb(9));
-      txn.commit();
-    }
-  }
-
   @Test
   public void closedBackwardTest() {
     verify(closedBackward(bb(7), bb(3)), 6, 4);
diff --git a/src/test/resources/CursorIterableRangeTest/testSignedComparator.actual b/src/test/resources/CursorIterableRangeTest/testSignedComparator.actual
new file mode 100644
index 00000000..5968c07f
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testSignedComparator.actual
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [-2,-1], [0,1], [2,3], [4,5], [6,7], [8,9]
+FORWARD_AT_LEAST, 5, => [6,7], [8,9]
+FORWARD_AT_LEAST, 6, => [6,7], [8,9]
+FORWARD_AT_MOST, , 5 => [-2,-1], [0,1], [2,3], [4,5]
+FORWARD_AT_MOST, , 6 => [-2,-1], [0,1], [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 3, 7 => [4,5], [6,7]
+FORWARD_CLOSED, 2, 6 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 1, 7 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [4,5]
+FORWARD_GREATER_THAN, 4, => [6,7], [8,9]
+FORWARD_GREATER_THAN, 3, => [4,5], [6,7], [8,9]
+FORWARD_LESS_THAN, , 5 => [-2,-1], [0,1], [2,3], [4,5]
+FORWARD_LESS_THAN, , 8 => [-2,-1], [0,1], [2,3], [4,5], [6,7]
+FORWARD_OPEN, 3, 7 => [4,5], [6,7]
+FORWARD_OPEN, 2, 8 => [4,5], [6,7]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [6,7], [8,9]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [6,7]
+BACKWARD_ALL, , => [8,9], [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, 5, => [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, 9, => [8,9], [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, -1, => [-2,-1]
+BACKWARD_AT_MOST, , 5 => [8,9], [6,7]
+BACKWARD_AT_MOST, , 6 => [8,9], [6,7]
+BACKWARD_AT_MOST, , -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_CLOSED, 7, 3 => [6,7], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,5], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, 6, => [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_GREATER_THAN, 7, => [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_GREATER_THAN, 9, => [8,9], [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_GREATER_THAN, -1, => [-2,-1]
+BACKWARD_LESS_THAN, , 5 => [8,9], [6,7]
+BACKWARD_LESS_THAN, , 2 => [8,9], [6,7], [4,5]
+BACKWARD_LESS_THAN, , -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,9], [6,7]
+BACKWARD_OPEN, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,9], [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
diff --git a/src/test/resources/CursorIterableRangeTest/testSignedComparator.expected b/src/test/resources/CursorIterableRangeTest/testSignedComparator.expected
new file mode 100644
index 00000000..5968c07f
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testSignedComparator.expected
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [-2,-1], [0,1], [2,3], [4,5], [6,7], [8,9]
+FORWARD_AT_LEAST, 5, => [6,7], [8,9]
+FORWARD_AT_LEAST, 6, => [6,7], [8,9]
+FORWARD_AT_MOST, , 5 => [-2,-1], [0,1], [2,3], [4,5]
+FORWARD_AT_MOST, , 6 => [-2,-1], [0,1], [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 3, 7 => [4,5], [6,7]
+FORWARD_CLOSED, 2, 6 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 1, 7 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [4,5]
+FORWARD_GREATER_THAN, 4, => [6,7], [8,9]
+FORWARD_GREATER_THAN, 3, => [4,5], [6,7], [8,9]
+FORWARD_LESS_THAN, , 5 => [-2,-1], [0,1], [2,3], [4,5]
+FORWARD_LESS_THAN, , 8 => [-2,-1], [0,1], [2,3], [4,5], [6,7]
+FORWARD_OPEN, 3, 7 => [4,5], [6,7]
+FORWARD_OPEN, 2, 8 => [4,5], [6,7]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [6,7], [8,9]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [6,7]
+BACKWARD_ALL, , => [8,9], [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, 5, => [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, 9, => [8,9], [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, -1, => [-2,-1]
+BACKWARD_AT_MOST, , 5 => [8,9], [6,7]
+BACKWARD_AT_MOST, , 6 => [8,9], [6,7]
+BACKWARD_AT_MOST, , -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_CLOSED, 7, 3 => [6,7], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,5], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, 6, => [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_GREATER_THAN, 7, => [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_GREATER_THAN, 9, => [8,9], [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_GREATER_THAN, -1, => [-2,-1]
+BACKWARD_LESS_THAN, , 5 => [8,9], [6,7]
+BACKWARD_LESS_THAN, , 2 => [8,9], [6,7], [4,5]
+BACKWARD_LESS_THAN, , -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,9], [6,7]
+BACKWARD_OPEN, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,9], [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
diff --git a/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.actual b/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.actual
new file mode 100644
index 00000000..9f7a6709
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.actual
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_AT_LEAST, 5, => [6,7], [6,8], [8,9], [8,10]
+FORWARD_AT_LEAST, 6, => [6,7], [6,8], [8,9], [8,10]
+FORWARD_AT_MOST, , 5 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_AT_MOST, , 6 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 2, 6 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 1, 7 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [2,4], [4,5], [4,6]
+FORWARD_GREATER_THAN, 4, => [6,7], [6,8], [8,9], [8,10]
+FORWARD_GREATER_THAN, 3, => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_LESS_THAN, , 5 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_LESS_THAN, , 8 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 2, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [4,6], [6,7], [6,8]
+BACKWARD_ALL, , => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, 5, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, -1, => [-2,-1], [-2,0]
+BACKWARD_AT_MOST, , 5 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , 6 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_CLOSED, 7, 3 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, 6, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_GREATER_THAN, 7, => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_GREATER_THAN, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_GREATER_THAN, -1, => [-2,-1], [-2,0]
+BACKWARD_LESS_THAN, , 5 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_LESS_THAN, , 2 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_LESS_THAN, , -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_OPEN, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
diff --git a/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.expected b/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.expected
new file mode 100644
index 00000000..9f7a6709
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.expected
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_AT_LEAST, 5, => [6,7], [6,8], [8,9], [8,10]
+FORWARD_AT_LEAST, 6, => [6,7], [6,8], [8,9], [8,10]
+FORWARD_AT_MOST, , 5 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_AT_MOST, , 6 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 2, 6 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 1, 7 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [2,4], [4,5], [4,6]
+FORWARD_GREATER_THAN, 4, => [6,7], [6,8], [8,9], [8,10]
+FORWARD_GREATER_THAN, 3, => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_LESS_THAN, , 5 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_LESS_THAN, , 8 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 2, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [4,6], [6,7], [6,8]
+BACKWARD_ALL, , => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, 5, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, -1, => [-2,-1], [-2,0]
+BACKWARD_AT_MOST, , 5 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , 6 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_CLOSED, 7, 3 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, 6, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_GREATER_THAN, 7, => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_GREATER_THAN, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_GREATER_THAN, -1, => [-2,-1], [-2,0]
+BACKWARD_LESS_THAN, , 5 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_LESS_THAN, , 2 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_LESS_THAN, , -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_OPEN, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
diff --git a/src/test/resources/CursorIterableRangeTest/testUnsignedComparator.actual b/src/test/resources/CursorIterableRangeTest/testUnsignedComparator.actual
new file mode 100644
index 00000000..1be8d951
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testUnsignedComparator.actual
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [0,1], [2,3], [4,5], [6,7], [8,9], [-2,-1]
+FORWARD_AT_LEAST, 5, => [6,7], [8,9], [-2,-1]
+FORWARD_AT_LEAST, 6, => [6,7], [8,9], [-2,-1]
+FORWARD_AT_MOST, , 5 => [0,1], [2,3], [4,5]
+FORWARD_AT_MOST, , 6 => [0,1], [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 3, 7 => [4,5], [6,7]
+FORWARD_CLOSED, 2, 6 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 1, 7 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [4,5]
+FORWARD_GREATER_THAN, 4, => [6,7], [8,9], [-2,-1]
+FORWARD_GREATER_THAN, 3, => [4,5], [6,7], [8,9], [-2,-1]
+FORWARD_LESS_THAN, , 5 => [0,1], [2,3], [4,5]
+FORWARD_LESS_THAN, , 8 => [0,1], [2,3], [4,5], [6,7]
+FORWARD_OPEN, 3, 7 => [4,5], [6,7]
+FORWARD_OPEN, 2, 8 => [4,5], [6,7]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [6,7], [8,9]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [6,7]
+BACKWARD_ALL, , => [-2,-1], [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, 5, => [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, 9, => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, -1, => [-2,-1], [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_MOST, , 5 => [-2,-1], [8,9], [6,7]
+BACKWARD_AT_MOST, , 6 => [-2,-1], [8,9], [6,7]
+BACKWARD_AT_MOST, , -1 =>
+BACKWARD_CLOSED, 7, 3 => [6,7], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,5], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED, 9, -1 =>
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 =>
+BACKWARD_GREATER_THAN, 6, => [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, 7, => [6,7], [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, 9, => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, -1, => [-2,-1], [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_LESS_THAN, , 5 => [-2,-1], [8,9], [6,7]
+BACKWARD_LESS_THAN, , 2 => [-2,-1], [8,9], [6,7], [4,5]
+BACKWARD_LESS_THAN, , -1 =>
+BACKWARD_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,9], [6,7]
+BACKWARD_OPEN, 9, -1 =>
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,9], [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 =>
diff --git a/src/test/resources/CursorIterableRangeTest/testUnsignedComparator.expected b/src/test/resources/CursorIterableRangeTest/testUnsignedComparator.expected
new file mode 100644
index 00000000..1be8d951
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testUnsignedComparator.expected
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [0,1], [2,3], [4,5], [6,7], [8,9], [-2,-1]
+FORWARD_AT_LEAST, 5, => [6,7], [8,9], [-2,-1]
+FORWARD_AT_LEAST, 6, => [6,7], [8,9], [-2,-1]
+FORWARD_AT_MOST, , 5 => [0,1], [2,3], [4,5]
+FORWARD_AT_MOST, , 6 => [0,1], [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 3, 7 => [4,5], [6,7]
+FORWARD_CLOSED, 2, 6 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 1, 7 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [4,5]
+FORWARD_GREATER_THAN, 4, => [6,7], [8,9], [-2,-1]
+FORWARD_GREATER_THAN, 3, => [4,5], [6,7], [8,9], [-2,-1]
+FORWARD_LESS_THAN, , 5 => [0,1], [2,3], [4,5]
+FORWARD_LESS_THAN, , 8 => [0,1], [2,3], [4,5], [6,7]
+FORWARD_OPEN, 3, 7 => [4,5], [6,7]
+FORWARD_OPEN, 2, 8 => [4,5], [6,7]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [6,7], [8,9]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [6,7]
+BACKWARD_ALL, , => [-2,-1], [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, 5, => [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, 9, => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, -1, => [-2,-1], [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_MOST, , 5 => [-2,-1], [8,9], [6,7]
+BACKWARD_AT_MOST, , 6 => [-2,-1], [8,9], [6,7]
+BACKWARD_AT_MOST, , -1 =>
+BACKWARD_CLOSED, 7, 3 => [6,7], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,5], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED, 9, -1 =>
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 =>
+BACKWARD_GREATER_THAN, 6, => [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, 7, => [6,7], [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, 9, => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, -1, => [-2,-1], [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_LESS_THAN, , 5 => [-2,-1], [8,9], [6,7]
+BACKWARD_LESS_THAN, , 2 => [-2,-1], [8,9], [6,7], [4,5]
+BACKWARD_LESS_THAN, , -1 =>
+BACKWARD_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,9], [6,7]
+BACKWARD_OPEN, 9, -1 =>
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,9], [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 =>
diff --git a/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.actual b/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.actual
new file mode 100644
index 00000000..15dcb9f9
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.actual
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_AT_LEAST, 5, => [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_AT_LEAST, 6, => [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_AT_MOST, , 5 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_AT_MOST, , 6 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 2, 6 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 1, 7 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [2,4], [4,5], [4,6]
+FORWARD_GREATER_THAN, 4, => [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_GREATER_THAN, 3, => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_LESS_THAN, , 5 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_LESS_THAN, , 8 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 2, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [4,6], [6,7], [6,8]
+BACKWARD_ALL, , => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, 5, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, -1, => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_MOST, , 5 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , 6 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , -1 =>
+BACKWARD_CLOSED, 7, 3 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 9, -1 =>
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 =>
+BACKWARD_GREATER_THAN, 6, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, 7, => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, -1, => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_LESS_THAN, , 5 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7]
+BACKWARD_LESS_THAN, , 2 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_LESS_THAN, , -1 =>
+BACKWARD_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_OPEN, 9, -1 =>
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 =>
diff --git a/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.expected b/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.expected
new file mode 100644
index 00000000..15dcb9f9
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.expected
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_AT_LEAST, 5, => [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_AT_LEAST, 6, => [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_AT_MOST, , 5 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_AT_MOST, , 6 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 2, 6 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 1, 7 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [2,4], [4,5], [4,6]
+FORWARD_GREATER_THAN, 4, => [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_GREATER_THAN, 3, => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_LESS_THAN, , 5 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_LESS_THAN, , 8 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 2, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [4,6], [6,7], [6,8]
+BACKWARD_ALL, , => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, 5, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, -1, => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_MOST, , 5 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , 6 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , -1 =>
+BACKWARD_CLOSED, 7, 3 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 9, -1 =>
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 =>
+BACKWARD_GREATER_THAN, 6, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, 7, => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, -1, => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_LESS_THAN, , 5 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7]
+BACKWARD_LESS_THAN, , 2 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_LESS_THAN, , -1 =>
+BACKWARD_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_OPEN, 9, -1 =>
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 =>
diff --git a/src/test/resources/CursorIterableRangeTest/tests.csv b/src/test/resources/CursorIterableRangeTest/tests.csv
new file mode 100644
index 00000000..0e103152
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/tests.csv
@@ -0,0 +1,49 @@
+FORWARD_ALL, ,
+FORWARD_AT_LEAST, 5,
+FORWARD_AT_LEAST, 6,
+FORWARD_AT_MOST, , 5
+FORWARD_AT_MOST, , 6
+FORWARD_CLOSED, 3, 7
+FORWARD_CLOSED, 2, 6
+FORWARD_CLOSED, 1, 7
+FORWARD_CLOSED_OPEN, 3, 8
+FORWARD_CLOSED_OPEN, 2, 6
+FORWARD_GREATER_THAN, 4,
+FORWARD_GREATER_THAN, 3,
+FORWARD_LESS_THAN, , 5
+FORWARD_LESS_THAN, , 8
+FORWARD_OPEN, 3, 7
+FORWARD_OPEN, 2, 8
+FORWARD_OPEN_CLOSED, 3, 8
+FORWARD_OPEN_CLOSED, 2, 6
+BACKWARD_ALL, ,
+BACKWARD_AT_LEAST, 5,
+BACKWARD_AT_LEAST, 6,
+BACKWARD_AT_LEAST, 9,
+BACKWARD_AT_LEAST, -1,
+BACKWARD_AT_MOST, , 5
+BACKWARD_AT_MOST, , 6
+BACKWARD_AT_MOST, , -1
+BACKWARD_CLOSED, 7, 3
+BACKWARD_CLOSED, 6, 2
+BACKWARD_CLOSED, 9, 3
+BACKWARD_CLOSED, 9, -1
+BACKWARD_CLOSED_OPEN, 8, 3
+BACKWARD_CLOSED_OPEN, 7, 2
+BACKWARD_CLOSED_OPEN, 9, 3
+BACKWARD_CLOSED_OPEN, 9, -1
+BACKWARD_GREATER_THAN, 6,
+BACKWARD_GREATER_THAN, 7,
+BACKWARD_GREATER_THAN, 9,
+BACKWARD_GREATER_THAN, -1,
+BACKWARD_LESS_THAN, , 5
+BACKWARD_LESS_THAN, , 2
+BACKWARD_LESS_THAN, , -1
+BACKWARD_OPEN, 7, 2
+BACKWARD_OPEN, 8, 1
+BACKWARD_OPEN, 9, 4
+BACKWARD_OPEN, 9, -1
+BACKWARD_OPEN_CLOSED, 7, 2
+BACKWARD_OPEN_CLOSED, 8, 4
+BACKWARD_OPEN_CLOSED, 9, 4
+BACKWARD_OPEN_CLOSED, 9, -1
\ No newline at end of file

From 0234d323244f874ccf12945949e6352879c5a3b3 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Tue, 28 Oct 2025 16:34:03 +0000
Subject: [PATCH 13/90] Replace get(Uns|S)ignedComparator with
 getComparator(DbiFlagSet)

Also improve javadoc and refactor some tests to use DbiBuilder.

Some tests are failing.
---
 src/main/java/org/lmdbjava/BufferProxy.java   |  45 +++-
 .../java/org/lmdbjava/ByteArrayProxy.java     |  17 +-
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  15 +-
 .../java/org/lmdbjava/ByteBufferProxy.java    |  46 +++-
 .../java/org/lmdbjava/CursorIterable.java     |   4 +-
 src/main/java/org/lmdbjava/Dbi.java           |   7 +-
 src/main/java/org/lmdbjava/DbiBuilder.java    | 196 +++++++++++++-----
 src/main/java/org/lmdbjava/DbiFlags.java      |  20 +-
 .../java/org/lmdbjava/DirectBufferProxy.java  |  17 +-
 src/main/java/org/lmdbjava/Env.java           |  20 +-
 src/main/java/org/lmdbjava/Txn.java           |   2 +-
 src/main/java/org/lmdbjava/TxnFlags.java      |   1 +
 .../java/org/lmdbjava/ComparatorTest.java     |  10 +-
 .../CursorIterableIntegerKeyTest.java         | 121 ++++++-----
 .../org/lmdbjava/CursorIterablePerfTest.java  |  22 +-
 .../java/org/lmdbjava/CursorIterableTest.java | 111 +++++-----
 src/test/java/org/lmdbjava/DbiTest.java       |   8 +-
 .../java/org/lmdbjava/TestDbiBuilder.java     |   6 +-
 18 files changed, 448 insertions(+), 220 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index 2ff5a8fc..60272209 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -66,26 +66,49 @@ protected BufferProxy() {}
   protected abstract byte[] getBytes(T buffer);
 
   /**
-   * Get a suitable default {@link Comparator} to compare numeric key values as signed.
+   * Get a suitable default {@link Comparator} given the provided flags.
    *
-   * <p>Note: LMDB's default comparator is unsigned so if this is used only for the {@link
-   * CursorIterable} start/stop key comparisons then its behaviour will differ from the iteration
-   * order. Use with caution.
+   * <p>The provided comparator must strictly match the lexicographical order of keys in the native
+   * LMDB database.
    *
+   * @param dbiFlagSet The {@link DbiFlags} set for the database.
    * @return a comparator that can be used (never null)
    */
-  public abstract Comparator<T> getSignedComparator();
+  public abstract Comparator<T> getComparator(final DbiFlagSet dbiFlagSet);
 
   /**
-   * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
-   * <p>
-   * This should match the behaviour of the LMDB's mdb_cmp comparator as it may be used for
-   * {@link CursorIterable} start/stop keys comparisons, which must match LMDB's insertion order.
-   * </p>
+   * Get a suitable default {@link Comparator}
+   *
+   * <p>The provided comparator must strictly match the lexicographical order of keys in the native
+   * LMDB database.
    *
    * @return a comparator that can be used (never null)
    */
-  public abstract Comparator<T> getUnsignedComparator();
+  public Comparator<T> getComparator() {
+    return getComparator(DbiFlagSet.empty());
+  }
+
+//  /**
+//   * Get a suitable default {@link Comparator} to compare numeric key values as signed.
+//   *
+//   * <p>Note: LMDB's default comparator is unsigned so if this is used only for the {@link
+//   * CursorIterable} start/stop key comparisons then its behaviour will differ from the iteration
+//   * order. Use with caution.
+//   *
+//   * @return a comparator that can be used (never null)
+//   */
+//  public abstract Comparator<T> getSignedComparator();
+//
+//  /**
+//   * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
+//   * <p>
+//   * This should match the behaviour of the LMDB's mdb_cmp comparator as it may be used for
+//   * {@link CursorIterable} start/stop keys comparisons, which must match LMDB's insertion order.
+//   * </p>
+//   *
+//   * @return a comparator that can be used (never null)
+//   */
+//  public abstract Comparator<T> getUnsignedComparator(final DbiFlagSet dbiFlagSet);
 
   /**
    * Called when the <code>MDB_val</code> should be set to reflect the passed buffer. This buffer
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index b4fb1e7b..5231ed51 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -104,15 +104,20 @@ protected byte[] getBytes(final byte[] buffer) {
   }
 
   @Override
-  public Comparator<byte[]> getSignedComparator() {
-    return signedComparator;
-  }
-
-  @Override
-  public Comparator<byte[]> getUnsignedComparator() {
+  public Comparator<byte[]> getComparator(final DbiFlagSet dbiFlagSet) {
     return unsignedComparator;
   }
 
+  //  @Override
+//  public Comparator<byte[]> getSignedComparator() {
+//    return signedComparator;
+//  }
+//
+//  @Override
+//  public Comparator<byte[]> getUnsignedComparator() {
+//    return unsignedComparator;
+//  }
+
   @Override
   protected Pointer in(final byte[] buffer, final Pointer ptr) {
     final Pointer pointer = MEM_MGR.allocateDirect(buffer.length);
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index e26bcb07..fc14b58f 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -114,14 +114,19 @@ protected ByteBuf allocate() {
   }
 
   @Override
-  public Comparator<ByteBuf> getSignedComparator() {
+  public Comparator<ByteBuf> getComparator(final DbiFlagSet dbiFlagSet) {
     return comparator;
   }
 
-  @Override
-  public Comparator<ByteBuf> getUnsignedComparator() {
-    return comparator;
-  }
+  //  @Override
+//  public Comparator<ByteBuf> getSignedComparator() {
+//    return comparator;
+//  }
+//
+//  @Override
+//  public Comparator<ByteBuf> getUnsignedComparator() {
+//    return comparator;
+//  }
 
   @Override
   protected void deallocate(final ByteBuf buff) {
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index d9edb6a8..4875572b 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -148,6 +148,35 @@ public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
       return o1.remaining() - o2.remaining();
     }
 
+//    /**
+//     * Possible compareBuff method specifically for 4/8 byte keys when using MDB_INTEGER_KEY
+//     */
+//    public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
+//      requireNonNull(o1);
+//      requireNonNull(o2);
+//      // Both buffers should be same len
+//      final int len1 = o1.limit();
+//      final int len2 = o2.limit();
+//      if (len1 != len2) {
+//        throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
+//            + ". Lengths must be identical and either 4 or 8 bytes.");
+//      }
+//      final boolean reverse1 = o1.order() == LITTLE_ENDIAN;
+//      final boolean reverse2 = o2.order() == LITTLE_ENDIAN;
+//      if (len1 == 8) {
+//          final long lw = reverse1 ? Long.reverseBytes(o1.getLong()) : o1.getLong();
+//          final long rw = reverse2 ? Long.reverseBytes(o2.getLong()) : o2.getLong();
+//          return Long.compareUnsigned(lw, rw);
+//      } else if (len1 == 4) {
+//        final int lw = reverse1 ? Integer.reverseBytes(o1.getInt()) : o1.getInt();
+//        final int rw = reverse2 ? Integer.reverseBytes(o2.getInt()) : o2.getInt();
+//          return Integer.compareUnsigned(lw, rw);
+//      } else {
+//        throw new RuntimeException("Unexpected length len1: " + len1 + ", len2: " + len2
+//            + ". Lengths must be identical and either 4 or 8 bytes.");
+//      }
+//    }
+
     static Field findField(final Class<?> c, final String name) {
       Class<?> clazz = c;
       do {
@@ -182,15 +211,20 @@ protected final ByteBuffer allocate() {
     }
 
     @Override
-    public Comparator<ByteBuffer> getSignedComparator() {
-      return signedComparator;
-    }
-
-    @Override
-    public Comparator<ByteBuffer> getUnsignedComparator() {
+    public Comparator<ByteBuffer> getComparator(DbiFlagSet dbiFlagSet) {
       return unsignedComparator;
     }
 
+    //    @Override
+//    public Comparator<ByteBuffer> getSignedComparator() {
+//      return signedComparator;
+//    }
+//
+//    @Override
+//    public Comparator<ByteBuffer> getUnsignedComparator(final DbiFlagSet dbiFlagSet) {
+//      return unsignedComparator;
+//    }
+
     @Override
     protected final void deallocate(final ByteBuffer buff) {
       buff.order(BIG_ENDIAN);
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index dd11a468..69d43fcd 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -60,10 +60,10 @@ public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T
     this.entry = new KeyVal<>();
 
     if (comparator != null) {
-      // User supplied java-side comparator so use that
+      // User supplied Java-side comparator so use that
       this.rangeComparator = new JavaRangeComparator<>(range, comparator, entry::key);
     } else {
-      // No java-side comparator so call down to LMDB to do the comparison
+      // No Java-side comparator, so call down to LMDB to do the comparison
       this.rangeComparator = new LmdbRangeComparator<>(txn, dbi, cursor, range, proxy);
     }
   }
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 17fa4c46..9cdc03ee 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -51,6 +51,7 @@ public final class Dbi<T> {
 
   private final ComparatorCallback ccb;
   private boolean cleaned;
+  // Used for CursorIterable KeyRange testing and/or native callbacks
   private final Comparator<T> comparator;
   private final Env<T> env;
   private final byte[] name;
@@ -80,6 +81,7 @@ public final class Dbi<T> {
     ptr = dbiPtr.getPointer(0);
     if (nativeCb) {
       requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
+      // LMDB will call back to this comparator for insertion/iteration order
       this.ccb =
           (keyA, keyB) -> {
             final T compKeyA  = proxy.out(proxy.allocate(), keyA);
@@ -465,6 +467,7 @@ private String getNameAsString() {
       return "";
     } else {
       try {
+        // Assume a UTF8 encoding as we don't know, thus swallow if it fails
         return new String(name, StandardCharsets.UTF_8);
       } catch (Exception e) {
         return "?";
@@ -475,8 +478,8 @@ private String getNameAsString() {
   @Override
   public String toString() {
     return "Dbi{" +
-            "name=" + getNameAsString() +
-            ", dbiFlagSet=" + dbiFlagSet +
+            "name='" + getNameAsString() +
+            "', dbiFlagSet=" + dbiFlagSet +
             '}';
   }
 
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 7d05a51e..f2f925ce 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -98,8 +98,8 @@ public static class DbiBuilderStage2<T> {
 
     private final DbiBuilder<T> dbiBuilder;
 
-    private Comparator<T> comparator;
-    private boolean useNativeCallback;
+    private java.util.Comparator<T> customComparator;
+    private ComparatorType comparatorType;
 
     private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
       this.dbiBuilder = dbiBuilder;
@@ -107,95 +107,110 @@ private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
 
     /**
      * <p>
-     * {@link CursorIterable} will call down to LMDB's {@code mdb_cmp} method when
-     * comparing entries to start/stop keys. This ensures LmdbJava is comparing start/stop
-     * keys using the same comparator that is used for insert order into the db.
+     * This is the <strong>default</strong> choice when it comes to choosing a comparator.
+     * If you are not sure of the implications of the other methods then use this one as it
+     * is likely what you want and also probably the most performant.
      * </p>
      * <p>
-     * This option may be slightly less performant than when using
-     * {@link DbiBuilderStage2#withDefaultIteratorComparator()} as it need to call down
-     * to LMDB to perform the comparisons, however it guarantees that {@link CursorIterable}
-     * key comparison matches LMDB key comparison.
+     * With this option, {@link CursorIterable} will make use of the LmdbJava's default
+     * Java-side comparators when comparing iteration keys to the start/stop keys.
+     * LMDB will use its own comparator for controlling insertion order in the database.
+     * The two comparators are functionally identical.
+     * </p>
+     * <p>
+     * This option may be slightly more performant than when using
+     * {@link DbiBuilderStage2#withNativeComparator()} which calls down to LMDB for ALL
+     * comparison operations.
      * </p>
      * <p>
      * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
      * you choose {@link DbiBuilderStage2#withNativeComparator()},
-     * {@link DbiBuilderStage2#withDefaultIteratorComparator()} or
+     * {@link DbiBuilderStage2#withDefaultComparator()} or
      * {@link DbiBuilderStage2#withIteratorComparator(Comparator)} as these comparators will
      * never be used.
      * </p>
      *
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withNativeComparator() {
-      this.comparator = null;
-      this.useNativeCallback = false;
+    public DbiBuilderStage3<T> withDefaultComparator() {
+      this.comparatorType = ComparatorType.DEFAULT;
       return new DbiBuilderStage3<>(this);
     }
 
     /**
      * <p>
-     * {@link CursorIterable} will make use of the default Java-side comparators when
-     * comparing entries to start/stop keys.
+     * With this option, {@link CursorIterable} will call down to LMDB's {@code mdb_cmp} method when
+     * comparing iteration keys to start/stop keys. This ensures LmdbJava is comparing start/stop
+     * keys using the same comparator that is used for insertion order into the db.
      * </p>
      * <p>
-     * This option may be slightly more performant than when using
-     * {@link DbiBuilderStage2#withNativeComparator()} but it relies on the default comparator
-     * in LmdbJava behaving identically to the comparator in LMDB.
+     * This option may be slightly less performant than when using
+     * {@link DbiBuilderStage2#withDefaultComparator()} as it needs to call down
+     * to LMDB to perform the comparisons, however it guarantees that {@link CursorIterable}
+     * key comparison matches LMDB key comparison.
      * </p>
      * <p>
      * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
      * you choose {@link DbiBuilderStage2#withNativeComparator()},
-     * {@link DbiBuilderStage2#withDefaultIteratorComparator()} or
+     * {@link DbiBuilderStage2#withDefaultComparator()} or
      * {@link DbiBuilderStage2#withIteratorComparator(Comparator)} as these comparators will
      * never be used.
      * </p>
      *
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withDefaultIteratorComparator() {
-      this.comparator = dbiBuilder.proxy.getUnsignedComparator();
-      this.useNativeCallback = false;
+    public DbiBuilderStage3<T> withNativeComparator() {
+      this.comparatorType = ComparatorType.NATIVE;
       return new DbiBuilderStage3<>(this);
     }
 
+
     /**
-     * Provide a java-side {@link Comparator} that LMDB will call back to in order to
-     * manage database insertion/iteration order. It will also be used for {@link CursorIterable}
-     * start/stop key comparisons.
+     * Provide a java-side {@link Comparator} that LMDB will call back to for <strong>all</strong>
+     * comparison operations.
+     * Therefore, it will be called by LMDB to manage database insertion/iteration order.
+     * It will also be used for {@link CursorIterable} start/stop key comparisons.
      * <p>
-     * Due to calling back to java, this will be less performant than using LMDB's
-     * default comparator, but allows for total control over the order in which entries
+     * It can be useful if you need to sort your database using some other method,
+     * e.g. signed keys or case-insensitive order.
+     * Note, if you need keys stored in reverse order, see {@link DbiFlags#MDB_REVERSEKEY}
+     * and {@link DbiFlags#MDB_REVERSEDUP}.
+     * </p>
+     * <p>
+     * As this requires LMDB to call back to java, this will be less performant than using LMDB's
+     * default comparators, but allows for total control over the order in which entries
      * are stored in the database.
      * </p>
      *
      * @param comparator for all key comparison operations.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withCallbackIteratorComparator(final Comparator<T> comparator) {
-      this.comparator = Objects.requireNonNull(comparator);
-      this.useNativeCallback = true;
+    public DbiBuilderStage3<T> withCallbackComparator(final Comparator<T> comparator) {
+      this.customComparator = Objects.requireNonNull(comparator);
+      this.comparatorType = ComparatorType.CALLBACK;
       return new DbiBuilderStage3<>(this);
     }
 
     /**
+     * <hr>
      * <p>
-     * {@link CursorIterable} will make use of the passed comparator for
-     * comparing entries to start/stop keys. It has NO bearing on the insert/iteration
-     * order of the db.
+     * <strong>WARNING</strong>: Only use this if you fully understand the risks and implications.
      * </p>
+     * <hr>
      * <p>
-     * <strong>WARNING:</strong> Only call this method if you fully understand the implications
-     * of using a comparator for the {@link CursorIterable} start/stop keys that behaves
-     * differently to the comparator in LMDB that controls the insert/iteration order.
+     * With this option, {@link CursorIterable} will make use of the passed comparator for
+     * comparing iteration keys to start/stop keys. It has <strong>NO</strong> bearing on the
+     * insert/iteration order of the database (which is controlled by LMDB's own comparators).
      * </p>
      * <p>
-     * The supplied {@link Comparator} should match the behaviour of LMDB's mdb_cmp comparator.
+     * It is <strong>vital</strong> that this comparator is functionally identical to the one
+     * used internally in LMDB for insertion/iteration order, else you will see unexpected behaviour
+     * when using {@link CursorIterable}.
      * </p>
      * <p>
      * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
      * you choose {@link DbiBuilderStage2#withNativeComparator()},
-     * {@link DbiBuilderStage2#withDefaultIteratorComparator()} or
+     * {@link DbiBuilderStage2#withDefaultComparator()} or
      * {@link DbiBuilderStage2#withIteratorComparator(Comparator)} as these comparators will
      * never be used.
      * </p>
@@ -204,8 +219,8 @@ public DbiBuilderStage3<T> withCallbackIteratorComparator(final Comparator<T> co
      * @return The next builder stage.
      */
     public DbiBuilderStage3<T> withIteratorComparator(final Comparator<T> comparator) {
-      this.comparator = Objects.requireNonNull(comparator);
-      this.useNativeCallback = false;
+      this.customComparator = Objects.requireNonNull(comparator);
+      this.comparatorType = ComparatorType.ITERATOR;
       return new DbiBuilderStage3<>(this);
     }
   }
@@ -234,14 +249,18 @@ private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
      * Apply all the dbi flags supplied in dbiFlags.
      * </p>
      * <p>
-     * Replaces any flags applies in previous calls to
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)}, {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
+     * Clears all flags currently set by previous calls to
+     * {@link DbiBuilderStage3#withDbiFlags(Collection)},
+     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlags to open the database with.
+     *                 A null {@link Collection} will just clear all set flags.
+     *                 Null items are ignored.
      */
     public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
+      flagSetBuilder.clear();
       if (dbiFlags != null) {
         dbiFlags.stream()
                 .filter(Objects::nonNull)
@@ -255,14 +274,15 @@ public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
      * Apply all the dbi flags supplied in dbiFlags.
      * </p>
      * <p>
-     * Replaces any flags applies in previous calls to
+     * Clears all flags currently set by previous calls to
      * {@link DbiBuilderStage3#withDbiFlags(Collection)},
      * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlags to open the database with.
-     *                 A null array is a no-op. Null items are ignored.
+     *                 A null array will just clear all set flags.
+     *                 Null items are ignored.
      */
     public DbiBuilderStage3<T> withDbiFlags(final DbiFlags... dbiFlags) {
       flagSetBuilder.clear();
@@ -275,7 +295,29 @@ public DbiBuilderStage3<T> withDbiFlags(final DbiFlags... dbiFlags) {
     }
 
     /**
-     * Adds dbiFlag to those flags already added to this builder by
+     * <p>
+     * Apply all the dbi flags supplied in dbiFlags.
+     * </p>
+     * <p>
+     * Clears all flags currently set by previous calls to
+     * {@link DbiBuilderStage3#withDbiFlags(Collection)},
+     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
+     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
+     * </p>
+     *
+     * @param dbiFlagSet to open the database with.
+     *                 A null value will just clear all set flags.
+     */
+    public DbiBuilderStage3<T> withDbiFlags(final DbiFlagSet dbiFlagSet) {
+      flagSetBuilder.clear();
+      if (dbiFlagSet != null) {
+        this.flagSetBuilder.withFlags(dbiFlagSet.getFlags());
+      }
+      return this;
+    }
+
+    /**
+     * Adds a dbiFlag to those flags already added to this builder by
      * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)},
      * {@link DbiBuilderStage3#withDbiFlags(Collection)}
      * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
@@ -294,8 +336,15 @@ public DbiBuilderStage3<T> setDbiFlag(final DbiFlags dbiFlag) {
      * The caller MUST commit the transaction after calling {@link DbiBuilderStage3#open()},
      * in order to retain the <code>Dbi</code> in the <code>Env</code>.
      * </p>
+     * <p>
+     * If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for the purpose
+     * of creating and opening the {@link Dbi}, then closed. Therefore, if you already have a transaction
+     * open, you should supply that to avoid one blocking the other.
+     * </p>
      *
-     * @param txn transaction to use (required; not closed)
+     * @param txn transaction to use (required; not closed). If the {@link Env} was opened
+     *            with the {@link EnvFlags#MDB_RDONLY_ENV} flag, the {@link Txn} can be read-only,
+     *            else it needs to be a read/write {@link Txn}.
      * @return this builder instance.
      */
     public DbiBuilderStage3<T> withTxn(final Txn<T> txn) {
@@ -329,18 +378,69 @@ private Txn<T> getTxn(final DbiBuilder<T> dbiBuilder) {
           : dbiBuilder.env.txnWrite();
     }
 
+    private Comparator<T> getComparator(final DbiBuilder<T> dbiBuilder,
+                                        final ComparatorType comparatorType,
+                                        final DbiFlagSet dbiFlagSet) {
+      Comparator<T> comparator = null;
+      switch (comparatorType) {
+        case DEFAULT:
+          // Get the appropriate default CursorIterable comparator based on the DbiFlags,
+          // e.g. MDB_INTEGERKEY may benefit from an optimised comparator.
+          comparator = dbiBuilder.proxy.getComparator(dbiFlagSet);
+          break;
+        case CALLBACK:
+        case ITERATOR:
+          comparator = dbiBuilderStage2.customComparator;
+          break;
+        case NATIVE:
+          break;
+        default:
+          throw new IllegalStateException("Unexpected comparatorType " + comparatorType);
+      }
+      return comparator;
+    }
+
     private Dbi<T> open(final Txn<T> txn,
                         final DbiBuilder<T> dbiBuilder) {
       final DbiFlagSet dbiFlagSet = flagSetBuilder.build();
+      final ComparatorType comparatorType = dbiBuilderStage2.comparatorType;
+      final Comparator<T> comparator = getComparator(dbiBuilder, comparatorType, dbiFlagSet);
+      final boolean useNativeCallback = comparatorType == ComparatorType.CALLBACK;
 
       return new Dbi<>(
           dbiBuilder.env,
           txn,
           dbiBuilder.name,
-          dbiBuilderStage2.comparator,
-          dbiBuilderStage2.useNativeCallback,
+          comparator,
+          useNativeCallback,
           dbiBuilder.proxy,
           dbiFlagSet);
     }
   }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  private enum ComparatorType {
+    /**
+     * Default Java comparator for {@link CursorIterable} KeyRange testing,
+     * LMDB comparator for insertion/iteration order.
+     */
+    DEFAULT,
+    /**
+     * Use LMDB native comparator for everything.
+     */
+    NATIVE,
+    /**
+     * Use the supplied custom Java-side comparator for everything.
+     */
+    CALLBACK,
+    /**
+     * Use the supplied custom Java-side comparator for {@link CursorIterable} KeyRange testing,
+     * LMDB comparator for insertion/iteration order.
+     */
+    ITERATOR,
+    ;
+  }
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 6e4b723d..10952da9 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -32,7 +32,7 @@ public enum DbiFlags implements MaskedFlag, DbiFlagSet {
    * Use sorted duplicates.
    *
    * <p>Duplicate keys may be used in the database. Or, from another perspective, keys may have
-   * multiple data items, stored in sorted order. By default keys must be unique and may have only a
+   * multiple data items, stored in sorted order. By default, keys must be unique and may have only a
    * single data item.
    * <p>
    *
@@ -40,8 +40,22 @@ public enum DbiFlags implements MaskedFlag, DbiFlagSet {
    */
   MDB_DUPSORT(0x04),
   /**
-   * Numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the
-   * same size.
+   * Numeric keys in native byte order: either unsigned int or size_t.
+   * The keys must all be of the same size.
+   * <p>
+   * This is an optimisation that is available when your keys are 4 or 8 byte unsigned numeric values.
+   * There are performance benefits for both ordered and un-ordered puts as compared to not using
+   * this flag.
+   * </p>
+   * <p>
+   * When writing the key to the buffer you must write it in native order and subsequently read any
+   * keys retrieved from LMDB (via cursor or get method) also using native order.
+   * </p>
+   * <p>
+   * For more information, see
+   * <a href="https://github.com/lmdbjava/lmdbjava/wiki/Keys#numeric-keys">Numeric Keys</a>
+   * in the LmdbJava wiki.
+   * </p>
    */
   MDB_INTEGERKEY(0x08),
   /**
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 1aab2573..514c04ab 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -111,15 +111,20 @@ protected DirectBuffer allocate() {
   }
 
   @Override
-  public Comparator<DirectBuffer> getSignedComparator() {
-    return signedComparator;
-  }
-
-  @Override
-  public Comparator<DirectBuffer> getUnsignedComparator() {
+  public Comparator<DirectBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
     return unsignedComparator;
   }
 
+  //  @Override
+//  public Comparator<DirectBuffer> getSignedComparator() {
+//    return signedComparator;
+//  }
+//
+//  @Override
+//  public Comparator<DirectBuffer> getUnsignedComparator(final DbiFlagSet dbiFlagSet) {
+//    return unsignedComparator;
+//  }
+
   @Override
   protected void deallocate(final DirectBuffer buff) {
     final ArrayDeque<DirectBuffer> q = BUFFERS.get();
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 2ad929ad..efc4e240 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -270,13 +270,13 @@ public DbiBuilder<T> buildDbi() {
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
    * Comparator} that is not invoked from native code.
    *
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
@@ -285,6 +285,7 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
    *
@@ -298,7 +299,6 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
    *     comparator will be used.
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -308,6 +308,7 @@ public Dbi<T> openDbi(
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop
    * keys as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to
@@ -320,7 +321,6 @@ public Dbi<T> openDbi(
    * @param nativeCb whether LMDB native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -333,13 +333,13 @@ public Dbi<T> openDbi(
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
    * invoked from native code.
    *
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
@@ -347,6 +347,7 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that is not
    * invoked from native code.
    *
@@ -354,7 +355,6 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
    * @param comparator custom comparator callback (or null to use LMDB default)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -363,6 +363,7 @@ public Dbi<T> openDbi(
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that may be
    * invoked from native code if specified.
    *
@@ -374,7 +375,6 @@ public Dbi<T> openDbi(
    * @param nativeCb whether native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -390,6 +390,7 @@ public Dbi<T> openDbi(
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Open the {@link Dbi} using the passed {@link Txn}.
    *
    * <p>The caller must commit the transaction after this method returns in order to retain the
@@ -412,10 +413,9 @@ public Dbi<T> openDbi(
    * @param txn transaction to use (required; not closed)
    * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb whether native code should call back to the comparator
+   * @param nativeCb whether native LMDB code should call back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -424,6 +424,10 @@ public Dbi<T> openDbi(
       final Comparator<T> comparator,
       final boolean nativeCb,
       final DbiFlags... flags) {
+
+    if (nativeCb && comparator == null) {
+      throw new IllegalArgumentException("Is nativeCb is true, you must supply a comparator");
+    }
     return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
   }
 
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 5c8440fd..dc57fc66 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -164,7 +164,7 @@ public void renew() {
   }
 
   /**
-   * Aborts this read-only transaction and resets the transaction handle so it can be reused upon
+   * Aborts this read-only transaction and resets the transaction handle, so it can be reused upon
    * calling {@link #renew()}.
    */
   public void reset() {
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index 8e4ea757..94112957 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -20,6 +20,7 @@
 
 /** Flags for use when creating a {@link Txn}. */
 public enum TxnFlags implements MaskedFlag, TxnFlagSet {
+
   /** Read only. */
   MDB_RDONLY_TXN(0x2_0000);
 
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 446b8545..1b00c71c 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -136,7 +136,7 @@ private static final class ByteArrayRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final Comparator<byte[]> c = PROXY_BA.getUnsignedComparator();
+      final Comparator<byte[]> c = PROXY_BA.getComparator();
       return c.compare(o1, o2);
     }
   }
@@ -146,7 +146,7 @@ private static final class UnsignedByteArrayRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final Comparator<byte[]> c = PROXY_BA.getUnsignedComparator();
+      final Comparator<byte[]> c = PROXY_BA.getComparator();
       return c.compare(o1, o2);
     }
   }
@@ -156,7 +156,7 @@ private static final class ByteBufferRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getUnsignedComparator();
+      final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getComparator();
 
       // Convert arrays to buffers that are larger than the array, with
       // limit set at the array length. One buffer bigger than the other.
@@ -200,7 +200,7 @@ private static final class DirectBufferRunner implements ComparatorRunner {
     public int compare(final byte[] o1, final byte[] o2) {
       final DirectBuffer o1b = new UnsafeBuffer(o1);
       final DirectBuffer o2b = new UnsafeBuffer(o2);
-      final Comparator<DirectBuffer> c = PROXY_DB.getUnsignedComparator();
+      final Comparator<DirectBuffer> c = PROXY_DB.getComparator();
       return c.compare(o1b, o2b);
     }
   }
@@ -234,7 +234,7 @@ public int compare(final byte[] o1, final byte[] o2) {
       final ByteBuf o2b = DEFAULT.directBuffer(o2.length);
       o1b.writeBytes(o1);
       o2b.writeBytes(o2);
-      final Comparator<ByteBuf> c = PROXY_NETTY.getUnsignedComparator();
+      final Comparator<ByteBuf> c = PROXY_NETTY.getComparator();
       return c.compare(o1b, o2b);
     }
   }
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 431c6e51..aefe9d43 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -135,18 +135,27 @@ public void before() throws IOException {
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
     // Use a java comparator for start/stop keys only
-    dbJavaComparator = env.openDbi(DB_1,
-        bufferProxy.getUnsignedComparator(),
-        MDB_CREATE,
-        MDB_INTEGERKEY);
+    DbiFlagSet dbiFlagSet = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
+
+    dbJavaComparator = env.buildDbi()
+        .withDbName(DB_1)
+        .withIteratorComparator(bufferProxy.getComparator(dbiFlagSet))
+        .withDbiFlags(dbiFlagSet)
+        .open();
+
     // Use LMDB comparator for start/stop keys
-    dbLmdbComparator = env.openDbi(DB_2, MDB_CREATE, MDB_INTEGERKEY);
+    dbLmdbComparator = env.buildDbi()
+        .withDbName(DB_2)
+        .withDefaultComparator()
+        .withDbiFlags(dbiFlagSet)
+        .open();
+
     // Use a java comparator for start/stop keys and as a callback comparaotr
-    dbCallbackComparator = env.openDbi(DB_3,
-        bufferProxy.getUnsignedComparator(),
-        true,
-        MDB_CREATE,
-        MDB_INTEGERKEY);
+    dbCallbackComparator = env.buildDbi()
+        .withDbName(DB_3)
+        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
+        .withDbiFlags(dbiFlagSet)
+        .open();
 
     populateList();
 
@@ -411,52 +420,52 @@ public void forEachRemainingWithClosedEnvTest() {
     }
   }
 
-  @Test
-  public void testSignedVsUnsigned() {
-    final ByteBuffer val1 = bbNative(1);
-    final ByteBuffer val2 = bbNative(2);
-    final ByteBuffer val110 = bbNative(110);
-    final ByteBuffer val111 = bbNative(111);
-    final ByteBuffer val150 = bbNative(150);
-
-    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
-    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
-
-    // Compare the same
-    assertThat(
-        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
-
-    // Compare differently
-    assertThat(
-        unsignedComparator.compare(val110, val150),
-        Matchers.not(signedComparator.compare(val110, val150)));
-
-    // Compare differently
-    assertThat(
-        unsignedComparator.compare(val111, val150),
-        Matchers.not(signedComparator.compare(val111, val150)));
-
-    // This will fail if the db is using a signed comparator for the start/stop keys
-    for (final Dbi<ByteBuffer> db : dbs) {
-      db.put(val110, val110);
-      db.put(val150, val150);
-
-      final ByteBuffer startKeyBuf = val111;
-      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
-
-      try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
-        for (final KeyVal<ByteBuffer> kv : c) {
-          final int key = getNativeInt(kv.key());
-          final int val = kv.val().getInt();
-          //          System.out.println("key: " + key + " val: " + val);
-          assertThat(key, is(110));
-          break;
-        }
-      }
-    }
-  }
+//  @Test
+//  public void testSignedVsUnsigned() {
+//    final ByteBuffer val1 = bbNative(1);
+//    final ByteBuffer val2 = bbNative(2);
+//    final ByteBuffer val110 = bbNative(110);
+//    final ByteBuffer val111 = bbNative(111);
+//    final ByteBuffer val150 = bbNative(150);
+//
+//    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+//    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
+//    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
+//
+//    // Compare the same
+//    assertThat(
+//        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
+//
+//    // Compare differently
+//    assertThat(
+//        unsignedComparator.compare(val110, val150),
+//        Matchers.not(signedComparator.compare(val110, val150)));
+//
+//    // Compare differently
+//    assertThat(
+//        unsignedComparator.compare(val111, val150),
+//        Matchers.not(signedComparator.compare(val111, val150)));
+//
+//    // This will fail if the db is using a signed comparator for the start/stop keys
+//    for (final Dbi<ByteBuffer> db : dbs) {
+//      db.put(val110, val110);
+//      db.put(val150, val150);
+//
+//      final ByteBuffer startKeyBuf = val111;
+//      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
+//
+//      try (Txn<ByteBuffer> txn = env.txnRead();
+//          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+//        for (final KeyVal<ByteBuffer> kv : c) {
+//          final int key = getNativeInt(kv.key());
+//          final int val = kv.val().getInt();
+//          //          System.out.println("key: " + key + " val: " + val);
+//          assertThat(key, is(110));
+//          break;
+//        }
+//      }
+//    }
+//  }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
     // Verify using all comparator types
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index f77ac4d6..e2c54346 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -65,14 +65,26 @@ public void before() throws IOException {
             .setMaxDbs(3)
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
+    final DbiFlagSet dbiFlagSet = MDB_CREATE;
     // Use a java comparator for start/stop keys only
-    dbJavaComparator =
-        env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
+    dbJavaComparator = env.buildDbi()
+        .withDbName("JavaComparator")
+        .withDefaultComparator()
+        .withDbiFlags(dbiFlagSet)
+        .open();
     // Use LMDB comparator for start/stop keys
-    dbLmdbComparator = env.openDbi("LmdbComparator", MDB_CREATE);
+    dbLmdbComparator = env.buildDbi()
+        .withDbName("LmdbComparator")
+        .withNativeComparator()
+        .withDbiFlags(dbiFlagSet)
+        .open();
+
     // Use a java comparator for start/stop keys and as a callback comparator
-    dbCallbackComparator =
-        env.openDbi("CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+    dbCallbackComparator = env.buildDbi()
+        .withDbName("CallBackComparator")
+        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
+        .withDbiFlags(dbiFlagSet)
+        .open();
 
     dbs.add(dbJavaComparator);
     dbs.add(dbLmdbComparator);
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 22cf7361..79a9a34c 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -129,12 +129,25 @@ public void before() throws IOException {
             .setMaxDbs(3)
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
+    final DbiFlagSet dbiFlagSet = MDB_CREATE;
     // Use a java comparator for start/stop keys only
-    dbJavaComparator = env.openDbi(DB_1, bufferProxy.getUnsignedComparator(), MDB_CREATE);
+    dbJavaComparator = env.buildDbi()
+        .withDbName(DB_1)
+        .withDefaultComparator()
+        .withDbiFlags(dbiFlagSet)
+        .open();
     // Use LMDB comparator for start/stop keys
-    dbLmdbComparator = env.openDbi(DB_2, MDB_CREATE);
+    dbLmdbComparator = env.buildDbi()
+        .withDbName(DB_2)
+        .withNativeComparator()
+        .withDbiFlags(dbiFlagSet)
+        .open();
     // Use a java comparator for start/stop keys and as a callback comparaotr
-    dbCallbackComparator = env.openDbi(DB_3, bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+    dbCallbackComparator = env.buildDbi()
+        .withDbName(DB_3)
+        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
+        .withDbiFlags(dbiFlagSet)
+        .open();
 
     populateList();
 
@@ -407,52 +420,52 @@ public void forEachRemainingWithClosedEnvTest() {
     }
   }
 
-  @Test
-  public void testSignedVsUnsigned() {
-    final ByteBuffer val1 = bb(1);
-    final ByteBuffer val2 = bb(2);
-    final ByteBuffer val110 = bb(110);
-    final ByteBuffer val111 = bb(111);
-    final ByteBuffer val150 = bb(150);
-
-    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
-    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
-
-    // Compare the same
-    assertThat(
-        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
-
-    // Compare differently
-    assertThat(
-        unsignedComparator.compare(val110, val150),
-        Matchers.not(signedComparator.compare(val110, val150)));
-
-    // Compare differently
-    assertThat(
-        unsignedComparator.compare(val111, val150),
-        Matchers.not(signedComparator.compare(val111, val150)));
-
-    // This will fail if the db is using a signed comparator for the start/stop keys
-    for (final Dbi<ByteBuffer> db : dbs) {
-      db.put(val110, val110);
-      db.put(val150, val150);
-
-      final ByteBuffer startKeyBuf = val111;
-      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
-
-      try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
-        for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
-          final int key = kv.key().getInt();
-          final int val = kv.val().getInt();
-          //          System.out.println("key: " + key + " val: " + val);
-          assertThat(key, is(110));
-          break;
-        }
-      }
-    }
-  }
+//  @Test
+//  public void testSignedVsUnsigned() {
+//    final ByteBuffer val1 = bb(1);
+//    final ByteBuffer val2 = bb(2);
+//    final ByteBuffer val110 = bb(110);
+//    final ByteBuffer val111 = bb(111);
+//    final ByteBuffer val150 = bb(150);
+//
+//    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+//    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
+//    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
+//
+//    // Compare the same
+//    assertThat(
+//        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
+//
+//    // Compare differently
+//    assertThat(
+//        unsignedComparator.compare(val110, val150),
+//        Matchers.not(signedComparator.compare(val110, val150)));
+//
+//    // Compare differently
+//    assertThat(
+//        unsignedComparator.compare(val111, val150),
+//        Matchers.not(signedComparator.compare(val111, val150)));
+//
+//    // This will fail if the db is using a signed comparator for the start/stop keys
+//    for (final Dbi<ByteBuffer> db : dbs) {
+//      db.put(val110, val110);
+//      db.put(val150, val150);
+//
+//      final ByteBuffer startKeyBuf = val111;
+//      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
+//
+//      try (Txn<ByteBuffer> txn = env.txnRead();
+//          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+//        for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+//          final int key = kv.key().getInt();
+//          final int val = kv.val().getInt();
+//          //          System.out.println("key: " + key + " val: " + val);
+//          assertThat(key, is(110));
+//          break;
+//        }
+//      }
+//    }
+//  }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
     // Verify using all comparator types
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 37f141e9..2209e614 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -118,7 +118,7 @@ public void close() {
   public void customComparator() {
     final Comparator<ByteBuffer> reverseOrder =
         (o1, o2) -> {
-          final int lexical = PROXY_OPTIMAL.getUnsignedComparator().compare(o1, o2);
+          final int lexical = PROXY_OPTIMAL.getComparator().compare(o1, o2);
           if (lexical == 0) {
             return 0;
           }
@@ -131,7 +131,7 @@ public void customComparator() {
   public void customComparatorByteArray() {
     final Comparator<byte[]> reverseOrder =
         (o1, o2) -> {
-          final int lexical = PROXY_BA.getUnsignedComparator().compare(o1, o2);
+          final int lexical = PROXY_BA.getComparator().compare(o1, o2);
           if (lexical == 0) {
             return 0;
           }
@@ -172,13 +172,13 @@ public void dbOpenMaxDatabases() {
   @Test
   public void dbiWithComparatorThreadSafety() {
     doDbiWithComparatorThreadSafety(
-        env, PROXY_OPTIMAL::getUnsignedComparator, TestUtils::bb, ByteBuffer::getInt);
+        env, PROXY_OPTIMAL::getComparator, TestUtils::bb, ByteBuffer::getInt);
   }
 
   @Test
   public void dbiWithComparatorThreadSafetyByteArray() {
     doDbiWithComparatorThreadSafety(
-        envBa, PROXY_BA::getUnsignedComparator, TestUtils::ba, TestUtils::fromBa);
+        envBa, PROXY_BA::getComparator, TestUtils::ba, TestUtils::fromBa);
   }
 
   public <T> void doDbiWithComparatorThreadSafety(
diff --git a/src/test/java/org/lmdbjava/TestDbiBuilder.java b/src/test/java/org/lmdbjava/TestDbiBuilder.java
index 15b70812..7a1e8947 100644
--- a/src/test/java/org/lmdbjava/TestDbiBuilder.java
+++ b/src/test/java/org/lmdbjava/TestDbiBuilder.java
@@ -10,7 +10,6 @@
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
-import junit.framework.TestCase;
 import org.hamcrest.Matchers;
 import org.junit.After;
 import org.junit.Before;
@@ -31,6 +30,7 @@ public void after() {
 
     @Before
     public void before() throws IOException {
+        System.out.println("before");
         final File path = tmp.newFile();
         env =
                 create()
@@ -44,7 +44,7 @@ public void before() throws IOException {
     public void unnamed() {
         final Dbi<ByteBuffer> dbi = env.buildDbi()
                 .withoutDbName()
-                .withDefaultIteratorComparator()
+                .withDefaultComparator()
                 .withDbiFlags(DbiFlags.MDB_CREATE)
                 .open();
 
@@ -58,7 +58,7 @@ public void unnamed() {
     public void named() {
         final Dbi<ByteBuffer> dbi = env.buildDbi()
                 .withDbName("foo")
-                .withDefaultIteratorComparator()
+                .withDefaultComparator()
                 .withDbiFlags(DbiFlags.MDB_CREATE)
                 .open();
 

From ef0c852ad9a631ae0f194f4d63dce62e3d1b549f Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Tue, 28 Oct 2025 17:31:32 +0000
Subject: [PATCH 14/90] Add missing txn commit in DbiBuilder

---
 .../java/org/lmdbjava/AbstractFlagSet.java    | 15 +++
 src/main/java/org/lmdbjava/CopyFlagSet.java   | 15 +++
 src/main/java/org/lmdbjava/Dbi.java           | 11 +--
 src/main/java/org/lmdbjava/DbiBuilder.java    | 15 +--
 src/main/java/org/lmdbjava/DbiFlagSet.java    | 15 +++
 src/main/java/org/lmdbjava/EnvFlagSet.java    | 15 +++
 src/main/java/org/lmdbjava/FlagSet.java       | 15 +++
 src/main/java/org/lmdbjava/PutFlagSet.java    | 15 +++
 src/main/java/org/lmdbjava/ReferenceUtil.java |  1 +
 src/main/java/org/lmdbjava/Txn.java           |  7 +-
 src/main/java/org/lmdbjava/TxnFlagSet.java    | 15 +++
 .../java/org/lmdbjava/CopyFlagSetTest.java    | 15 +++
 .../java/org/lmdbjava/DbiBuilderTest.java     | 97 +++++++++++++++++++
 .../java/org/lmdbjava/DbiFlagSetTest.java     | 15 +++
 .../java/org/lmdbjava/EnvFlagSetTest.java     | 15 +++
 .../java/org/lmdbjava/PutFlagSetTest.java     | 15 +++
 .../java/org/lmdbjava/TestDbiBuilder.java     | 83 ----------------
 .../java/org/lmdbjava/TxnFlagSetTest.java     | 15 +++
 18 files changed, 296 insertions(+), 98 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/DbiBuilderTest.java
 delete mode 100644 src/test/java/org/lmdbjava/TestDbiBuilder.java

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 7ea413fb..5e62b437 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.Collection;
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index 62c73c8d..5f7901de 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.Collection;
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 9cdc03ee..c66dc780 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -49,7 +49,7 @@
  */
 public final class Dbi<T> {
 
-  private final ComparatorCallback ccb;
+  private final ComparatorCallback callbackComparator;
   private boolean cleaned;
   // Used for CursorIterable KeyRange testing and/or native callbacks
   private final Comparator<T> comparator;
@@ -82,7 +82,7 @@ public final class Dbi<T> {
     if (nativeCb) {
       requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
       // LMDB will call back to this comparator for insertion/iteration order
-      this.ccb =
+      this.callbackComparator =
           (keyA, keyB) -> {
             final T compKeyA  = proxy.out(proxy.allocate(), keyA);
             final T compKeyB = proxy.out(proxy.allocate(), keyB);
@@ -91,9 +91,9 @@ public final class Dbi<T> {
             proxy.deallocate(compKeyB);
             return result;
           };
-      LIB.mdb_set_compare(txn.pointer(), ptr, ccb);
+      LIB.mdb_set_compare(txn.pointer(), ptr, callbackComparator);
     } else {
-      ccb = null;
+      callbackComparator = null;
     }
   }
 
@@ -380,8 +380,7 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(val);
     final int mask = mask(flags);
-    final int rc =
-        LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
+    final int rc = LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
       if (isSet(mask, MDB_NOOVERWRITE)) {
         txn.kv().valOut(); // marked as in,out in LMDB C docs
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index f2f925ce..dcf34d0a 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -355,20 +355,23 @@ public DbiBuilderStage3<T> withTxn(final Txn<T> txn) {
     /**
      * Construct and open the {@link Dbi}.
      * <p>
-     * If a {@link Txn} was supplied to the builder, it should be committed upon return from
-     * this method.
+     * If a {@link Txn} was supplied to the builder, it is the callers responsibility to
+     * commit and close the txn upon return from this method, else the created DB won't be retained.
      * </p>
      *
      * @return A newly constructed and opened {@link Dbi}.
      */
     public Dbi<T> open() {
       final DbiBuilder<T> dbiBuilder = dbiBuilderStage2.dbiBuilder;
-      if (txn == null) {
+      if (txn != null) {
+        return open(txn, dbiBuilder);
+      } else {
         try (final Txn<T> txn = getTxn(dbiBuilder)) {
-          return open(txn, dbiBuilder);
+          final Dbi<T> dbi = open(txn, dbiBuilder);
+          // even RO Txns require a commit to retain Dbi in Env
+          txn.commit();
+          return dbi;
         }
-      } else {
-        return open(txn, dbiBuilder);
       }
     }
 
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index e5c97544..28f5e4f1 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.Collection;
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index 944496e6..f1bab2d0 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.Collection;
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index 80a4c19e..89b955a0 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.Comparator;
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 1eedaf10..85de014b 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.Collection;
diff --git a/src/main/java/org/lmdbjava/ReferenceUtil.java b/src/main/java/org/lmdbjava/ReferenceUtil.java
index 2b9f211e..70b3c338 100644
--- a/src/main/java/org/lmdbjava/ReferenceUtil.java
+++ b/src/main/java/org/lmdbjava/ReferenceUtil.java
@@ -41,6 +41,7 @@ private ReferenceUtil() {}
    */
   public static void reachabilityFence0(final Object ref) {
     if (ref != null) {
+      //noinspection EmptySynchronizedStatement
       synchronized (ref) {
         // Empty synchronized is ok: https://stackoverflow.com/a/31933260/1151521
       }
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index dc57fc66..99439bf7 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -42,15 +42,16 @@ public final class Txn<T> implements AutoCloseable {
   private final Pointer ptr;
   private final boolean readOnly;
   private final Env<T> env;
+  private final TxnFlagSet flags;
   private State state;
 
   Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlagSet flags) {
-    final TxnFlagSet flagSet = flags != null
+    this.flags = flags != null
         ? flags
         : TxnFlagSet.EMPTY;
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
-    this.readOnly = flagSet.isSet(MDB_RDONLY_TXN);
+    this.readOnly = this.flags.isSet(MDB_RDONLY_TXN);
     if (env.isReadOnly() && !this.readOnly) {
       throw new EnvIsReadOnly();
     }
@@ -61,7 +62,7 @@ public final class Txn<T> implements AutoCloseable {
     }
     final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
     final Pointer txnParentPtr = parent == null ? null : parent.ptr;
-    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, flagSet.getMask(), txnPtr));
+    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, this.flags.getMask(), txnPtr));
     ptr = txnPtr.getPointer(0);
 
     state = READY;
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index 6320eece..8e6310b3 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.EnumSet;
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 1ea44b7e..66e89ccb 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
new file mode 100644
index 00000000..da9341c6
--- /dev/null
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.TestUtils.bb;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import org.hamcrest.Matchers;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+public class DbiBuilderTest {
+
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
+  private Env<ByteBuffer> env;
+
+  @After
+  public void after() {
+    env.close();
+  }
+
+  @Before
+  public void before() throws IOException {
+    System.out.println("before");
+    final File path = tmp.newFile();
+    env = create()
+        .setMapSize(MEBIBYTES.toBytes(64))
+        .setMaxReaders(2)
+        .setMaxDbs(2)
+        .open(path, MDB_NOSUBDIR);
+  }
+
+  @Test
+  public void unnamed() {
+    final Dbi<ByteBuffer> dbi = env.buildDbi()
+        .withoutDbName()
+        .withDefaultComparator()
+        .withDbiFlags(DbiFlags.MDB_CREATE)
+        .open();
+
+    assertThat(env.getDbiNames().size(), Matchers.is(0));
+
+    assertPutAndGet(dbi);
+  }
+
+
+  @Test
+  public void named() {
+    final Dbi<ByteBuffer> dbi = env.buildDbi()
+        .withDbName("foo")
+        .withDefaultComparator()
+        .withDbiFlags(DbiFlags.MDB_CREATE)
+        .open();
+
+    assertPutAndGet(dbi);
+
+    assertThat(env.getDbiNames().size(), Matchers.is(1));
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8), Matchers.is("foo"));
+  }
+
+  private void assertPutAndGet(Dbi<ByteBuffer> dbi) {
+    try (Txn<ByteBuffer> writeTxn = env.txnWrite()) {
+      dbi.put(writeTxn, bb(123), bb(123_000));
+      writeTxn.commit();
+    }
+
+    try (Txn<ByteBuffer> readTxn = env.txnRead()) {
+      final ByteBuffer byteBuffer = dbi.get(readTxn, bb(123));
+      final int val = byteBuffer.getInt();
+      assertThat(val, Matchers.is(123_000));
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index 323a2ed4..457e4718 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index ed6a0fea..2ecce3c2 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 8cf1efe0..3e402732 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
diff --git a/src/test/java/org/lmdbjava/TestDbiBuilder.java b/src/test/java/org/lmdbjava/TestDbiBuilder.java
deleted file mode 100644
index 7a1e8947..00000000
--- a/src/test/java/org/lmdbjava/TestDbiBuilder.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package org.lmdbjava;
-
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.lmdbjava.Env.create;
-import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
-import static org.lmdbjava.TestUtils.bb;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.nio.charset.StandardCharsets;
-import org.hamcrest.Matchers;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-
-public class TestDbiBuilder {
-
-    @Rule
-    public final TemporaryFolder tmp = new TemporaryFolder();
-    private Env<ByteBuffer> env;
-
-    @After
-    public void after() {
-        env.close();
-    }
-
-    @Before
-    public void before() throws IOException {
-        System.out.println("before");
-        final File path = tmp.newFile();
-        env =
-                create()
-                        .setMapSize(MEBIBYTES.toBytes(64))
-                        .setMaxReaders(2)
-                        .setMaxDbs(2)
-                        .open(path, MDB_NOSUBDIR);
-    }
-
-    @Test
-    public void unnamed() {
-        final Dbi<ByteBuffer> dbi = env.buildDbi()
-                .withoutDbName()
-                .withDefaultComparator()
-                .withDbiFlags(DbiFlags.MDB_CREATE)
-                .open();
-
-        assertThat(env.getDbiNames().size(), Matchers.is(0));
-
-        assertPutAndGet(dbi);
-    }
-
-
-    @Test
-    public void named() {
-        final Dbi<ByteBuffer> dbi = env.buildDbi()
-                .withDbName("foo")
-                .withDefaultComparator()
-                .withDbiFlags(DbiFlags.MDB_CREATE)
-                .open();
-
-        assertPutAndGet(dbi);
-
-        assertThat(env.getDbiNames().size(), Matchers.is(1));
-        assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8), Matchers.is("foo"));
-    }
-
-    private void assertPutAndGet(Dbi<ByteBuffer> dbi) {
-        try (Txn<ByteBuffer> writeTxn = env.txnWrite()) {
-            dbi.put(writeTxn, bb(123), bb(123_000));
-            writeTxn.commit();
-        }
-
-        try (Txn<ByteBuffer> readTxn = env.txnRead()) {
-            final ByteBuffer byteBuffer = dbi.get(readTxn, bb(123));
-            final int val = byteBuffer.getInt();
-            assertThat(val, Matchers.is(123_000));
-        }
-    }
-}
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index b526ceeb..2bb3790a 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;

From 1b3f94df197b0889e6612418d3a43a9f496ee452 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Tue, 28 Oct 2025 18:21:58 +0000
Subject: [PATCH 15/90] Change CursorIterableTest to use Parameterized

---
 .../java/org/lmdbjava/CursorIterableTest.java | 205 ++++++++++--------
 src/test/java/org/lmdbjava/TestUtils.java     |   1 +
 2 files changed, 116 insertions(+), 90 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 79a9a34c..bf2eb9eb 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -45,6 +45,7 @@
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.DB_2;
 import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.DB_4;
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
@@ -59,25 +60,83 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.function.Function;
 import org.hamcrest.Matchers;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 import org.lmdbjava.CursorIterable.KeyVal;
 
-/** Test {@link CursorIterable}. */
+/**
+ * Test {@link CursorIterable}.
+ */
+@RunWith(Parameterized.class)
 public final class CursorIterableTest {
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
-  private Dbi<ByteBuffer> dbJavaComparator;
-  private Dbi<ByteBuffer> dbLmdbComparator;
-  private Dbi<ByteBuffer> dbCallbackComparator;
-  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private static final DbiFlagSet dbiFlagSet = MDB_CREATE;
+  private static final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
+
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
+  /** Injected by {@link #data()} with appropriate runner. */
+  @Parameterized.Parameter
+  public DbiFactory dbiFactory;
+
+  @Before
+  public void before() throws IOException {
+    final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+    populateTestDataList();
+  }
+
+  @Parameterized.Parameters(name = "{index}: dbi: {0}")
+  public static Object[] data() {
+    final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_1)
+            .withDefaultComparator()
+            .withDbiFlags(dbiFlagSet)
+            .open());
+    final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_2)
+            .withNativeComparator()
+            .withDbiFlags(dbiFlagSet)
+            .open());
+    final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_3)
+            .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
+            .withDbiFlags(dbiFlagSet)
+            .open());
+    final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_4)
+            .withIteratorComparator(bufferProxy.getComparator(dbiFlagSet))
+            .withDbiFlags(dbiFlagSet)
+            .open());
+    return new Object[] {
+        defaultComparator,
+        nativeComparator,
+        callbackComparator,
+        iteratorComparator};
+  }
+
   @After
   public void after() {
     env.close();
@@ -118,49 +177,8 @@ public void atMostTest() {
     verify(atMost(bb(6)), 2, 4, 6);
   }
 
-  @Before
-  public void before() throws IOException {
-    final File path = tmp.newFile();
-    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env =
-        create(bufferProxy)
-            .setMapSize(KIBIBYTES.toBytes(256))
-            .setMaxReaders(1)
-            .setMaxDbs(3)
-            .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
-    final DbiFlagSet dbiFlagSet = MDB_CREATE;
-    // Use a java comparator for start/stop keys only
-    dbJavaComparator = env.buildDbi()
-        .withDbName(DB_1)
-        .withDefaultComparator()
-        .withDbiFlags(dbiFlagSet)
-        .open();
-    // Use LMDB comparator for start/stop keys
-    dbLmdbComparator = env.buildDbi()
-        .withDbName(DB_2)
-        .withNativeComparator()
-        .withDbiFlags(dbiFlagSet)
-        .open();
-    // Use a java comparator for start/stop keys and as a callback comparaotr
-    dbCallbackComparator = env.buildDbi()
-        .withDbName(DB_3)
-        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
-        .withDbiFlags(dbiFlagSet)
-        .open();
-
-    populateList();
-
-    populateDatabase(dbJavaComparator);
-    populateDatabase(dbLmdbComparator);
-    populateDatabase(dbCallbackComparator);
-
-    dbs.add(dbJavaComparator);
-    dbs.add(dbLmdbComparator);
-    dbs.add(dbCallbackComparator);
-  }
-
-  private void populateList() {
+  private void populateTestDataList() {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
   }
@@ -203,14 +221,6 @@ public void closedTest() {
     verify(closed(bb(1), bb(7)), 2, 4, 6);
   }
 
-  public void closedTest1() {
-    verify(dbLmdbComparator, closed(bb(3), bb(7)), 4, 6);
-  }
-
-  public void closedTest2() {
-    verify(dbJavaComparator, closed(bb(3), bb(7)), 4, 6);
-  }
-
   @Test
   public void greaterThanBackwardTest() {
     verify(greaterThanBackward(bb(6)), 4, 2);
@@ -226,21 +236,19 @@ public void greaterThanTest() {
 
   @Test(expected = IllegalStateException.class)
   public void iterableOnlyReturnedOnce() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
         c.iterator(); // ok
         c.iterator(); // fails
       }
-    }
   }
 
   @Test
   public void iterate() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      populateList();
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
 
         int cnt = 0;
         for (final KeyVal<ByteBuffer> kv : c) {
@@ -248,18 +256,16 @@ public void iterate() {
           assertThat(kv.val().getInt(), is(list.pollFirst()));
         }
       }
-    }
   }
 
   @Test(expected = IllegalStateException.class)
   public void iteratorOnlyReturnedOnce() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
         c.iterator(); // ok
         c.iterator(); // fails
       }
-    }
   }
 
   @Test
@@ -276,10 +282,10 @@ public void lessThanTest() {
 
   @Test(expected = NoSuchElementException.class)
   public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      populateList();
+    final Dbi<ByteBuffer> db = getDb();
+      populateTestDataList();
       try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
         final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
         while (i.hasNext()) {
           final KeyVal<ByteBuffer> kv = i.next();
@@ -289,7 +295,6 @@ public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
         assertThat(i.hasNext(), is(false));
         i.next();
       }
-    }
   }
 
   @Test
@@ -341,8 +346,8 @@ public void openTest() {
 
   @Test
   public void removeOddElements() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      verify(db, all(), 2, 4, 6, 8);
+    final Dbi<ByteBuffer> db = getDb();
+    verify(db, all(), 2, 4, 6, 8);
       int idx = -1;
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
@@ -358,12 +363,11 @@ public void removeOddElements() {
         txn.commit();
       }
       verify(db, all(), 4, 8);
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void nextWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -372,12 +376,11 @@ public void nextWithClosedEnvTest() {
           c.next();
         }
       }
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void removeWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -389,12 +392,11 @@ public void removeWithClosedEnvTest() {
           c.remove();
         }
       }
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void hasNextWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -403,21 +405,20 @@ public void hasNextWithClosedEnvTest() {
           c.hasNext();
         }
       }
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void forEachRemainingWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
           env.close();
-          c.forEachRemaining(keyVal -> {});
+          c.forEachRemaining(keyVal -> {
+          });
         }
       }
-    }
   }
 
 //  @Test
@@ -468,10 +469,8 @@ public void forEachRemainingWithClosedEnvTest() {
 //  }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
-    // Verify using all comparator types
-    for (final Dbi<ByteBuffer> db : dbs) {
-      verify(range, db, expected);
-    }
+    final Dbi<ByteBuffer> db = getDb();
+    verify(range, db, expected);
   }
 
   private void verify(
@@ -479,13 +478,14 @@ private void verify(
     verify(range, dbi, expected);
   }
 
-  private void verify(
-      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
+  private void verify(final KeyRange<ByteBuffer> range,
+                      final Dbi<ByteBuffer> dbi,
+                      final int... expected) {
 
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = kv.key().getInt();
         final int val = kv.val().getInt();
@@ -499,4 +499,29 @@ private void verify(
       assertThat(results.get(idx), is(expected[idx]));
     }
   }
+
+  private Dbi<ByteBuffer> getDb() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+    populateDatabase(dbi);
+    return dbi;
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  private static class DbiFactory {
+    private final String name;
+    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
+
+    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
+      this.name = name;
+      this.factory = factory;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index bc9561ed..c26c1c52 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -33,6 +33,7 @@ final class TestUtils {
   public static final String DB_1 = "test-db-1";
   public static final String DB_2 = "test-db-2";
   public static final String DB_3 = "test-db-3";
+  public static final String DB_4 = "test-db-2";
 
   public static final int POSIX_MODE = 0664;
 

From c0bbe73cb1d128ebb04baf842b9ed98b941a8e7f Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Tue, 28 Oct 2025 21:13:21 +0000
Subject: [PATCH 16/90] Deprecate methods using varargs flags

---
 src/main/java/org/lmdbjava/Cursor.java        | 181 ++++++++++++++++--
 src/main/java/org/lmdbjava/Dbi.java           |  99 +++++++---
 src/main/java/org/lmdbjava/DbiBuilder.java    |  14 +-
 src/main/java/org/lmdbjava/DbiFlagSet.java    |   2 +
 src/main/java/org/lmdbjava/Env.java           | 179 +++++++++--------
 src/main/java/org/lmdbjava/EnvFlagSet.java    |   2 +
 src/main/java/org/lmdbjava/FlagSet.java       |  33 ++++
 src/main/java/org/lmdbjava/MaskedFlag.java    |   4 +
 src/main/java/org/lmdbjava/PutFlagSet.java    |   2 +
 .../org/lmdbjava/CursorIterablePerfTest.java  |   6 +-
 10 files changed, 392 insertions(+), 130 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 6d31a3d6..c1ac7374 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -20,8 +20,6 @@
 import static org.lmdbjava.Dbi.KeyNotFoundException.MDB_NOTFOUND;
 import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.Library.LIB;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
 import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
@@ -97,23 +95,49 @@ public long count() {
     checkRc(LIB.mdb_cursor_count(ptrCursor, longByReference));
     return longByReference.longValue();
   }
+  /**
+   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}.
+   * <hr>
+   * Delete current key/data pair.
+   *
+   * <p>This function deletes the key/data pair to which the cursor refers.
+   *
+   * @param flags flags (either null or {@link PutFlags#MDB_NODUPDATA}
+   */
+  @Deprecated
+  public void delete(final PutFlags... flags) {
+    delete(PutFlagSet.of(flags));
+  }
+
+  /**
+   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}.
+   * <hr>
+   * Delete current key/data pair.
+   *
+   * <p>This function deletes the key/data pair to which the cursor refers.
+   */
+  public void delete() {
+    delete(PutFlagSet.EMPTY);
+  }
 
   /**
    * Delete current key/data pair.
    *
    * <p>This function deletes the key/data pair to which the cursor refers.
    *
-   * @param f flags (either null or {@link PutFlags#MDB_NODUPDATA}
+   * @param flags flags (either null or {@link PutFlags#MDB_NODUPDATA}
    */
-  public void delete(final PutFlags... f) {
+  public void delete(final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int flags = mask(f);
-    checkRc(LIB.mdb_cursor_del(ptrCursor, flags));
+    final PutFlagSet putFlagSet = flags != null
+        ? flags
+        : PutFlagSet.EMPTY;
+    checkRc(LIB.mdb_cursor_del(ptrCursor, putFlagSet.getMask()));
   }
 
   /**
@@ -235,17 +259,49 @@ public boolean prev() {
   }
 
   /**
+   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead.
+   * <hr>
    * Store by cursor.
    *
    * <p>This function stores key/data pairs into the database.
    *
    * @param key key to store
    * @param val data to store
-   * @param op options for this operation
+   * @param flags options for this operation
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   */
+  @Deprecated
+  public boolean put(final T key, final T val, final PutFlags... flags) {
+    return put(key, val, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Store by cursor.
+   *
+   * <p>This function stores key/data pairs into the database.
+   *
+   * @param key key to store
+   * @param val data to store
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   */
+  public boolean put(final T key, final T val) {
+    return put(key, val, PutFlagSet.EMPTY);
+  }
+
+  /**
+   * Store by cursor.
+   *
+   * <p>This function stores key/data pairs into the database.
+   *
+   * @param key key to store
+   * @param val data to store
+   * @param flags options for this operation
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
    *     key/value existed already.
    */
-  public boolean put(final T key, final T val, final PutFlags... op) {
+  public boolean put(final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       requireNonNull(val);
@@ -256,12 +312,14 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(val);
-    final int mask = mask(op);
-    final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), mask);
+    final PutFlagSet putFlagSet = flags != null
+        ? flags
+        : PutFlagSet.EMPTY;
+    final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), putFlagSet.getMask());
     if (rc == MDB_KEYEXIST) {
-      if (isSet(mask, MDB_NOOVERWRITE)) {
+      if (putFlagSet.isSet(MDB_NOOVERWRITE)) {
         kv.valOut(); // marked as in,out in LMDB C docs
-      } else if (!isSet(mask, MDB_NODUPDATA)) {
+      } else if (!putFlagSet.isSet(MDB_NODUPDATA)) {
         checkRc(rc);
       }
       return false;
@@ -274,6 +332,42 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     return true;
   }
 
+  /**
+   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead.
+   * <hr>
+   * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
+   *
+   * <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
+   * contain fixed-sized values to be inserted. The size of each element is calculated from the
+   * buffer's size divided by the given element count. For example, to populate 10 X 4 byte integers
+   * at once, present a buffer of 40 bytes and specify the element as 10.
+   *
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @param elements number of elements contained in the passed value buffer
+   * @param flags options for operation (must set <code>MDB_MULTIPLE</code>)
+   */
+  @Deprecated
+  public void putMultiple(final T key, final T val, final int elements, final PutFlags... flags) {
+    putMultiple(key, val, elements, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
+   *
+   * <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
+   * contain fixed-sized values to be inserted. The size of each element is calculated from the
+   * buffer's size divided by the given element count. For example, to populate 10 X 4 byte integers
+   * at once, present a buffer of 40 bytes and specify the element as 10.
+   *
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @param elements number of elements contained in the passed value buffer
+   */
+  public void putMultiple(final T key, final T val, final int elements) {
+    putMultiple(key, val, elements, PutFlagSet.EMPTY);
+  }
+
   /**
    * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
    *
@@ -285,9 +379,10 @@ public boolean put(final T key, final T val, final PutFlags... op) {
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
    * @param elements number of elements contained in the passed value buffer
-   * @param op options for operation (must set <code>MDB_MULTIPLE</code>)
+   * @param flags options for operation (must set <code>MDB_MULTIPLE</code>)
+   *              Either a {@link PutFlagSet} or a single {@link PutFlags}.
    */
-  public void putMultiple(final T key, final T val, final int elements, final PutFlags... op) {
+  public void putMultiple(final T key, final T val, final int elements, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
@@ -296,13 +391,15 @@ public void putMultiple(final T key, final T val, final int elements, final PutF
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int mask = mask(op);
-    if (SHOULD_CHECK && !isSet(mask, MDB_MULTIPLE)) {
+    final PutFlagSet putFlagSet = flags != null
+        ? flags
+        : PutFlagSet.EMPTY;
+    if (SHOULD_CHECK && !putFlagSet.isSet(MDB_MULTIPLE)) {
       throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
     }
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer dataPtr = txn.kv().valInMulti(val, elements);
-    final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, mask);
+    final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, putFlagSet.getMask());
     checkRc(rc);
     ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(dataPtr);
@@ -334,6 +431,8 @@ public void renew(final Txn<T> newTxn) {
   }
 
   /**
+   * @deprecated Use {@link Cursor#reserve(Object, int, PutFlagSet)} instead.
+   * <hr>
    * Reserve space for data of the given size, but don't copy the given val. Instead, return a
    * pointer to the reserved space, which the caller can fill in later - before the next update
    * operation or the transaction ends. This saves an extra memcpy if the data is being generated
@@ -344,10 +443,46 @@ public void renew(final Txn<T> newTxn) {
    *
    * @param key key to store in the database (not null)
    * @param size size of the value to be stored in the database (not null)
-   * @param op options for this operation
+   * @param flags options for this operation
+   * @return a buffer that can be used to modify the value
+   */
+  @Deprecated
+  public T reserve(final T key, final int size, final PutFlags... flags) {
+    return reserve(key, size, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Reserve space for data of the given size, but don't copy the given val. Instead, return a
+   * pointer to the reserved space, which the caller can fill in later - before the next update
+   * operation or the transaction ends. This saves an extra {@code memcpy} if the data is being generated
+   * later. LMDB does nothing else with this memory, the caller is expected to modify all the
+   * space requested.
+   *
+   * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
+   *
+   * @param key key to store in the database (not null)
+   * @param size size of the value to be stored in the database (not null)
+   * @return a buffer that can be used to modify the value
+   */
+  public T reserve(final T key, final int size) {
+    return reserve(key, size, PutFlagSet.EMPTY);
+  }
+
+  /**
+   * Reserve space for data of the given size, but don't copy the given val. Instead, return a
+   * pointer to the reserved space, which the caller can fill in later - before the next update
+   * operation or the transaction ends. This saves an extra memcpy if the data is being generated
+   * later. LMDB does nothing else with this memory, the caller is expected to modify all of the
+   * space requested.
+   *
+   * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
+   *
+   * @param key key to store in the database (not null)
+   * @param size size of the value to be stored in the database (not null)
+   * @param flags options for this operation
    * @return a buffer that can be used to modify the value
    */
-  public T reserve(final T key, final int size, final PutFlags... op) {
+  public T reserve(final T key, final int size, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       env.checkNotClosed();
@@ -357,8 +492,12 @@ public T reserve(final T key, final int size, final PutFlags... op) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(size);
-    final int flags = mask(op) | MDB_RESERVE.getMask();
-    checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flags));
+    final PutFlagSet putFlagSet = flags != null
+        ? flags
+        : PutFlagSet.EMPTY;
+    // This is inconsistent with putMultiple which require MDB_MULTIPLE to be in the set.
+    final int flagsMask = putFlagSet.getMaskWith(MDB_RESERVE);
+    checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flagsMask));
     kv.valOut();
     ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(transientVal);
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index c66dc780..bcb1ccfc 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -31,7 +31,7 @@
 import static org.lmdbjava.PutFlags.MDB_RESERVE;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 
-import java.nio.charset.StandardCharsets;
+import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
@@ -261,6 +261,31 @@ public byte[] getName() {
     return name == null ? null : Arrays.copyOf(name, name.length);
   }
 
+  public String getNameAsString() {
+    return getNameAsString(Env.DEFAULT_NAME_CHARSET);
+  }
+
+
+  /**
+   * Obtains the name of this database, using the supplied {@link Charset}.
+   *
+   * @return The name of the database. If this is the unnamed database an empty
+   * string will be returned.
+   * @throws RuntimeException if the name can't be decoded.
+   */
+  public String getNameAsString(final Charset charset) {
+    if (name == null) {
+      return "";
+    } else {
+      // Assume a UTF8 encoding as we don't know, thus swallow if it fails
+      try {
+        return new String(name, requireNonNull(charset));
+      } catch (Exception e) {
+        throw new RuntimeException("Unable to decode database name using charset " + charset);
+      }
+    }
+  }
+
   /**
    * Iterate the database from the first item and forwards.
    *
@@ -345,18 +370,22 @@ public Cursor<T> openCursor(final Txn<T> txn) {
    *
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
-   * @see #put(org.lmdbjava.Txn, java.lang.Object, java.lang.Object, org.lmdbjava.PutFlags...)
+   * @see #put(Txn, Object, Object, PutFlagSet)
    */
   public void put(final T key, final T val) {
     try (Txn<T> txn = env.txnWrite()) {
-      put(txn, key, val);
+      put(txn, key, val, PutFlagSet.EMPTY);
       txn.commit();
     }
   }
 
   /**
+   * @deprecated Use {@link Dbi#put(Txn, Object, Object, PutFlagSet)} instead, with a statically
+   * held {@link PutFlagSet}.
+   * <hr>
+   * <p>
    * Store a key/value pair in the database.
-   *
+   * </p>
    * <p>This function stores key/data pairs in the database. The default behavior is to enter the
    * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
    * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
@@ -368,7 +397,40 @@ public void put(final T key, final T val) {
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
    *     key/value existed already.
    */
+  @Deprecated
   public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags... flags) {
+    return put(txn, key, val, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Store a key/value pair in the database.
+   *
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   * @see #put(Txn, Object, Object, PutFlagSet)
+   */
+  public boolean put(final Txn<T> txn, final T key, final T val) {
+    return put(txn, key, val, PutFlagSet.EMPTY);
+  }
+
+  /**
+   * Store a key/value pair in the database.
+   *
+   * <p>This function stores key/data pairs in the database. The default behavior is to enter the
+   * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
+   * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
+   *
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @param flags Special options for this operation.
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   */
+  public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
@@ -377,14 +439,14 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
       txn.checkReady();
       txn.checkWritesAllowed();
     }
+    final PutFlagSet flagSet = flags != null ? flags : PutFlagSet.empty();
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(val);
-    final int mask = mask(flags);
-    final int rc = LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
+    final int rc = LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flagSet.getMask());
     if (rc == MDB_KEYEXIST) {
-      if (isSet(mask, MDB_NOOVERWRITE)) {
+      if (flagSet.isSet(MDB_NOOVERWRITE)) {
         txn.kv().valOut(); // marked as in,out in LMDB C docs
-      } else if (!isSet(mask, MDB_NODUPDATA)) {
+      } else if (!flagSet.isSet(MDB_NODUPDATA)) {
         checkRc(rc);
       }
       return false;
@@ -461,23 +523,16 @@ private void clean() {
     cleaned = true;
   }
 
-  private String getNameAsString() {
-    if (name == null) {
-      return "";
-    } else {
-      try {
-        // Assume a UTF8 encoding as we don't know, thus swallow if it fails
-        return new String(name, StandardCharsets.UTF_8);
-      } catch (Exception e) {
-        return "?";
-      }
-    }
-  }
-
   @Override
   public String toString() {
+    String name;
+    try {
+      name = getNameAsString();
+    } catch (Exception e) {
+      name = "?";
+    }
     return "Dbi{" +
-            "name='" + getNameAsString() +
+            "name='" + name +
             "', dbiFlagSet=" + dbiFlagSet +
             '}';
   }
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index dcf34d0a..2b4e6ad8 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -28,6 +28,7 @@
  */
 public class DbiBuilder<T> {
 
+
   private final Env<T> env;
   private final BufferProxy<T> proxy;
   private final boolean readOnly;
@@ -56,7 +57,7 @@ public DbiBuilderStage2<T> withDbName(final String name) {
     // Null name is allowed so no null check
     final byte[] nameBytes = name == null
         ? null
-        : name.getBytes(StandardCharsets.UTF_8);
+        : name.getBytes(Env.DEFAULT_NAME_CHARSET);
     return withDbName(nameBytes);
   }
 
@@ -252,7 +253,7 @@ private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
      * Clears all flags currently set by previous calls to
      * {@link DbiBuilderStage3#withDbiFlags(Collection)},
      * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlags to open the database with.
@@ -277,7 +278,7 @@ public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
      * Clears all flags currently set by previous calls to
      * {@link DbiBuilderStage3#withDbiFlags(Collection)},
      * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlags to open the database with.
@@ -302,7 +303,7 @@ public DbiBuilderStage3<T> withDbiFlags(final DbiFlags... dbiFlags) {
      * Clears all flags currently set by previous calls to
      * {@link DbiBuilderStage3#withDbiFlags(Collection)},
      * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlagSet to open the database with.
@@ -320,12 +321,12 @@ public DbiBuilderStage3<T> withDbiFlags(final DbiFlagSet dbiFlagSet) {
      * Adds a dbiFlag to those flags already added to this builder by
      * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)},
      * {@link DbiBuilderStage3#withDbiFlags(Collection)}
-     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlag to open the database with. A null value is a no-op.
      * @return this builder instance.
      */
-    public DbiBuilderStage3<T> setDbiFlag(final DbiFlags dbiFlag) {
+    public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
       this.flagSetBuilder.setFlag(dbiFlag);
       return this;
     }
@@ -409,7 +410,6 @@ private Dbi<T> open(final Txn<T> txn,
       final ComparatorType comparatorType = dbiBuilderStage2.comparatorType;
       final Comparator<T> comparator = getComparator(dbiBuilder, comparatorType, dbiFlagSet);
       final boolean useNativeCallback = comparatorType == ComparatorType.CALLBACK;
-
       return new Dbi<>(
           dbiBuilder.env,
           txn,
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 28f5e4f1..5edf10c7 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -21,6 +21,8 @@
 
 public interface DbiFlagSet extends FlagSet<DbiFlags> {
 
+  DbiFlagSet EMPTY = DbiFlagSetImpl.EMPTY;
+
   static DbiFlagSet empty() {
     return DbiFlagSetImpl.EMPTY;
   }
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index efc4e240..55c88ec1 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -29,6 +29,8 @@
 
 import java.io.File;
 import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
@@ -46,8 +48,11 @@
  */
 public final class Env<T> implements AutoCloseable {
 
-  /** Java system property name that can be set to disable optional checks. */
+  /**
+   * Java system property name that can be set to disable optional checks.
+   */
   public static final String DISABLE_CHECKS_PROP = "lmdbjava.disable.checks";
+  public static final Charset DEFAULT_NAME_CHARSET = StandardCharsets.UTF_8;
 
   /**
    * Indicates whether optional checks should be applied in LmdbJava. Optional checks are only
@@ -88,7 +93,7 @@ public static Builder<ByteBuffer> create() {
   /**
    * Create an {@link Env} using the passed {@link BufferProxy}.
    *
-   * @param <T> buffer type
+   * @param <T>   buffer type
    * @param proxy the proxy to use (required)
    * @return the environment (never null)
    */
@@ -100,13 +105,15 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
    * Opens an environment with a single default database in 0664 mode using the {@link
    * ByteBufferProxy#PROXY_OPTIMAL}.
    *
-   * @param path file system destination
-   * @param size size in megabytes
+   * @param path  file system destination
+   * @param size  size in megabytes
    * @param flags the flags for this new environment
    * @return env the environment (never null)
    */
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
-    return new Builder<>(PROXY_OPTIMAL).setMapSize(size * 1_024L * 1_024L).open(path, flags);
+    return new Builder<>(PROXY_OPTIMAL)
+        .setMapSize(size * 1_024L * 1_024L)
+        .open(path, flags);
   }
 
   /**
@@ -159,7 +166,7 @@ public void copy(final File path) {
    * transactions, because it employs a read-only transaction. See long-lived transactions under
    * "Caveats" in the LMDB native documentation.
    *
-   * @param path writable destination path as described above
+   * @param path  writable destination path as described above
    * @param flags special options for this copy
    */
   public void copy(final File path, final CopyFlagSet flags) {
@@ -183,7 +190,7 @@ public List<byte[]> getDbiNames() {
     final List<byte[]> result = new ArrayList<>();
     final Dbi<T> names = openDbi((byte[]) null);
     try (Txn<T> txn = txnRead();
-        Cursor<T> cursor = names.openCursor(txn)) {
+         Cursor<T> cursor = names.openCursor(txn)) {
       if (!cursor.first()) {
         return Collections.emptyList();
       }
@@ -263,6 +270,7 @@ public boolean isReadOnly() {
   /**
    * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set)
    * a {@link Dbi} using a builder.
+   *
    * @return A new builder instance for creating/opening a {@link Dbi}.
    */
   public DbiBuilder<T> buildDbi() {
@@ -270,13 +278,12 @@ public DbiBuilder<T> buildDbi() {
   }
 
   /**
+   * @param name  name of the database (or null if no name is required)
+   * @param flags to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
    * Comparator} that is not invoked from native code.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
@@ -285,6 +292,11 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   }
 
   /**
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator for cursor start/stop key comparisons. If null, LMDB's
+   *                   comparator will be used.
+   * @param flags      to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
@@ -293,88 +305,83 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
    * LMDB uses for its insertion order (for the type of data that will be stored in the database),
    * or you fully understand the implications of them behaving differently. LMDB's comparator is
    * unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is used.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator for cursor start/stop key comparisons. If null, LMDB's
-   *     comparator will be used.
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
-  public Dbi<T> openDbi(
-      final String name, final Comparator<T> comparator, final DbiFlags... flags) {
+  public Dbi<T> openDbi(final String name,
+                        final Comparator<T> comparator,
+                        final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
     return openDbi(nameBytes, comparator, false, flags);
   }
 
   /**
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator for cursor start/stop key comparisons and optionally for
+   *                   LMDB to call back to. If null, LMDB's comparator will be used.
+   * @param nativeCb   whether LMDB native code calls back to the Java comparator
+   * @param flags      to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop
    * keys as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to
    * determine insertion/iteration order. Calling back to a java comparator may significantly impact
    * performance.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator for cursor start/stop key comparisons and optionally for
-   *     LMDB to call back to. If null, LMDB's comparator will be used.
-   * @param nativeCb whether LMDB native code calls back to the Java comparator
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
-  public Dbi<T> openDbi(
-      final String name,
-      final Comparator<T> comparator,
-      final boolean nativeCb,
-      final DbiFlags... flags) {
+  public Dbi<T> openDbi(final String name,
+                        final Comparator<T> comparator,
+                        final boolean nativeCb,
+                        final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
     return openDbi(nameBytes, comparator, nativeCb, flags);
   }
 
   /**
+   * @param name  name of the database (or null if no name is required)
+   * @param flags to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
+   * <hr>
    * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
    * invoked from native code.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
-  public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
+  public Dbi<T> openDbi(final byte[] name,
+                        final DbiFlags... flags) {
     return openDbi(name, null, false, flags);
   }
 
   /**
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param flags      to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
+   * <hr>
    * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that is not
    * invoked from native code.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
-  public Dbi<T> openDbi(
-      final byte[] name, final Comparator<T> comparator, final DbiFlags... flags) {
+  public Dbi<T> openDbi(final byte[] name,
+                        final Comparator<T> comparator,
+                        final DbiFlags... flags) {
     return openDbi(name, comparator, false, flags);
   }
 
   /**
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param nativeCb   whether native code calls back to the Java comparator
+   * @param flags      to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
+   * <hr>
    * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that may be
    * invoked from native code if specified.
    *
    * <p>This method will automatically commit the private transaction before returning. This ensures
    * the <code>Dbi</code> is available in the <code>Env</code>.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb whether native code calls back to the Java comparator
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -390,6 +397,12 @@ public Dbi<T> openDbi(
   }
 
   /**
+   * @param txn        transaction to use (required; not closed)
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param nativeCb   whether native LMDB code should call back to the Java comparator
+   * @param flags      to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
    * Open the {@link Dbi} using the passed {@link Txn}.
    *
@@ -409,13 +422,6 @@ public Dbi<T> openDbi(
    *
    * <p>This method (and its overloaded convenience variants) must not be called from concurrent
    * threads.
-   *
-   * @param txn transaction to use (required; not closed)
-   * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb whether native LMDB code should call back to the Java comparator
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -455,7 +461,7 @@ public Stat stat() {
    * Flushes the data buffers to disk.
    *
    * @param force force a synchronous flush (otherwise if the environment has the MDB_NOSYNC flag
-   *     set the flushes will be omitted, and with MDB_MAPASYNC they will be asynchronous)
+   *              set the flushes will be omitted, and with MDB_MAPASYNC they will be asynchronous)
    */
   public void sync(final boolean force) {
     if (closed) {
@@ -466,13 +472,12 @@ public void sync(final boolean force) {
   }
 
   /**
-   * @deprecated Instead use {@link Env#txn(Txn, TxnFlagSet)}
-   *
-   * Obtain a transaction with the requested parent and flags.
-   *
    * @param parent parent transaction (may be null if no parent)
-   * @param flags applicable flags (eg for a reusable, read-only transaction)
+   * @param flags  applicable flags (eg for a reusable, read-only transaction)
    * @return a transaction (never null)
+   * @deprecated Instead use {@link Env#txn(Txn, TxnFlagSet)}
+   * <p>
+   * Obtain a transaction with the requested parent and flags.
    */
   @Deprecated
   public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
@@ -495,7 +500,7 @@ public Txn<T> txn(final Txn<T> parent) {
    * Obtain a transaction with the requested parent and flags.
    *
    * @param parent parent transaction (may be null if no parent)
-   * @param flag applicable flag (eg for a reusable, read-only transaction)
+   * @param flag   applicable flag (eg for a reusable, read-only transaction)
    * @return a transaction (never null)
    */
   public Txn<T> txn(final Txn<T> parent, final TxnFlags flag) {
@@ -507,9 +512,9 @@ public Txn<T> txn(final Txn<T> parent, final TxnFlags flag) {
    * Obtain a transaction with the requested parent and flags.
    *
    * @param parent parent transaction (may be null if no parent)
-   * @param flags applicable flags (e.g. for a reusable, read-only transaction).
-   *              If the set of flags is used frequently it is recommended to hold
-   *              a static instance of the {@link TxnFlagSet} for re-use.
+   * @param flags  applicable flags (e.g. for a reusable, read-only transaction).
+   *               If the set of flags is used frequently it is recommended to hold
+   *               a static instance of the {@link TxnFlagSet} for re-use.
    * @return a transaction (never null)
    */
   public Txn<T> txn(final Txn<T> parent, final TxnFlagSet flags) {
@@ -581,23 +586,31 @@ public int readerCheck() {
     return resultPtr.intValue();
   }
 
-  /** Object has already been closed and the operation is therefore prohibited. */
+  /**
+   * Object has already been closed and the operation is therefore prohibited.
+   */
   public static final class AlreadyClosedException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /** Creates a new instance. */
+    /**
+     * Creates a new instance.
+     */
     public AlreadyClosedException() {
       super("Environment has already been closed");
     }
   }
 
-  /** Object has already been opened and the operation is therefore prohibited. */
+  /**
+   * Object has already been opened and the operation is therefore prohibited.
+   */
   public static final class AlreadyOpenException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /** Creates a new instance. */
+    /**
+     * Creates a new instance.
+     */
     public AlreadyOpenException() {
       super("Environment has already been opened");
     }
@@ -625,8 +638,8 @@ public static final class Builder<T> {
     /**
      * Opens the environment.
      *
-     * @param path file system destination
-     * @param mode Unix permissions to set on created files and semaphores
+     * @param path  file system destination
+     * @param mode  Unix permissions to set on created files and semaphores
      * @param flags the flags for this new environment
      * @return an environment ready for use
      */
@@ -657,7 +670,7 @@ public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
     /**
      * Opens the environment with 0664 mode.
      *
-     * @param path file system destination
+     * @param path  file system destination
      * @param flags the flags for this new environment
      * @return an environment ready for use
      */
@@ -711,7 +724,9 @@ public Builder<T> setMaxReaders(final int readers) {
     }
   }
 
-  /** File is not a valid LMDB file. */
+  /**
+   * File is not a valid LMDB file.
+   */
   public static final class FileInvalidException extends LmdbNativeException {
 
     static final int MDB_INVALID = -30_793;
@@ -722,7 +737,9 @@ public static final class FileInvalidException extends LmdbNativeException {
     }
   }
 
-  /** The specified copy destination is invalid. */
+  /**
+   * The specified copy destination is invalid.
+   */
   public static final class InvalidCopyDestination extends LmdbException {
 
     private static final long serialVersionUID = 1L;
@@ -737,7 +754,9 @@ public InvalidCopyDestination(final String message) {
     }
   }
 
-  /** Environment mapsize reached. */
+  /**
+   * Environment mapsize reached.
+   */
   public static final class MapFullException extends LmdbNativeException {
 
     static final int MDB_MAP_FULL = -30_792;
@@ -748,7 +767,9 @@ public static final class MapFullException extends LmdbNativeException {
     }
   }
 
-  /** Environment maxreaders reached. */
+  /**
+   * Environment maxreaders reached.
+   */
   public static final class ReadersFullException extends LmdbNativeException {
 
     static final int MDB_READERS_FULL = -30_790;
@@ -759,7 +780,9 @@ public static final class ReadersFullException extends LmdbNativeException {
     }
   }
 
-  /** Environment version mismatch. */
+  /**
+   * Environment version mismatch.
+   */
   public static final class VersionMismatchException extends LmdbNativeException {
 
     static final int MDB_VERSION_MISMATCH = -30_794;
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index f1bab2d0..a3c8d1fa 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -21,6 +21,8 @@
 
 public interface EnvFlagSet extends FlagSet<EnvFlags> {
 
+  EnvFlagSet EMPTY = EnvFlagSetImpl.EMPTY;
+
   static EnvFlagSet empty() {
     return EnvFlagSetImpl.EMPTY;
   }
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index 89b955a0..668e33ba 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -28,24 +28,57 @@
  */
 public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
 
+  /**
+   * @return The combined mask for this flagSet.
+   */
   int getMask();
 
+  /**
+   * @return The result of combining the mask of this {@link FlagSet}
+   * with the mask of the other {@link FlagSet}.
+   */
+  default int getMaskWith(final FlagSet<T> other) {
+    if (other != null) {
+      return MaskedFlag.mask(getMask(), other.getMask());
+    } else {
+      return getMask();
+    }
+  }
+
+  /**
+   * @return The set of flags in this {@link FlagSet}.
+   */
   Set<T> getFlags();
 
+  /**
+   * @return True if flag is non-null and included in this {@link FlagSet}.
+   */
   boolean isSet(T flag);
 
+  /**
+   * @return The size of this {@link FlagSet}
+   */
   default int size() {
     return getFlags().size();
   }
 
+  /**
+   * @return True if this {@link FlagSet} is empty.
+   */
   default boolean isEmpty() {
     return getFlags().isEmpty();
   }
 
+  /**
+   * @return The {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
+   */
   default Iterator<T> iterator() {
     return getFlags().iterator();
   }
 
+  /**
+   * Convert this {@link FlagSet} to a string for use in toString methods.
+   */
   static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
     Objects.requireNonNull(flagSet);
     final String flagsStr = flagSet.getFlags()
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index f2f08274..271bb122 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -59,6 +59,10 @@ static <M extends MaskedFlag> int mask(final M... flags) {
     }
   }
 
+  static <M extends MaskedFlag> int mask(final int mask1, final int mask2) {
+    return mask1 | mask2;
+  }
+
   static <M extends MaskedFlag> int mask(final Collection<M> flags) {
     if (flags == null || flags.isEmpty()) {
       return EMPTY_MASK;
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 85de014b..9d3a7288 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -21,6 +21,8 @@
 
 public interface PutFlagSet extends FlagSet<PutFlags> {
 
+    PutFlagSet EMPTY = PutFlagSetImpl.EMPTY;
+
     static PutFlagSet empty() {
         return PutFlagSetImpl.EMPTY;
     }
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index e2c54346..c5240215 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -110,6 +110,8 @@ private void populateDatabases(final boolean randomOrder) {
       data = this.data;
     }
 
+    final PutFlagSet noOverwriteAndAppendFlagSet = PutFlagSet.of(MDB_NOOVERWRITE, MDB_APPEND);
+
     for (int round = 0; round < 3; round++) {
       System.out.println("round: " + round + " -----------------------------------------");
 
@@ -122,14 +124,14 @@ private void populateDatabases(final boolean randomOrder) {
           }
         }
 
-        final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+        final String dbName = db.getNameAsString(StandardCharsets.UTF_8);
         final Instant start = Instant.now();
         try (Txn<ByteBuffer> txn = env.txnWrite()) {
           for (final Integer i : data) {
             if (randomOrder) {
               db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE);
             } else {
-              db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE, MDB_APPEND);
+              db.put(txn, bb(i), bb(i + 1), noOverwriteAndAppendFlagSet);
             }
           }
           txn.commit();

From 4fd89fff1755e1572929da3097809dfdad5fa1bb Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 29 Oct 2025 11:32:38 +0000
Subject: [PATCH 17/90] Add int key compare method to (Direct|Byte)BufferProxy

---
 .../java/org/lmdbjava/AbstractFlagSet.java    |  27 +-
 src/main/java/org/lmdbjava/BufferProxy.java   |  27 +-
 .../java/org/lmdbjava/ByteArrayProxy.java     |  31 --
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  10 -
 .../java/org/lmdbjava/ByteBufferProxy.java    | 122 ++++----
 .../java/org/lmdbjava/DirectBufferProxy.java  |  60 ++--
 src/main/java/org/lmdbjava/FlagSet.java       |  39 ++-
 .../org/lmdbjava/ByteBufferProxyTest.java     |  90 +++++-
 .../CursorIterableIntegerKeyTest.java         | 293 +++++++++++-------
 .../java/org/lmdbjava/CursorIterableTest.java |  45 +--
 .../java/org/lmdbjava/DbiBuilderTest.java     |   1 -
 11 files changed, 453 insertions(+), 292 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 5e62b437..25aa328b 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -64,7 +64,6 @@ public boolean isSet(final T flag) {
     // Probably cheaper to compare the masks than to use EnumSet.contains()
     return flag != null
         && MaskedFlag.isSet(mask, flag);
-
   }
 
   /**
@@ -93,9 +92,7 @@ public Iterator<T> iterator() {
 
   @Override
   public boolean equals(Object object) {
-    if (this == object) return true;
-//    if (object == null || getClass() != object.getClass()) return false;
-    return FlagSet.equals(this, (FlagSet<?>) object);
+    return FlagSet.equals(this, object);
   }
 
   @Override
@@ -141,6 +138,15 @@ public boolean isSet(final T flag) {
       return this.flag == flag;
     }
 
+    @Override
+    public boolean areAnySet(FlagSet<T> flags) {
+      if (flags == null) {
+        return false;
+      } else {
+        return flags.isSet(this.flag);
+      }
+    }
+
     @Override
     public int size() {
       return 1;
@@ -167,9 +173,7 @@ public String toString() {
 
     @Override
     public boolean equals(Object object) {
-      if (this == object) return true;
-//      if (object == null || getClass() != object.getClass()) return false;
-      return FlagSet.equals(this, (FlagSet<?>) object);
+      return FlagSet.equals(this, object);
     }
 
     @Override
@@ -205,6 +209,11 @@ public boolean isSet(final T flag) {
       return false;
     }
 
+    @Override
+    public boolean areAnySet(final FlagSet<T> flags) {
+      return false;
+    }
+
     @Override
     public int size() {
       return 0;
@@ -227,9 +236,7 @@ public String toString() {
 
     @Override
     public boolean equals(Object object) {
-      if (this == object) return true;
-//      if (object == null || getClass() != object.getClass()) return false;
-      return FlagSet.equals(this, (FlagSet<?>) object);
+      return FlagSet.equals(this, object);
     }
 
     @Override
diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index 60272209..af0c7f06 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -40,6 +40,11 @@ public abstract class BufferProxy<T> {
   /** Offset from a pointer of the <code>MDB_val.mv_size</code> field. */
   protected static final int STRUCT_FIELD_OFFSET_SIZE = 0;
 
+  /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
+  protected static final DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(
+      DbiFlags.MDB_INTEGERKEY,
+      DbiFlags.MDB_INTEGERDUP);
+
   /** Explicitly-defined default constructor to avoid warnings. */
   protected BufferProxy() {}
 
@@ -88,28 +93,6 @@ public Comparator<T> getComparator() {
     return getComparator(DbiFlagSet.empty());
   }
 
-//  /**
-//   * Get a suitable default {@link Comparator} to compare numeric key values as signed.
-//   *
-//   * <p>Note: LMDB's default comparator is unsigned so if this is used only for the {@link
-//   * CursorIterable} start/stop key comparisons then its behaviour will differ from the iteration
-//   * order. Use with caution.
-//   *
-//   * @return a comparator that can be used (never null)
-//   */
-//  public abstract Comparator<T> getSignedComparator();
-//
-//  /**
-//   * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
-//   * <p>
-//   * This should match the behaviour of the LMDB's mdb_cmp comparator as it may be used for
-//   * {@link CursorIterable} start/stop keys comparisons, which must match LMDB's insertion order.
-//   * </p>
-//   *
-//   * @return a comparator that can be used (never null)
-//   */
-//  public abstract Comparator<T> getUnsignedComparator(final DbiFlagSet dbiFlagSet);
-
   /**
    * Called when the <code>MDB_val</code> should be set to reflect the passed buffer. This buffer
    * will have been created by end users, not {@link #allocate()}.
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 5231ed51..d7c23919 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -36,7 +36,6 @@ public final class ByteArrayProxy extends BufferProxy<byte[]> {
 
   private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  private static final Comparator<byte[]> signedComparator = ByteArrayProxy::compareArraysSigned;
   private static final Comparator<byte[]> unsignedComparator = ByteArrayProxy::compareArrays;
 
   private ByteArrayProxy() {}
@@ -68,26 +67,6 @@ public static int compareArrays(final byte[] o1, final byte[] o2) {
     return o1.length - o2.length;
   }
 
-  /**
-   * Compare two byte arrays.
-   *
-   * @param b1 left operand (required)
-   * @param b2 right operand (required)
-   * @return as specified by {@link Comparable} interface
-   */
-  public static int compareArraysSigned(final byte[] b1, final byte[] b2) {
-    requireNonNull(b1);
-    requireNonNull(b2);
-
-    if (b1 == b2) return 0;
-
-    for (int i = 0; i < min(b1.length, b2.length); ++i) {
-      if (b1[i] != b2[i]) return b1[i] - b2[i];
-    }
-
-    return b1.length - b2.length;
-  }
-
   @Override
   protected byte[] allocate() {
     return new byte[0];
@@ -108,16 +87,6 @@ public Comparator<byte[]> getComparator(final DbiFlagSet dbiFlagSet) {
     return unsignedComparator;
   }
 
-  //  @Override
-//  public Comparator<byte[]> getSignedComparator() {
-//    return signedComparator;
-//  }
-//
-//  @Override
-//  public Comparator<byte[]> getUnsignedComparator() {
-//    return unsignedComparator;
-//  }
-
   @Override
   protected Pointer in(final byte[] buffer, final Pointer ptr) {
     final Pointer pointer = MEM_MGR.allocateDirect(buffer.length);
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index fc14b58f..319256fb 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -118,16 +118,6 @@ public Comparator<ByteBuf> getComparator(final DbiFlagSet dbiFlagSet) {
     return comparator;
   }
 
-  //  @Override
-//  public Comparator<ByteBuf> getSignedComparator() {
-//    return comparator;
-//  }
-//
-//  @Override
-//  public Comparator<ByteBuf> getUnsignedComparator() {
-//    return comparator;
-//  }
-
   @Override
   protected void deallocate(final ByteBuf buff) {
     buff.release();
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 4875572b..ca4deba3 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -54,15 +54,19 @@ public final class ByteBufferProxy {
    */
   public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
 
-  /** The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null. */
+  /**
+   * The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null.
+   */
   public static final BufferProxy<ByteBuffer> PROXY_SAFE;
 
+
   static {
     PROXY_SAFE = new ReflectiveProxy();
     PROXY_OPTIMAL = getProxyOptimal();
   }
 
-  private ByteBufferProxy() {}
+  private ByteBufferProxy() {
+  }
 
   private static BufferProxy<ByteBuffer> getProxyOptimal() {
     try {
@@ -72,17 +76,25 @@ private static BufferProxy<ByteBuffer> getProxyOptimal() {
     }
   }
 
-  /** The buffer must be a direct buffer (not heap allocated). */
+  /**
+   * The buffer must be a direct buffer (not heap allocated).
+   */
   public static final class BufferMustBeDirectException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /** Creates a new instance. */
+    /**
+     * Creates a new instance.
+     */
     public BufferMustBeDirectException() {
       super("The buffer must be a direct buffer (not heap allocated");
     }
   }
 
+
+  // --------------------------------------------------------------------------------
+
+
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -92,16 +104,6 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
     protected static final String FIELD_NAME_ADDRESS = "address";
     protected static final String FIELD_NAME_CAPACITY = "capacity";
 
-    private static final Comparator<ByteBuffer> signedComparator =
-        (o1, o2) -> {
-          requireNonNull(o1);
-          requireNonNull(o2);
-
-          return o1.compareTo(o2);
-        };
-    private static final Comparator<ByteBuffer> unsignedComparator =
-        AbstractByteBufferProxy::compareBuff;
-
     /**
      * A thread-safe pool for a given length. If the buffer found is valid (ie not of a negative
      * length) then that buffer is used. If no valid buffer is found, a new buffer is created.
@@ -116,7 +118,7 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
      * @param o2 right operand (required)
      * @return as specified by {@link Comparable} interface
      */
-    public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
+    public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
       if (o1.equals(o2)) {
@@ -148,34 +150,42 @@ public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
       return o1.remaining() - o2.remaining();
     }
 
-//    /**
-//     * Possible compareBuff method specifically for 4/8 byte keys when using MDB_INTEGER_KEY
-//     */
-//    public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
-//      requireNonNull(o1);
-//      requireNonNull(o2);
-//      // Both buffers should be same len
-//      final int len1 = o1.limit();
-//      final int len2 = o2.limit();
-//      if (len1 != len2) {
-//        throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
-//            + ". Lengths must be identical and either 4 or 8 bytes.");
-//      }
-//      final boolean reverse1 = o1.order() == LITTLE_ENDIAN;
-//      final boolean reverse2 = o2.order() == LITTLE_ENDIAN;
-//      if (len1 == 8) {
-//          final long lw = reverse1 ? Long.reverseBytes(o1.getLong()) : o1.getLong();
-//          final long rw = reverse2 ? Long.reverseBytes(o2.getLong()) : o2.getLong();
-//          return Long.compareUnsigned(lw, rw);
-//      } else if (len1 == 4) {
-//        final int lw = reverse1 ? Integer.reverseBytes(o1.getInt()) : o1.getInt();
-//        final int rw = reverse2 ? Integer.reverseBytes(o2.getInt()) : o2.getInt();
-//          return Integer.compareUnsigned(lw, rw);
-//      } else {
-//        throw new RuntimeException("Unexpected length len1: " + len1 + ", len2: " + len2
-//            + ". Lengths must be identical and either 4 or 8 bytes.");
-//      }
-//    }
+    /**
+     * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
+     * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+     * <p>
+     * Both buffer must have 4 or 8 bytes remaining
+     * </p>
+     *
+     * @param o1 left operand (required)
+     * @param o2 right operand (required)
+     * @return as specified by {@link Comparable} interface
+     */
+    public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2) {
+      requireNonNull(o1);
+      requireNonNull(o2);
+      // Both buffers should be same len
+      final int len1 = o1.limit();
+      final int len2 = o2.limit();
+      if (len1 != len2) {
+        throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
+            + ". Lengths must be identical and either 4 or 8 bytes.");
+      }
+      final boolean reverse1 = o1.order() == LITTLE_ENDIAN;
+      final boolean reverse2 = o2.order() == LITTLE_ENDIAN;
+      if (len1 == 8) {
+        final long lw = reverse1 ? Long.reverseBytes(o1.getLong(0)) : o1.getLong(0);
+        final long rw = reverse2 ? Long.reverseBytes(o2.getLong(0)) : o2.getLong(0);
+        return Long.compareUnsigned(lw, rw);
+      } else if (len1 == 4) {
+        final int lw = reverse1 ? Integer.reverseBytes(o1.getInt(0)) : o1.getInt(0);
+        final int rw = reverse2 ? Integer.reverseBytes(o2.getInt(0)) : o2.getInt(0);
+        return Integer.compareUnsigned(lw, rw);
+      } else {
+        throw new RuntimeException("Unexpected length1: " + len1
+            + ". Lengths must be identical and either 4 or 8 bytes.");
+      }
+    }
 
     static Field findField(final Class<?> c, final String name) {
       Class<?> clazz = c;
@@ -211,20 +221,14 @@ protected final ByteBuffer allocate() {
     }
 
     @Override
-    public Comparator<ByteBuffer> getComparator(DbiFlagSet dbiFlagSet) {
-      return unsignedComparator;
+    public Comparator<ByteBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
+      if (dbiFlagSet.areAnySet(INTEGER_KEY_FLAGS)) {
+        return AbstractByteBufferProxy::compareAsIntegerKeys;
+      } else {
+        return AbstractByteBufferProxy::compareLexicographically;
+      }
     }
 
-    //    @Override
-//    public Comparator<ByteBuffer> getSignedComparator() {
-//      return signedComparator;
-//    }
-//
-//    @Override
-//    public Comparator<ByteBuffer> getUnsignedComparator(final DbiFlagSet dbiFlagSet) {
-//      return unsignedComparator;
-//    }
-
     @Override
     protected final void deallocate(final ByteBuffer buff) {
       buff.order(BIG_ENDIAN);
@@ -240,6 +244,10 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
+
+  // --------------------------------------------------------------------------------
+
+
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -284,6 +292,10 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
+
+  // --------------------------------------------------------------------------------
+
+
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 514c04ab..9c90d98b 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -35,14 +35,6 @@
  * <p>This class requires {@link UnsafeAccess} and Agrona must be in the classpath.
  */
 public final class DirectBufferProxy extends BufferProxy<DirectBuffer> {
-  private static final Comparator<DirectBuffer> signedComparator =
-      (o1, o2) -> {
-        requireNonNull(o1);
-        requireNonNull(o2);
-
-        return o1.compareTo(o2);
-      };
-  private static final Comparator<DirectBuffer> unsignedComparator = DirectBufferProxy::compareBuff;
 
   /**
    * The {@link MutableDirectBuffer} proxy. Guaranteed to never be null, although a class
@@ -67,7 +59,7 @@ private DirectBufferProxy() {}
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
-  public static int compareBuff(final DirectBuffer o1, final DirectBuffer o2) {
+  public static int compareLexicographically(final DirectBuffer o1, final DirectBuffer o2) {
     requireNonNull(o1);
     requireNonNull(o2);
     if (o1.equals(o2)) {
@@ -97,6 +89,40 @@ public static int compareBuff(final DirectBuffer o1, final DirectBuffer o2) {
     return o1.capacity() - o2.capacity();
   }
 
+  /**
+   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
+   * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+   * <p>
+   * Both buffer must have 4 or 8 bytes remaining
+   * </p>
+   * @param o1 left operand (required)
+   * @param o2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  public static int compareAsIntegerKeys(final DirectBuffer o1, final DirectBuffer o2) {
+    requireNonNull(o1);
+    requireNonNull(o2);
+    // Both buffers should be same len
+    final int len1 = o1.capacity();
+    final int len2 = o2.capacity();
+    if (len1 != len2) {
+      throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
+          + ". Lengths must be identical and either 4 or 8 bytes.");
+    }
+    if (len1 == 8) {
+      final long lw = o1.getLong(0, BIG_ENDIAN);
+      final long rw = o2.getLong(0, BIG_ENDIAN);
+      return Long.compareUnsigned(lw, rw);
+    } else if (len1 == 4) {
+      final int lw = o1.getInt(0, BIG_ENDIAN);
+      final int rw = o2.getInt(0, BIG_ENDIAN);
+      return Integer.compareUnsigned(lw, rw);
+    } else {
+      throw new RuntimeException("Unexpected length len1: " + len1 + ", len2: " + len2
+          + ". Lengths must be identical and either 4 or 8 bytes.");
+    }
+  }
+
   @Override
   protected DirectBuffer allocate() {
     final ArrayDeque<DirectBuffer> q = BUFFERS.get();
@@ -112,19 +138,13 @@ protected DirectBuffer allocate() {
 
   @Override
   public Comparator<DirectBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
-    return unsignedComparator;
+    if (dbiFlagSet.areAnySet(INTEGER_KEY_FLAGS)) {
+      return DirectBufferProxy::compareAsIntegerKeys;
+    } else {
+      return DirectBufferProxy::compareLexicographically;
+    }
   }
 
-  //  @Override
-//  public Comparator<DirectBuffer> getSignedComparator() {
-//    return signedComparator;
-//  }
-//
-//  @Override
-//  public Comparator<DirectBuffer> getUnsignedComparator(final DbiFlagSet dbiFlagSet) {
-//    return unsignedComparator;
-//  }
-
   @Override
   protected void deallocate(final DirectBuffer buff) {
     final ArrayDeque<DirectBuffer> q = BUFFERS.get();
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index 668e33ba..27513fcd 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -55,6 +55,22 @@ default int getMaskWith(final FlagSet<T> other) {
    */
   boolean isSet(T flag);
 
+  /**
+   * @return True if at least one of flags are included in thie {@link FlagSet}
+   */
+  default boolean areAnySet(final FlagSet<T> flags) {
+    if (flags == null) {
+      return false;
+    } else {
+      for (final T flag : flags) {
+        if (isSet(flag)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   /**
    * @return The size of this {@link FlagSet}
    */
@@ -92,17 +108,20 @@ static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
         '}';
   }
 
-  static boolean equals(final FlagSet<?> flagSet1,
-                        final FlagSet<?> flagSet2) {
-    if (flagSet1 == flagSet2) {
-      return true;
-    } else if (flagSet1 != null && flagSet2 == null) {
-      return false;
-    } else if (flagSet1 == null) {
-      return false;
+  static boolean equals(final FlagSet<?> flagSet,
+                        final Object other) {
+    if (other instanceof FlagSet) {
+      final FlagSet<?> flagSet2 = (FlagSet<?>) other;
+      if (flagSet == flagSet2) {
+        return true;
+      } else if (flagSet == null) {
+        return false;
+      } else {
+        return flagSet.getMask() == flagSet2.getMask()
+            && Objects.equals(flagSet.getFlags(), flagSet2.getFlags());
+      }
     } else {
-      return flagSet1.getMask() == flagSet2.getMask()
-          && Objects.equals(flagSet1.getFlags(), flagSet2.getFlags());
+      return false;
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index b68f39ef..1372b74a 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -40,20 +40,31 @@
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Random;
+import java.util.Set;
 import jnr.ffi.Pointer;
 import jnr.ffi.provider.MemoryManager;
+import org.junit.Assert;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
 import org.lmdbjava.Env.ReadersFullException;
 
-/** Test {@link ByteBufferProxy}. */
+/**
+ * Test {@link ByteBufferProxy}.
+ */
 public final class ByteBufferProxyTest {
 
   static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
 
   @Test(expected = BufferMustBeDirectException.class)
   public void buffersMustBeDirect() throws IOException {
@@ -129,6 +140,81 @@ public void unsafeIsDefault() {
     assertThat(v.getClass().getSimpleName(), startsWith("Unsafe"));
   }
 
+  /**
+   * For 100 rounds of 1,000,000 comparisons
+   * compareAsIntegerKeys: PT0.267813487S
+   * compareLexicographically: PT0.644165235S
+   */
+  @Test
+  public void comparatorPerformance() {
+    final Random random = new Random();
+    final ByteBuffer buffer1 = ByteBuffer.allocateDirect(Long.BYTES);
+    final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
+    buffer1.limit(Long.BYTES);
+    buffer2.limit(Long.BYTES);
+    final long[] values = random.longs(1_000_000).toArray();
+
+    Instant time = Instant.now();
+    int x = 0;
+    for (int rounds = 0; rounds < 100; rounds++) {
+      for (int i = 1; i < values.length; i++) {
+        buffer1.putLong(0, values[i - 1]);
+        buffer2.putLong(0, values[i]);
+        final int result = ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
+        x += result;
+      }
+    }
+    System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()));
+
+    time = Instant.now();
+    x = 0;
+    for (int rounds = 0; rounds < 100; rounds++) {
+      for (int i = 1; i < values.length; i++) {
+        buffer1.putLong(0, values[i - 1]);
+        buffer2.putLong(0, values[i]);
+        final int result = ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
+        x += result;
+      }
+    }
+    System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()));
+  }
+
+  @Test
+  public void verifyComparators() {
+    final Random random = new Random(203948);
+    final ByteBuffer buffer1 = ByteBuffer.allocateDirect(Long.BYTES);
+    final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
+    buffer1.limit(Long.BYTES);
+    buffer2.limit(Long.BYTES);
+    final long[] values = random.longs(10_000_000).toArray();
+
+    final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
+    comparators.put("compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
+    comparators.put("compareLexicographically", ByteBufferProxy.AbstractByteBufferProxy::compareLexicographically);
+
+    final LinkedHashMap<String, Integer> results = new LinkedHashMap<>(comparators.size());
+    final Set<Integer> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      final long val1 = values[i - 1];
+      final long val2 = values[i];
+      buffer1.putLong(0, val1);
+      buffer2.putLong(0, val2);
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach((name, comparator) -> {
+        final int result = comparator.compare(buffer1, buffer2);
+        results.put(name, result);
+        uniqueResults.add(result);
+      });
+
+      if (uniqueResults.size() != 1) {
+        Assert.fail("Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+
   private void checkInOut(final BufferProxy<ByteBuffer> v) {
     // allocate a buffer larger than max key size
     final ByteBuffer b = allocateDirect(1_000);
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index aefe9d43..85c0a567 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -46,6 +46,7 @@
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.DB_2;
 import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.DB_4;
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.bbNative;
@@ -63,26 +64,128 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.function.Function;
 import org.hamcrest.Matchers;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 import org.lmdbjava.CursorIterable.KeyVal;
 
-/** Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that
- * comparators work with native order integer keys. */
+/**
+ * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that
+ * comparators work with native order integer keys.
+ */
+@RunWith(Parameterized.class)
 public final class CursorIterableIntegerKeyTest {
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
-  private Dbi<ByteBuffer> dbJavaComparator;
-  private Dbi<ByteBuffer> dbLmdbComparator;
-  private Dbi<ByteBuffer> dbCallbackComparator;
-  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
+  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
+
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
+
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
+  /**
+   * Injected by {@link #data()} with appropriate runner.
+   */
+  @SuppressWarnings("ClassEscapesDefinedScope")
+  @Parameterized.Parameter
+  public DbiFactory dbiFactory;
+
+  @Parameterized.Parameters(name = "{index}: dbi: {0}")
+  public static Object[] data() {
+    final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_1)
+            .withDefaultComparator()
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_2)
+            .withNativeComparator()
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_3)
+            .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_4)
+            .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    return new Object[]{
+        defaultComparator,
+        nativeComparator,
+        callbackComparator,
+        iteratorComparator};
+  }
+
+  @Before
+  public void before() throws IOException {
+    final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+    populateTestDataList();
+//    final File path = tmp.newFile();
+//    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+//    env =
+//        create(bufferProxy)
+//            .setMapSize(KIBIBYTES.toBytes(256))
+//            .setMaxReaders(1)
+//            .setMaxDbs(3)
+//            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+//
+//    // Use a java comparator for start/stop keys only
+//    DbiFlagSet dbiFlagSet = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
+//
+//    dbJavaComparator = env.buildDbi()
+//        .withDbName(DB_1)
+//        .withIteratorComparator(bufferProxy.getComparator(dbiFlagSet))
+//        .withDbiFlags(dbiFlagSet)
+//        .open();
+//
+//    // Use LMDB comparator for start/stop keys
+//    dbLmdbComparator = env.buildDbi()
+//        .withDbName(DB_2)
+//        .withDefaultComparator()
+//        .withDbiFlags(dbiFlagSet)
+//        .open();
+//
+//    // Use a java comparator for start/stop keys and as a callback comparaotr
+//    dbCallbackComparator = env.buildDbi()
+//        .withDbName(DB_3)
+//        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
+//        .withDbiFlags(dbiFlagSet)
+//        .open();
+//
+//    populateTestDataList();
+//
+//    populateDatabase(dbJavaComparator);
+//    populateDatabase(dbLmdbComparator);
+//    populateDatabase(dbCallbackComparator);
+//
+//    dbs.add(dbJavaComparator);
+//    dbs.add(dbLmdbComparator);
+//    dbs.add(dbCallbackComparator);
+  }
+
   @After
   public void after() {
     env.close();
@@ -123,52 +226,8 @@ public void atMostTest() {
     verify(atMost(bbNative(6)), 2, 4, 6);
   }
 
-  @Before
-  public void before() throws IOException {
-    final File path = tmp.newFile();
-    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env =
-        create(bufferProxy)
-            .setMapSize(KIBIBYTES.toBytes(256))
-            .setMaxReaders(1)
-            .setMaxDbs(3)
-            .open(path, POSIX_MODE, MDB_NOSUBDIR);
-
-    // Use a java comparator for start/stop keys only
-    DbiFlagSet dbiFlagSet = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
-
-    dbJavaComparator = env.buildDbi()
-        .withDbName(DB_1)
-        .withIteratorComparator(bufferProxy.getComparator(dbiFlagSet))
-        .withDbiFlags(dbiFlagSet)
-        .open();
-
-    // Use LMDB comparator for start/stop keys
-    dbLmdbComparator = env.buildDbi()
-        .withDbName(DB_2)
-        .withDefaultComparator()
-        .withDbiFlags(dbiFlagSet)
-        .open();
 
-    // Use a java comparator for start/stop keys and as a callback comparaotr
-    dbCallbackComparator = env.buildDbi()
-        .withDbName(DB_3)
-        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
-        .withDbiFlags(dbiFlagSet)
-        .open();
-
-    populateList();
-
-    populateDatabase(dbJavaComparator);
-    populateDatabase(dbLmdbComparator);
-    populateDatabase(dbCallbackComparator);
-
-    dbs.add(dbJavaComparator);
-    dbs.add(dbLmdbComparator);
-    dbs.add(dbCallbackComparator);
-  }
-
-  private void populateList() {
+  private void populateTestDataList() {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
   }
@@ -226,40 +285,37 @@ public void greaterThanTest() {
 
   @Test(expected = IllegalStateException.class)
   public void iterableOnlyReturnedOnce() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        c.iterator(); // ok
-        c.iterator(); // fails
-      }
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      c.iterator(); // ok
+      c.iterator(); // fails
     }
   }
 
   @Test
   public void iterate() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      populateList();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+    populateTestDataList();
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
 
-        int cnt = 0;
-        for (final KeyVal<ByteBuffer> kv : c) {
-          assertThat(getNativeInt(kv.key()), is(list.pollFirst()));
-          assertThat(kv.val().getInt(), is(list.pollFirst()));
-        }
+      int cnt = 0;
+      for (final KeyVal<ByteBuffer> kv : c) {
+        assertThat(getNativeInt(kv.key()), is(list.pollFirst()));
+        assertThat(kv.val().getInt(), is(list.pollFirst()));
       }
     }
   }
 
   @Test(expected = IllegalStateException.class)
   public void iteratorOnlyReturnedOnce() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
         c.iterator(); // ok
         c.iterator(); // fails
       }
-    }
   }
 
   @Test
@@ -276,19 +332,18 @@ public void lessThanTest() {
 
   @Test(expected = NoSuchElementException.class)
   public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      populateList();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
-        while (i.hasNext()) {
-          final KeyVal<ByteBuffer> kv = i.next();
-          assertThat(TestUtils.getNativeInt(kv.key()), is(list.pollFirst()));
-          assertThat(kv.val().getInt(), is(list.pollFirst()));
-        }
-        assertThat(i.hasNext(), is(false));
-        i.next();
+    populateTestDataList();
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+      while (i.hasNext()) {
+        final KeyVal<ByteBuffer> kv = i.next();
+        assertThat(TestUtils.getNativeInt(kv.key()), is(list.pollFirst()));
+        assertThat(kv.val().getInt(), is(list.pollFirst()));
       }
+      assertThat(i.hasNext(), is(false));
+      i.next();
     }
   }
 
@@ -341,29 +396,28 @@ public void openTest() {
 
   @Test
   public void removeOddElements() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      verify(db, all(), 2, 4, 6, 8);
-      int idx = -1;
-      try (Txn<ByteBuffer> txn = env.txnWrite()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-          while (c.hasNext()) {
-            c.next();
-            idx++;
-            if (idx % 2 == 0) {
-              c.remove();
-            }
+    final Dbi<ByteBuffer> db = getDb();
+    verify(db, all(), 2, 4, 6, 8);
+    int idx = -1;
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+        while (c.hasNext()) {
+          c.next();
+          idx++;
+          if (idx % 2 == 0) {
+            c.remove();
           }
         }
-        txn.commit();
       }
-      verify(db, all(), 4, 8);
+      txn.commit();
     }
+    verify(db, all(), 4, 8);
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void nextWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -372,12 +426,11 @@ public void nextWithClosedEnvTest() {
           c.next();
         }
       }
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void removeWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -389,12 +442,11 @@ public void removeWithClosedEnvTest() {
           c.remove();
         }
       }
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void hasNextWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -403,21 +455,20 @@ public void hasNextWithClosedEnvTest() {
           c.hasNext();
         }
       }
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void forEachRemainingWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
           env.close();
-          c.forEachRemaining(keyVal -> {});
+          c.forEachRemaining(keyVal -> {
+          });
         }
       }
-    }
   }
 
 //  @Test
@@ -469,9 +520,8 @@ public void forEachRemainingWithClosedEnvTest() {
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
     // Verify using all comparator types
-    for (final Dbi<ByteBuffer> db : dbs) {
-      verify(range, db, expected);
-    }
+    final Dbi<ByteBuffer> db = getDb();
+    verify(range, db, expected);
   }
 
   private void verify(
@@ -485,7 +535,7 @@ private void verify(
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = kv.key().order(ByteOrder.nativeOrder()).getInt();
         final int val = kv.val().getInt();
@@ -499,4 +549,29 @@ private void verify(
       assertThat(results.get(idx), is(expected[idx]));
     }
   }
+
+  private Dbi<ByteBuffer> getDb() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+    populateDatabase(dbi);
+    return dbi;
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  private static class DbiFactory {
+    private final String name;
+    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
+
+    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
+      this.name = name;
+      this.factory = factory;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index bf2eb9eb..7bcbd851 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -77,8 +77,8 @@
 @RunWith(Parameterized.class)
 public final class CursorIterableTest {
 
-  private static final DbiFlagSet dbiFlagSet = MDB_CREATE;
-  private static final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+  private static final DbiFlagSet DBI_FLAGS = MDB_CREATE;
+  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
 
   @Rule
   public final TemporaryFolder tmp = new TemporaryFolder();
@@ -87,48 +87,35 @@ public final class CursorIterableTest {
   private Deque<Integer> list;
 
   /** Injected by {@link #data()} with appropriate runner. */
+  @SuppressWarnings("ClassEscapesDefinedScope")
   @Parameterized.Parameter
   public DbiFactory dbiFactory;
 
-  @Before
-  public void before() throws IOException {
-    final File path = tmp.newFile();
-    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env =
-        create(bufferProxy)
-            .setMapSize(KIBIBYTES.toBytes(256))
-            .setMaxReaders(1)
-            .setMaxDbs(3)
-            .open(path, POSIX_MODE, MDB_NOSUBDIR);
-
-    populateTestDataList();
-  }
-
   @Parameterized.Parameters(name = "{index}: dbi: {0}")
   public static Object[] data() {
     final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
         env.buildDbi()
             .withDbName(DB_1)
             .withDefaultComparator()
-            .withDbiFlags(dbiFlagSet)
+            .withDbiFlags(DBI_FLAGS)
             .open());
     final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
         env.buildDbi()
             .withDbName(DB_2)
             .withNativeComparator()
-            .withDbiFlags(dbiFlagSet)
+            .withDbiFlags(DBI_FLAGS)
             .open());
     final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
         env.buildDbi()
             .withDbName(DB_3)
-            .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
-            .withDbiFlags(dbiFlagSet)
+            .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withDbiFlags(DBI_FLAGS)
             .open());
     final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
         env.buildDbi()
             .withDbName(DB_4)
-            .withIteratorComparator(bufferProxy.getComparator(dbiFlagSet))
-            .withDbiFlags(dbiFlagSet)
+            .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withDbiFlags(DBI_FLAGS)
             .open());
     return new Object[] {
         defaultComparator,
@@ -137,6 +124,20 @@ public static Object[] data() {
         iteratorComparator};
   }
 
+  @Before
+  public void before() throws IOException {
+    final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+    populateTestDataList();
+  }
+
   @After
   public void after() {
     env.close();
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index da9341c6..74fbd8f5 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -45,7 +45,6 @@ public void after() {
 
   @Before
   public void before() throws IOException {
-    System.out.println("before");
     final File path = tmp.newFile();
     env = create()
         .setMapSize(MEBIBYTES.toBytes(64))

From 58dcc6e8bb1b393188ef3c1d86015ae15b50e1fb Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 29 Oct 2025 16:09:53 +0000
Subject: [PATCH 18/90] Tidy code

---
 .../java/org/lmdbjava/ByteArrayProxy.java     |   6 +-
 .../java/org/lmdbjava/ByteBufferProxy.java    |   2 +-
 .../CursorIterableIntegerDupTest.java         | 563 ++++++++++++++++++
 .../CursorIterableIntegerKeyTest.java         |  89 ---
 4 files changed, 566 insertions(+), 94 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java

diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index d7c23919..82b7721c 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -36,8 +36,6 @@ public final class ByteArrayProxy extends BufferProxy<byte[]> {
 
   private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  private static final Comparator<byte[]> unsignedComparator = ByteArrayProxy::compareArrays;
-
   private ByteArrayProxy() {}
 
   /**
@@ -47,7 +45,7 @@ private ByteArrayProxy() {}
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
-  public static int compareArrays(final byte[] o1, final byte[] o2) {
+  public static int compareLexicographically(final byte[] o1, final byte[] o2) {
     requireNonNull(o1);
     requireNonNull(o2);
     if (o1 == o2) {
@@ -84,7 +82,7 @@ protected byte[] getBytes(final byte[] buffer) {
 
   @Override
   public Comparator<byte[]> getComparator(final DbiFlagSet dbiFlagSet) {
-    return unsignedComparator;
+    return ByteArrayProxy::compareLexicographically;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index ca4deba3..89931587 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -154,7 +154,7 @@ public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer
      * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
      * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
      * <p>
-     * Both buffer must have 4 or 8 bytes remaining
+     * Both buffers must have 4 or 8 bytes remaining
      * </p>
      *
      * @param o1 left operand (required)
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
new file mode 100644
index 00000000..1acf4328
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -0,0 +1,563 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasSize;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERDUP;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.KeyRange.all;
+import static org.lmdbjava.KeyRange.allBackward;
+import static org.lmdbjava.KeyRange.atLeast;
+import static org.lmdbjava.KeyRange.atLeastBackward;
+import static org.lmdbjava.KeyRange.atMost;
+import static org.lmdbjava.KeyRange.atMostBackward;
+import static org.lmdbjava.KeyRange.closed;
+import static org.lmdbjava.KeyRange.closedBackward;
+import static org.lmdbjava.KeyRange.closedOpen;
+import static org.lmdbjava.KeyRange.closedOpenBackward;
+import static org.lmdbjava.KeyRange.greaterThan;
+import static org.lmdbjava.KeyRange.greaterThanBackward;
+import static org.lmdbjava.KeyRange.lessThan;
+import static org.lmdbjava.KeyRange.lessThanBackward;
+import static org.lmdbjava.KeyRange.open;
+import static org.lmdbjava.KeyRange.openBackward;
+import static org.lmdbjava.KeyRange.openClosed;
+import static org.lmdbjava.KeyRange.openClosedBackward;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.DB_2;
+import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.DB_4;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.bbNative;
+import static org.lmdbjava.TestUtils.getNativeInt;
+
+import com.google.common.primitives.UnsignedBytes;
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.Matchers;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.lmdbjava.CursorIterable.KeyVal;
+
+/**
+ * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that
+ * comparators work with native order integer keys.
+ */
+@Ignore // Waiting for the merge of stroomdev66's cursor tests
+@RunWith(Parameterized.class)
+public final class CursorIterableIntegerDupTest {
+
+  private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERDUP, MDB_DUPSORT);
+  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
+  private static final List<Map.Entry<Integer, Integer>> INPUT_DATA;
+
+  static {
+    // 2 => 21
+    // 2 => 22
+    // 3 => 31
+    // ...
+    // 9 => 92
+    INPUT_DATA = new ArrayList<>();
+    for (int i = 2; i <= 9; i++) {
+      final int val1 = (i * 10) + 1;
+      final int val2 = (i * 10) + 2;
+      INPUT_DATA.add(new AbstractMap.SimpleEntry<>(i, val1));
+      INPUT_DATA.add(new AbstractMap.SimpleEntry<>(i, val2));
+    }
+  }
+
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
+
+  private Env<ByteBuffer> env;
+  private Deque<Map.Entry<Integer, Integer>> expectedEntriesDeque;
+
+  /**
+   * Injected by {@link #data()} with appropriate runner.
+   */
+  @SuppressWarnings("ClassEscapesDefinedScope")
+  @Parameterized.Parameter
+  public DbiFactory dbiFactory;
+
+  @Parameterized.Parameters(name = "{index}: dbi: {0}")
+  public static Object[] data() {
+    final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_1)
+            .withDefaultComparator()
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_2)
+            .withNativeComparator()
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_3)
+            .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_4)
+            .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    return new Object[]{
+        defaultComparator,
+        nativeComparator,
+        callbackComparator,
+        iteratorComparator};
+  }
+
+  @Before
+  public void before() throws IOException {
+    final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+    populateExpectedEntriesDeque();
+  }
+
+  @After
+  public void after() {
+    env.close();
+  }
+
+  @Test
+  public void allBackwardTest() {
+    verify(allBackward(), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void allTest() {
+    verify(all(), 2, 4, 6, 8);
+  }
+
+  @Test
+  public void atLeastBackwardTest() {
+    verify(atLeastBackward(bbNative(5)), 4, 2);
+    verify(atLeastBackward(bbNative(6)), 6, 4, 2);
+    verify(atLeastBackward(bbNative(9)), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void atLeastTest() {
+    verify(atLeast(bbNative(5)), 6, 8);
+    verify(atLeast(bbNative(6)), 6, 8);
+  }
+
+  @Test
+  public void atMostBackwardTest() {
+    verify(atMostBackward(bbNative(5)), 8, 6);
+    verify(atMostBackward(bbNative(6)), 8, 6);
+  }
+
+  @Test
+  public void atMostTest() {
+    verify(atMost(bbNative(5)), 2, 4);
+    verify(atMost(bbNative(6)), 2, 4, 6);
+  }
+
+  private void populateExpectedEntriesDeque() {
+    expectedEntriesDeque = new LinkedList<>();
+    expectedEntriesDeque.addAll(INPUT_DATA);
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      for (Map.Entry<Integer, Integer> entry : INPUT_DATA) {
+        c.put(bbNative(entry.getKey()), bb(entry.getValue()));
+      }
+      txn.commit();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
+
+      for (final KeyVal<ByteBuffer> kv : c) {
+        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
+        System.out.print(", ");
+      }
+      System.out.println();
+    }
+  }
+
+  private int[] rangeInc(final int fromInc, final int toInc) {
+    int idx = 0;
+    if (fromInc <= toInc) {
+      // Forwards
+      final int[] arr = new int[toInc - fromInc + 1];
+      for (int i = fromInc; i <= toInc; i++) {
+        arr[idx++] = i;
+      }
+      return arr;
+    } else {
+      // Backwards
+      final int[] arr = new int[fromInc - toInc + 1];
+      for (int i = fromInc; i >= toInc; i--) {
+        arr[idx++] = i;
+      }
+      return arr;
+    }
+  }
+
+  @Test
+  public void closedBackwardTest() {
+    verify(closedBackward(bbNative(7), bbNative(3)), rangeInc(7, 3));
+    verify(closedBackward(bbNative(6), bbNative(2)), rangeInc(6, 2));
+    verify(closedBackward(bbNative(9), bbNative(3)), rangeInc(9, 3));
+  }
+
+  @Test
+  public void closedOpenBackwardTest() {
+    verify(closedOpenBackward(bbNative(8), bbNative(3)), rangeInc(8, 4));
+    verify(closedOpenBackward(bbNative(7), bbNative(2)), rangeInc(7, 3));
+    verify(closedOpenBackward(bbNative(9), bbNative(3)), rangeInc(9, 4));
+  }
+
+  @Test
+  public void closedOpenTest() {
+    verify(closedOpen(bbNative(3), bbNative(8)), rangeInc(3, 7));
+    verify(closedOpen(bbNative(2), bbNative(6)), rangeInc(2, 5));
+  }
+
+  @Test
+  public void closedTest() {
+    verify(closed(bbNative(3), bbNative(7)), rangeInc(3, 7));
+    verify(closed(bbNative(2), bbNative(6)), rangeInc(2, 6));
+    verify(closed(bbNative(1), bbNative(7)), rangeInc(2, 7));
+  }
+
+  @Test
+  public void greaterThanBackwardTest() {
+    verify(greaterThanBackward(bbNative(6)), rangeInc(5, 2));
+    verify(greaterThanBackward(bbNative(7)), rangeInc(6, 2));
+    verify(greaterThanBackward(bbNative(9)), rangeInc(8, 2));
+  }
+
+  @Test
+  public void greaterThanTest() {
+    verify(greaterThan(bbNative(4)), rangeInc(5, 9));
+    verify(greaterThan(bbNative(3)), rangeInc(4, 9));
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void iterableOnlyReturnedOnce() {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      c.iterator(); // ok
+      c.iterator(); // fails
+    }
+  }
+
+  @Test
+  public void iterate() {
+    populateExpectedEntriesDeque();
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+
+      for (final KeyVal<ByteBuffer> kv : c) {
+        final Map.Entry<Integer, Integer> entry = expectedEntriesDeque.pollFirst();
+//        System.out.println(entry.getKey() + " => " + entry.getValue());
+        assertThat(getNativeInt(kv.key()), is(entry.getKey()));
+        assertThat(kv.val().getInt(), is(entry.getValue()));
+      }
+    }
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void iteratorOnlyReturnedOnce() {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      c.iterator(); // ok
+      c.iterator(); // fails
+    }
+  }
+
+  @Test
+  public void lessThanBackwardTest() {
+    verify(lessThanBackward(bbNative(5)), 8, 6);
+    verify(lessThanBackward(bbNative(2)), 8, 6, 4);
+  }
+
+  @Test
+  public void lessThanTest() {
+    verify(lessThan(bbNative(5)), 2, 4);
+    verify(lessThan(bbNative(8)), 2, 4, 6);
+  }
+
+  @Test(expected = NoSuchElementException.class)
+  public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
+    populateExpectedEntriesDeque();
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+      while (i.hasNext()) {
+        final KeyVal<ByteBuffer> kv = i.next();
+        assertThat(getNativeInt(kv.key()), is(expectedEntriesDeque.pollFirst()));
+        assertThat(kv.val().getInt(), is(expectedEntriesDeque.pollFirst()));
+      }
+      assertThat(i.hasNext(), is(false));
+      i.next();
+    }
+  }
+
+  @Test
+  public void openBackwardTest() {
+    verify(openBackward(bbNative(7), bbNative(2)), 6, 4);
+    verify(openBackward(bbNative(8), bbNative(1)), 6, 4, 2);
+    verify(openBackward(bbNative(9), bbNative(4)), 8, 6);
+  }
+
+  @Test
+  public void openClosedBackwardTest() {
+    verify(openClosedBackward(bbNative(7), bbNative(2)), 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), 6, 4);
+    verify(openClosedBackward(bbNative(9), bbNative(4)), 8, 6, 4);
+  }
+
+  @Test
+  public void openClosedBackwardTestWithGuava() {
+    final Comparator<byte[]> guava = UnsignedBytes.lexicographicalComparator();
+    final Comparator<ByteBuffer> comparator =
+        (bb1, bb2) -> {
+          final byte[] array1 = new byte[bb1.remaining()];
+          final byte[] array2 = new byte[bb2.remaining()];
+          bb1.mark();
+          bb2.mark();
+          bb1.get(array1);
+          bb2.get(array2);
+          bb1.reset();
+          bb2.reset();
+          return guava.compare(array1, array2);
+        };
+    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    populateDatabase(guavaDbi);
+    verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
+  }
+
+  @Test
+  public void openClosedTest() {
+    verify(openClosed(bbNative(3), bbNative(8)), 4, 6, 8);
+    verify(openClosed(bbNative(2), bbNative(6)), 4, 6);
+  }
+
+  @Test
+  public void openTest() {
+    verify(open(bbNative(3), bbNative(7)), 4, 6);
+    verify(open(bbNative(2), bbNative(8)), 4, 6);
+  }
+
+  @Test
+  public void removeOddElements() {
+    final Dbi<ByteBuffer> db = getDb();
+    verify(db, all(), 2, 4, 6, 8);
+    int idx = -1;
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+        while (c.hasNext()) {
+          c.next();
+          idx++;
+          if (idx % 2 == 0) {
+            c.remove();
+          }
+        }
+      }
+      txn.commit();
+    }
+    verify(db, all(), 4, 8);
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void nextWithClosedEnvTest() {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+        env.close();
+        c.next();
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void removeWithClosedEnvTest() {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+        final KeyVal<ByteBuffer> keyVal = c.next();
+        assertThat(keyVal, Matchers.notNullValue());
+
+        env.close();
+        c.remove();
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void hasNextWithClosedEnvTest() {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+        env.close();
+        c.hasNext();
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void forEachRemainingWithClosedEnvTest() {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+        env.close();
+        c.forEachRemaining(keyVal -> {
+        });
+      }
+    }
+  }
+
+  private void verify(final KeyRange<ByteBuffer> range, final int... expectedKeys) {
+    // Verify using all comparator types
+    final Dbi<ByteBuffer> db = getDb();
+    verify(range, db, expectedKeys);
+  }
+
+  private void verify(final Dbi<ByteBuffer> dbi,
+                      final KeyRange<ByteBuffer> range,
+                      final int... expectedKeys) {
+    verify(range, dbi, expectedKeys);
+  }
+
+  private void verify(final KeyRange<ByteBuffer> range,
+                      final Dbi<ByteBuffer> dbi,
+                      final int... expectedKeys) {
+    final boolean isForward = range.getType().isDirectionForward();
+
+    final List<Integer> expectedValues = Arrays.stream(expectedKeys)
+        .boxed()
+        .flatMap(key -> {
+          final int base = key * 10;
+          return isForward
+              ? Stream.of(base + 1, base + 2)
+              : Stream.of(base + 2, base + 1);
+        })
+        .collect(Collectors.toList());
+
+    final List<Integer> results = new ArrayList<>();
+    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
+
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
+        final int key = getNativeInt(kv.key());
+        final int val = kv.val().getInt();
+        System.out.println(key + " => " + val);
+        results.add(val);
+        assertThat(val, CoreMatchers.anyOf(
+            CoreMatchers.is((key * 10) + 1),
+            CoreMatchers.is((key * 10) + 2)));
+      }
+    }
+
+    assertThat(results, hasSize(expectedValues.size()));
+    for (int idx = 0; idx < results.size(); idx++) {
+      assertThat(results.get(idx), is(expectedValues.get(idx)));
+    }
+  }
+
+  private String rangeToString(final KeyRange<ByteBuffer> range) {
+    final ByteBuffer start = range.getStart();
+    final ByteBuffer stop = range.getStop();
+    return range.getType() + " start: " + (start != null ? getNativeInt(start) : "")
+        + " stop: " + (stop != null ? getNativeInt(stop) : "");
+  }
+
+  private Dbi<ByteBuffer> getDb() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+    populateDatabase(dbi);
+    return dbi;
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  private static class DbiFactory {
+    private final String name;
+    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
+
+    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
+      this.name = name;
+      this.factory = factory;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 85c0a567..bac95e13 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -143,47 +143,6 @@ public void before() throws IOException {
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
     populateTestDataList();
-//    final File path = tmp.newFile();
-//    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-//    env =
-//        create(bufferProxy)
-//            .setMapSize(KIBIBYTES.toBytes(256))
-//            .setMaxReaders(1)
-//            .setMaxDbs(3)
-//            .open(path, POSIX_MODE, MDB_NOSUBDIR);
-//
-//    // Use a java comparator for start/stop keys only
-//    DbiFlagSet dbiFlagSet = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
-//
-//    dbJavaComparator = env.buildDbi()
-//        .withDbName(DB_1)
-//        .withIteratorComparator(bufferProxy.getComparator(dbiFlagSet))
-//        .withDbiFlags(dbiFlagSet)
-//        .open();
-//
-//    // Use LMDB comparator for start/stop keys
-//    dbLmdbComparator = env.buildDbi()
-//        .withDbName(DB_2)
-//        .withDefaultComparator()
-//        .withDbiFlags(dbiFlagSet)
-//        .open();
-//
-//    // Use a java comparator for start/stop keys and as a callback comparaotr
-//    dbCallbackComparator = env.buildDbi()
-//        .withDbName(DB_3)
-//        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
-//        .withDbiFlags(dbiFlagSet)
-//        .open();
-//
-//    populateTestDataList();
-//
-//    populateDatabase(dbJavaComparator);
-//    populateDatabase(dbLmdbComparator);
-//    populateDatabase(dbCallbackComparator);
-//
-//    dbs.add(dbJavaComparator);
-//    dbs.add(dbLmdbComparator);
-//    dbs.add(dbCallbackComparator);
   }
 
   @After
@@ -226,7 +185,6 @@ public void atMostTest() {
     verify(atMost(bbNative(6)), 2, 4, 6);
   }
 
-
   private void populateTestDataList() {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
@@ -471,53 +429,6 @@ public void forEachRemainingWithClosedEnvTest() {
       }
   }
 
-//  @Test
-//  public void testSignedVsUnsigned() {
-//    final ByteBuffer val1 = bbNative(1);
-//    final ByteBuffer val2 = bbNative(2);
-//    final ByteBuffer val110 = bbNative(110);
-//    final ByteBuffer val111 = bbNative(111);
-//    final ByteBuffer val150 = bbNative(150);
-//
-//    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-//    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
-//    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
-//
-//    // Compare the same
-//    assertThat(
-//        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
-//
-//    // Compare differently
-//    assertThat(
-//        unsignedComparator.compare(val110, val150),
-//        Matchers.not(signedComparator.compare(val110, val150)));
-//
-//    // Compare differently
-//    assertThat(
-//        unsignedComparator.compare(val111, val150),
-//        Matchers.not(signedComparator.compare(val111, val150)));
-//
-//    // This will fail if the db is using a signed comparator for the start/stop keys
-//    for (final Dbi<ByteBuffer> db : dbs) {
-//      db.put(val110, val110);
-//      db.put(val150, val150);
-//
-//      final ByteBuffer startKeyBuf = val111;
-//      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
-//
-//      try (Txn<ByteBuffer> txn = env.txnRead();
-//          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
-//        for (final KeyVal<ByteBuffer> kv : c) {
-//          final int key = getNativeInt(kv.key());
-//          final int val = kv.val().getInt();
-//          //          System.out.println("key: " + key + " val: " + val);
-//          assertThat(key, is(110));
-//          break;
-//        }
-//      }
-//    }
-//  }
-
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
     // Verify using all comparator types
     final Dbi<ByteBuffer> db = getDb();

From 26665ba0cfaafaa082d3e22feeb4080cb0bc7849 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 29 Oct 2025 17:45:21 +0000
Subject: [PATCH 19/90] Fix byte order issues with compareAsIntegerKeys

---
 src/main/java/org/lmdbjava/BufferProxy.java   |  4 -
 .../java/org/lmdbjava/ByteBufferProxy.java    | 32 ++++---
 src/main/java/org/lmdbjava/Dbi.java           | 30 ++++--
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  6 ++
 src/main/java/org/lmdbjava/DbiFlags.java      |  2 +-
 .../java/org/lmdbjava/DirectBufferProxy.java  |  2 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     | 39 +++++---
 .../CursorIterableIntegerKeyTest.java         | 96 +++++++++++++++++++
 src/test/java/org/lmdbjava/TestUtils.java     | 33 ++++++-
 9 files changed, 204 insertions(+), 40 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index af0c7f06..f857ade7 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -40,10 +40,6 @@ public abstract class BufferProxy<T> {
   /** Offset from a pointer of the <code>MDB_val.mv_size</code> field. */
   protected static final int STRUCT_FIELD_OFFSET_SIZE = 0;
 
-  /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
-  protected static final DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(
-      DbiFlags.MDB_INTEGERKEY,
-      DbiFlags.MDB_INTEGERDUP);
 
   /** Explicitly-defined default constructor to avoid warnings. */
   protected BufferProxy() {}
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 89931587..5d5aa2ca 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -27,6 +27,7 @@
 import java.lang.reflect.Field;
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.util.ArrayDeque;
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -153,9 +154,6 @@ public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer
     /**
      * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
      * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
-     * <p>
-     * Both buffers must have 4 or 8 bytes remaining
-     * </p>
      *
      * @param o1 left operand (required)
      * @param o2 right operand (required)
@@ -164,26 +162,34 @@ public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer
     public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
-      // Both buffers should be same len
+      // Both buffers should be same lenght according to LMDB API.
       final int len1 = o1.limit();
       final int len2 = o2.limit();
       if (len1 != len2) {
         throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
             + ". Lengths must be identical and either 4 or 8 bytes.");
       }
-      final boolean reverse1 = o1.order() == LITTLE_ENDIAN;
-      final boolean reverse2 = o2.order() == LITTLE_ENDIAN;
+      // Keys for MDB_INTEGER_KEY are written in native order so ensure we read them in that order
+      o1.order(ByteOrder.nativeOrder());
+      o2.order(ByteOrder.nativeOrder());
+      // TODO it might be worth the DbiBuilder having a method to capture fixedKeyLength() or -1
+      //  for variable length keys. This can be passed to getComparator(..) so it can return a
+      //  comparator that doesn't need to test the length every time. There may be other benefits
+      //  to the Dbi knowing the key length if it is fixed.
       if (len1 == 8) {
-        final long lw = reverse1 ? Long.reverseBytes(o1.getLong(0)) : o1.getLong(0);
-        final long rw = reverse2 ? Long.reverseBytes(o2.getLong(0)) : o2.getLong(0);
+        final long lw = o1.getLong(0);
+        final long rw = o2.getLong(0);
         return Long.compareUnsigned(lw, rw);
       } else if (len1 == 4) {
-        final int lw = reverse1 ? Integer.reverseBytes(o1.getInt(0)) : o1.getInt(0);
-        final int rw = reverse2 ? Integer.reverseBytes(o2.getInt(0)) : o2.getInt(0);
+        final int lw = o1.getInt(0);
+        final int rw = o2.getInt(0);
         return Integer.compareUnsigned(lw, rw);
       } else {
-        throw new RuntimeException("Unexpected length1: " + len1
-            + ". Lengths must be identical and either 4 or 8 bytes.");
+        // size_t and int are likely to be 8bytes and 4bytes respectively on 64bit.
+        // If 32bit then would be 4/2 respectively.
+        // Short.compareUnsigned is not available in Java8.
+        // For now just fall back to our standard comparator
+        return compareLexicographically(o1, o2);
       }
     }
 
@@ -222,7 +228,7 @@ protected final ByteBuffer allocate() {
 
     @Override
     public Comparator<ByteBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
-      if (dbiFlagSet.areAnySet(INTEGER_KEY_FLAGS)) {
+      if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
         return AbstractByteBufferProxy::compareAsIntegerKeys;
       } else {
         return AbstractByteBufferProxy::compareLexicographically;
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index bcb1ccfc..5e8fa2f2 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -82,15 +82,27 @@ public final class Dbi<T> {
     if (nativeCb) {
       requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
       // LMDB will call back to this comparator for insertion/iteration order
-      this.callbackComparator =
-          (keyA, keyB) -> {
-            final T compKeyA  = proxy.out(proxy.allocate(), keyA);
-            final T compKeyB = proxy.out(proxy.allocate(), keyB);
-            final int result = this.comparator.compare(compKeyA, compKeyB);
-            proxy.deallocate(compKeyA);
-            proxy.deallocate(compKeyB);
-            return result;
-          };
+//      if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
+//        this.callbackComparator =
+//            (keyA, keyB) -> {
+//              final T compKeyA  = proxy.out(proxy.allocate(), keyA);
+//              final T compKeyB = proxy.out(proxy.allocate(), keyB);
+//              final int result = this.comparator.compare(compKeyA, compKeyB);
+//              proxy.deallocate(compKeyA);
+//              proxy.deallocate(compKeyB);
+//              return result;
+//            };
+//      } else {
+        this.callbackComparator =
+            (keyA, keyB) -> {
+              final T compKeyA  = proxy.out(proxy.allocate(), keyA);
+              final T compKeyB = proxy.out(proxy.allocate(), keyB);
+              final int result = this.comparator.compare(compKeyA, compKeyB);
+              proxy.deallocate(compKeyA);
+              proxy.deallocate(compKeyB);
+              return result;
+            };
+//      }
       LIB.mdb_set_compare(txn.pointer(), ptr, callbackComparator);
     } else {
       callbackComparator = null;
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 5edf10c7..5a0bc83e 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -21,8 +21,14 @@
 
 public interface DbiFlagSet extends FlagSet<DbiFlags> {
 
+  /** An immutable empty {@link DbiFlagSet}. */
   DbiFlagSet EMPTY = DbiFlagSetImpl.EMPTY;
 
+  /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
+  DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(
+      DbiFlags.MDB_INTEGERKEY,
+      DbiFlags.MDB_INTEGERDUP);
+
   static DbiFlagSet empty() {
     return DbiFlagSetImpl.EMPTY;
   }
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 10952da9..7c4b6794 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -41,7 +41,7 @@ public enum DbiFlags implements MaskedFlag, DbiFlagSet {
   MDB_DUPSORT(0x04),
   /**
    * Numeric keys in native byte order: either unsigned int or size_t.
-   * The keys must all be of the same size.
+   * <strong>The keys must all be of the same size.</strong>
    * <p>
    * This is an optimisation that is available when your keys are 4 or 8 byte unsigned numeric values.
    * There are performance benefits for both ordered and un-ordered puts as compared to not using
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 9c90d98b..180eee0a 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -138,7 +138,7 @@ protected DirectBuffer allocate() {
 
   @Override
   public Comparator<DirectBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
-    if (dbiFlagSet.areAnySet(INTEGER_KEY_FLAGS)) {
+    if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
       return DirectBufferProxy::compareAsIntegerKeys;
     } else {
       return DirectBufferProxy::compareLexicographically;
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index 1372b74a..c7d8333f 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -40,6 +40,7 @@
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.time.Duration;
 import java.time.Instant;
 import java.util.Comparator;
@@ -158,8 +159,10 @@ public void comparatorPerformance() {
     int x = 0;
     for (int rounds = 0; rounds < 100; rounds++) {
       for (int i = 1; i < values.length; i++) {
-        buffer1.putLong(0, values[i - 1]);
-        buffer2.putLong(0, values[i]);
+        buffer1.order(ByteOrder.nativeOrder())
+            .putLong(0, values[i - 1]);
+        buffer2.order(ByteOrder.nativeOrder())
+            .putLong(0, values[i]);
         final int result = ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
         x += result;
       }
@@ -170,8 +173,10 @@ public void comparatorPerformance() {
     x = 0;
     for (int rounds = 0; rounds < 100; rounds++) {
       for (int i = 1; i < values.length; i++) {
-        buffer1.putLong(0, values[i - 1]);
-        buffer2.putLong(0, values[i]);
+        buffer1.order(BIG_ENDIAN)
+            .putLong(0, values[i - 1]);
+        buffer2.order(BIG_ENDIAN)
+            .putLong(0, values[i]);
         final int result = ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
         x += result;
       }
@@ -182,10 +187,14 @@ public void comparatorPerformance() {
   @Test
   public void verifyComparators() {
     final Random random = new Random(203948);
-    final ByteBuffer buffer1 = ByteBuffer.allocateDirect(Long.BYTES);
-    final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
-    buffer1.limit(Long.BYTES);
-    buffer2.limit(Long.BYTES);
+    final ByteBuffer buffer1native = ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer2native = ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer1be = ByteBuffer.allocateDirect(Long.BYTES).order(BIG_ENDIAN);
+    final ByteBuffer buffer2be = ByteBuffer.allocateDirect(Long.BYTES).order(BIG_ENDIAN);
+    buffer1native.limit(Long.BYTES);
+    buffer2native.limit(Long.BYTES);
+    buffer1be.limit(Long.BYTES);
+    buffer2be.limit(Long.BYTES);
     final long[] values = random.longs(10_000_000).toArray();
 
     final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
@@ -198,13 +207,21 @@ public void verifyComparators() {
     for (int i = 1; i < values.length; i++) {
       final long val1 = values[i - 1];
       final long val2 = values[i];
-      buffer1.putLong(0, val1);
-      buffer2.putLong(0, val2);
+      buffer1native.putLong(0, val1);
+      buffer2native.putLong(0, val2);
+      buffer1be.putLong(0, val1);
+      buffer2be.putLong(0, val2);
       uniqueResults.clear();
 
       // Make sure all comparators give the same result for the same inputs
       comparators.forEach((name, comparator) -> {
-        final int result = comparator.compare(buffer1, buffer2);
+        final int result;
+        // IntegerKey comparator expects keys to have been written in native order so need different buffers.
+        if (name.equals("compareAsIntegerKeys")) {
+          result = comparator.compare(buffer1native, buffer2native);
+        } else {
+          result = comparator.compare(buffer1be, buffer2be);
+        }
         results.put(name, result);
         uniqueResults.add(result);
       });
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index bac95e13..be91ea4c 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -51,20 +51,24 @@
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.bbNative;
 import static org.lmdbjava.TestUtils.getNativeInt;
+import static org.lmdbjava.TestUtils.getString;
 
 import com.google.common.primitives.UnsignedBytes;
 import java.io.File;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
+import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Deque;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 import org.hamcrest.Matchers;
 import org.junit.After;
 import org.junit.Before;
@@ -150,6 +154,98 @@ public void after() {
     env.close();
   }
 
+  @Test
+  public void testNumericOrderLong() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      long i = 1;
+      while (true) {
+//        System.out.println("putting " + i);
+        c.put(bbNative(i), bb(i + "-long"));
+          final long i2 = i * 10;
+          if (i2 < i) {
+            // Overflowed
+            break;
+          }
+        i = i2;
+      }
+      txn.commit();
+    }
+
+    final List<Map.Entry<Long, String>> entries = new ArrayList<>();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> iterable = dbi.iterate(txn)) {
+        for (KeyVal<ByteBuffer> keyVal : iterable) {
+          final String val = getString(keyVal.val());
+          final long key = TestUtils.getNativeLong(keyVal.key());
+          entries.add(new AbstractMap.SimpleEntry<>(key, val));
+//          System.out.println(val);
+        }
+      }
+    }
+
+    final List<Long> dbKeys = entries.stream()
+        .map(Map.Entry::getKey)
+        .collect(Collectors.toList());
+    final List<Long> dbKeysSorted = entries.stream()
+        .map(Map.Entry::getKey)
+        .sorted()
+        .collect(Collectors.toList());
+    for (int i = 0; i < dbKeys.size(); i++) {
+      final long dbKey1 = dbKeys.get(i);
+      final long dbKey2 = dbKeysSorted.get(i);
+      assertThat(dbKey1, is(dbKey2));
+    }
+  }
+
+  @Test
+  public void testNumericOrderInt() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      int i = 1;
+      while (true) {
+//        System.out.println("putting " + i);
+        c.put(bbNative(i), bb(i + "-int"));
+        final int i2 = i * 10;
+        if (i2 < i) {
+          // Overflowed
+          break;
+        }
+        i = i2;
+      }
+      txn.commit();
+    }
+
+    final List<Map.Entry<Integer, String>> entries = new ArrayList<>();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> iterable = dbi.iterate(txn)) {
+        for (KeyVal<ByteBuffer> keyVal : iterable) {
+          final String val = getString(keyVal.val());
+          final int key = TestUtils.getNativeInt(keyVal.key());
+          entries.add(new AbstractMap.SimpleEntry<>(key, val));
+//          System.out.println(val);
+        }
+      }
+    }
+
+    final List<Integer> dbKeys = entries.stream()
+        .map(Map.Entry::getKey)
+        .collect(Collectors.toList());
+    final List<Integer> dbKeysSorted = entries.stream()
+        .map(Map.Entry::getKey)
+        .sorted()
+        .collect(Collectors.toList());
+    for (int i = 0; i < dbKeys.size(); i++) {
+      final long dbKey1 = dbKeys.get(i);
+      final long dbKey2 = dbKeysSorted.get(i);
+      assertThat(dbKey1, is(dbKey2));
+    }
+  }
+
   @Test
   public void allBackwardTest() {
     verify(allBackward(), 8, 6, 4, 2);
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index c26c1c52..511619fe 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -24,6 +24,7 @@
 import java.lang.reflect.InvocationTargetException;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
 
@@ -55,13 +56,29 @@ static ByteBuffer bb(final int value) {
     return bb;
   }
 
+  static ByteBuffer bb(final String value) {
+    final ByteBuffer bb = allocateDirect(100);
+    if (value != null) {
+      bb.put(value.getBytes(StandardCharsets.UTF_8));
+      bb.flip();
+    }
+    return bb;
+  }
+
   static ByteBuffer bbNative(final int value) {
-    final ByteBuffer bb = allocateDirect(Long.BYTES)
+    final ByteBuffer bb = allocateDirect(Integer.BYTES)
         .order(ByteOrder.nativeOrder());
     bb.putInt(value).flip();
     return bb;
   }
 
+  static ByteBuffer bbNative(final long value) {
+    final ByteBuffer bb = allocateDirect(Long.BYTES)
+        .order(ByteOrder.nativeOrder());
+    bb.putLong(value).flip();
+    return bb;
+  }
+
   static int getNativeInt(final ByteBuffer bb) {
     final int val = bb.order(ByteOrder.nativeOrder())
         .getInt();
@@ -69,6 +86,20 @@ static int getNativeInt(final ByteBuffer bb) {
     return val;
   }
 
+  static long getNativeLong(final ByteBuffer bb) {
+    final long val = bb.order(ByteOrder.nativeOrder())
+        .getLong();
+    bb.rewind();
+    return val;
+  }
+
+  static String getString(final ByteBuffer bb) {
+    final String str = StandardCharsets.UTF_8.decode(bb)
+        .toString();
+    bb.rewind();
+    return str;
+  }
+
   static void invokePrivateConstructor(final Class<?> clazz) {
     try {
       final Constructor<?> c = clazz.getDeclaredConstructor();

From dc0b96b4ab5489bd986f58895a35b653166016fb Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 29 Oct 2025 19:02:36 +0000
Subject: [PATCH 20/90] #267 Fix to establish start key when iterating
 backwards from a start key using DUPSORT

---
 .gitignore                                    |   2 +-
 cross-compile.sh                              |   1 +
 .../java/org/lmdbjava/CursorIterable.java     |  34 +-
 src/main/java/org/lmdbjava/KeyRangeType.java  |  64 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     |  23 +-
 .../org/lmdbjava/CursorIterableRangeTest.java | 430 +++++-----
 .../java/org/lmdbjava/CursorIterableTest.java |   9 +-
 .../java/org/lmdbjava/CursorParamTest.java    |   3 +-
 src/test/java/org/lmdbjava/CursorTest.java    |   7 +-
 src/test/java/org/lmdbjava/DbiTest.java       |  49 +-
 src/test/java/org/lmdbjava/EnvTest.java       | 546 ++++++-------
 src/test/java/org/lmdbjava/FileUtil.java      |  41 -
 .../org/lmdbjava/GarbageCollectionTest.java   |  97 +--
 src/test/java/org/lmdbjava/TempDir.java       |  57 ++
 src/test/java/org/lmdbjava/TestUtils.java     |   9 +
 src/test/java/org/lmdbjava/TutorialTest.java  | 734 +++++++++---------
 src/test/java/org/lmdbjava/TxnTest.java       |  10 +-
 src/test/java/org/lmdbjava/VerifierTest.java  |  27 +-
 .../testSignedComparatorDupsort.csv           |   2 +-
 .../testUnsignedComparatorDupsort.csv         |  13 +-
 20 files changed, 1097 insertions(+), 1061 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/TempDir.java

diff --git a/.gitignore b/.gitignore
index f46b8b6f..44fe1d51 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,5 +16,5 @@ dependency-reduced-pom.xml
 gpg-sign.json
 mvn-sync.json
 secrets.tar
-lmdb
+openldap
 pom.xml.versionsBackup
diff --git a/cross-compile.sh b/cross-compile.sh
index 5243feec..18d4ce07 100755
--- a/cross-compile.sh
+++ b/cross-compile.sh
@@ -20,6 +20,7 @@ set -o errexit
 
 rm -rf openldap
 git clone --depth 1 --branch LMDB_0.9.33 https://git.openldap.org/openldap/openldap.git
+rm -rf openldap/.git
 pushd openldap/libraries/liblmdb
 trap popd SIGINT
 
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 6a03bd90..b6d58e3d 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -15,11 +15,7 @@
  */
 package org.lmdbjava;
 
-import static org.lmdbjava.CursorIterable.State.RELEASED;
-import static org.lmdbjava.CursorIterable.State.REQUIRES_INITIAL_OP;
-import static org.lmdbjava.CursorIterable.State.REQUIRES_ITERATOR_OP;
-import static org.lmdbjava.CursorIterable.State.REQUIRES_NEXT_OP;
-import static org.lmdbjava.CursorIterable.State.TERMINATED;
+import static org.lmdbjava.CursorIterable.State.*;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
 
 import java.util.Comparator;
@@ -101,7 +97,7 @@ public void remove() {
   }
 
   private void executeCursorOp(final CursorOp op) {
-    final boolean found;
+    boolean found;
     switch (op) {
       case FIRST:
         found = cursor.first();
@@ -119,7 +115,31 @@ private void executeCursorOp(final CursorOp op) {
         found = cursor.get(range.getStart(), MDB_SET_RANGE);
         break;
       case GET_START_KEY_BACKWARD:
-        found = cursor.get(range.getStart(), MDB_SET_RANGE) || cursor.last();
+        found = cursor.get(range.getStart(), MDB_SET_RANGE);
+        if (found) {
+          if (!range.getType().isDirectionForward()
+              && range.getType().isStartKeyRequired()
+              && range.getType().isStartKeyInclusive()) {
+            // We need to ensure we move to the last matching key if using DUPSORT, see issue 267
+            boolean loop = true;
+            while (loop) {
+              if (comparator.compare(cursor.key(), range.getStart()) <= 0) {
+                found = cursor.next();
+                if (!found) {
+                  // We got to the end so move last.
+                  found = cursor.last();
+                  loop = false;
+                }
+              } else {
+                // We have moved past so go back one.
+                found = cursor.prev();
+                loop = false;
+              }
+            }
+          }
+        } else {
+          found = cursor.last();
+        }
         break;
       default:
         throw new IllegalStateException("Unknown cursor operation");
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index ad67286d..0514cbf2 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -46,7 +46,7 @@ public enum KeyRangeType {
    *
    * <p>In our example, the returned keys would be 2, 4, 6 and 8.
    */
-  FORWARD_ALL(true, false, false),
+  FORWARD_ALL(true, false, false, false, false),
   /**
    * Start on the passed key (or the first key immediately after it) and iterate forward until no
    * keys remain.
@@ -56,7 +56,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search key of 5, the returned keys would be 6 and 8. With a
    * passed key of 6, the returned keys would be 6 and 8.
    */
-  FORWARD_AT_LEAST(true, true, false),
+  FORWARD_AT_LEAST(true, true, true, false, false),
   /**
    * Start on the first key and iterate forward until a key equal to it (or the first key
    * immediately after it) is reached.
@@ -66,7 +66,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search key of 5, the returned keys would be 2 and 4. With a
    * passed key of 6, the returned keys would be 2, 4 and 6.
    */
-  FORWARD_AT_MOST(true, false, true),
+  FORWARD_AT_MOST(true, false, false, true, true),
   /**
    * Iterate forward between the passed keys, matching on the first keys directly equal to the
    * passed key (or immediately following it in the case of the "start" key, or immediately
@@ -77,7 +77,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search range of 3 - 7, the returned keys would be 4 and 6.
    * With a range of 2 - 6, the keys would be 2, 4 and 6.
    */
-  FORWARD_CLOSED(true, true, true),
+  FORWARD_CLOSED(true, true, true, true, true),
   /**
    * Iterate forward between the passed keys, matching on the first keys directly equal to the
    * passed key (or immediately following it in the case of the "start" key, or immediately
@@ -88,7 +88,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search range of 3 - 8, the returned keys would be 4 and 6.
    * With a range of 2 - 6, the keys would be 2 and 4.
    */
-  FORWARD_CLOSED_OPEN(true, true, true),
+  FORWARD_CLOSED_OPEN(true, true, true, true, false),
   /**
    * Start after the passed key (but not equal to it) and iterate forward until no keys remain.
    *
@@ -97,7 +97,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search key of 4, the returned keys would be 6 and 8. With a
    * passed key of 3, the returned keys would be 4, 6 and 8.
    */
-  FORWARD_GREATER_THAN(true, true, false),
+  FORWARD_GREATER_THAN(true, true, false, false, false),
   /**
    * Start on the first key and iterate forward until a key the passed key has been reached (but do
    * not return that key).
@@ -107,7 +107,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search key of 5, the returned keys would be 2 and 4. With a
    * passed key of 8, the returned keys would be 2, 4 and 6.
    */
-  FORWARD_LESS_THAN(true, false, true),
+  FORWARD_LESS_THAN(true, false, false, true, false),
   /**
    * Iterate forward between the passed keys but not equal to either of them.
    *
@@ -116,7 +116,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search range of 3 - 7, the returned keys would be 4 and 6.
    * With a range of 2 - 8, the key would be 4 and 6.
    */
-  FORWARD_OPEN(true, true, true),
+  FORWARD_OPEN(true, true, false, true, false),
   /**
    * Iterate forward between the passed keys. Do not return the "start" key, but do return the
    * "stop" key.
@@ -126,7 +126,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search range of 3 - 8, the returned keys would be 4, 6 and
    * 8. With a range of 2 - 6, the keys would be 4 and 6.
    */
-  FORWARD_OPEN_CLOSED(true, true, true),
+  FORWARD_OPEN_CLOSED(true, true, false, true, true),
   /**
    * Start on the last key and iterate backward until no keys remain.
    *
@@ -134,7 +134,7 @@ public enum KeyRangeType {
    *
    * <p>In our example, the returned keys would be 8, 6, 4 and 2.
    */
-  BACKWARD_ALL(false, false, false),
+  BACKWARD_ALL(false, false, false, false, false),
   /**
    * Start on the passed key (or the first key immediately preceding it) and iterate backward until
    * no keys remain.
@@ -145,7 +145,7 @@ public enum KeyRangeType {
    * passed key of 6, the returned keys would be 6, 4 and 2. With a passed key of 9, the returned
    * keys would be 8, 6, 4 and 2.
    */
-  BACKWARD_AT_LEAST(false, true, false),
+  BACKWARD_AT_LEAST(false, true, true, false, false),
   /**
    * Start on the last key and iterate backward until a key equal to it (or the first key
    * immediately preceding it it) is reached.
@@ -155,7 +155,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search key of 5, the returned keys would be 8 and 6. With a
    * passed key of 6, the returned keys would be 8 and 6.
    */
-  BACKWARD_AT_MOST(false, false, true),
+  BACKWARD_AT_MOST(false, false, false, true, true),
   /**
    * Iterate backward between the passed keys, matching on the first keys directly equal to the
    * passed key (or immediately preceding it in the case of the "start" key, or immediately
@@ -167,7 +167,7 @@ public enum KeyRangeType {
    * With a range of 6 - 2, the keys would be 6, 4 and 2. With a range of 9 - 3, the returned keys
    * would be 8, 6 and 4.
    */
-  BACKWARD_CLOSED(false, true, true),
+  BACKWARD_CLOSED(false, true, true, true, true),
   /**
    * Iterate backward between the passed keys, matching on the first keys directly equal to the
    * passed key (or immediately preceding it in the case of the "start" key, or immediately
@@ -179,7 +179,7 @@ public enum KeyRangeType {
    * 4. With a range of 7 - 2, the keys would be 6 and 4. With a range of 9 - 3, the keys would be
    * 8, 6 and 4.
    */
-  BACKWARD_CLOSED_OPEN(false, true, true),
+  BACKWARD_CLOSED_OPEN(false, true, true, true, false),
   /**
    * Start immediate prior to the passed key (but not equal to it) and iterate backward until no
    * keys remain.
@@ -190,7 +190,7 @@ public enum KeyRangeType {
    * passed key of 7, the returned keys would be 6, 4 and 2. With a passed key of 9, the returned
    * keys would be 8, 6, 4 and 2.
    */
-  BACKWARD_GREATER_THAN(false, true, false),
+  BACKWARD_GREATER_THAN(false, true, false, false, false),
   /**
    * Start on the last key and iterate backward until the last key greater than the passed "stop"
    * key is reached. Do not return the "stop" key.
@@ -200,7 +200,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search key of 5, the returned keys would be 8 and 6. With a
    * passed key of 2, the returned keys would be 8, 6 and 4
    */
-  BACKWARD_LESS_THAN(false, false, true),
+  BACKWARD_LESS_THAN(false, false, false, true, false),
   /**
    * Iterate backward between the passed keys, but do not return the passed keys.
    *
@@ -210,7 +210,7 @@ public enum KeyRangeType {
    * With a range of 8 - 1, the keys would be 6, 4 and 2. With a range of 9 - 4, the keys would be 8
    * and 6.
    */
-  BACKWARD_OPEN(false, true, true),
+  BACKWARD_OPEN(false, true, false, true, false),
   /**
    * Iterate backward between the passed keys. Do not return the "start" key, but do return the
    * "stop" key.
@@ -221,19 +221,25 @@ public enum KeyRangeType {
    * 2. With a range of 8 - 4, the keys would be 6 and 4. With a range of 9 - 4, the keys would be
    * 8, 6 and 4.
    */
-  BACKWARD_OPEN_CLOSED(false, true, true);
+  BACKWARD_OPEN_CLOSED(false, true, false, true, true);
 
   private final boolean directionForward;
   private final boolean startKeyRequired;
+  private final boolean startKeyInclusive;
   private final boolean stopKeyRequired;
+  private final boolean stopKeyInclusive;
 
   KeyRangeType(
       final boolean directionForward,
       final boolean startKeyRequired,
-      final boolean stopKeyRequired) {
+      final boolean startKeyInclusive,
+      final boolean stopKeyRequired,
+      final boolean stopKeyInclusive) {
     this.directionForward = directionForward;
     this.startKeyRequired = startKeyRequired;
+    this.startKeyInclusive = startKeyInclusive;
     this.stopKeyRequired = stopKeyRequired;
+    this.stopKeyInclusive = stopKeyInclusive;
   }
 
   /**
@@ -254,6 +260,16 @@ public boolean isStartKeyRequired() {
     return startKeyRequired;
   }
 
+  /**
+   * Is the start key to be treated as inclusive in the range.
+   *
+   * @return true if start key is inclusive. False if not inclusive or no start key is required by
+   *     the range type.
+   */
+  public boolean isStartKeyInclusive() {
+    return startKeyInclusive;
+  }
+
   /**
    * Whether the iteration requires a "stop" key.
    *
@@ -263,6 +279,16 @@ public boolean isStopKeyRequired() {
     return stopKeyRequired;
   }
 
+  /**
+   * Is the stop key to be treated as inclusive in the range.
+   *
+   * @return true if stop key is inclusive. False if not inclusive or no stop key is required by the
+   *     range type.
+   */
+  public boolean isStopKeyInclusive() {
+    return stopKeyInclusive;
+  }
+
   /**
    * Determine the iterator action to take when iterator first begins.
    *
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index 82c0abce..d5638fe2 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -36,6 +36,7 @@
 
 import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
+import java.nio.file.Path;
 import jnr.ffi.Pointer;
 import jnr.ffi.provider.MemoryManager;
 import org.junit.jupiter.api.Test;
@@ -51,17 +52,17 @@ public final class ByteBufferProxyTest {
   void buffersMustBeDirect() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempDir(
-                  dir -> {
-                    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(dir.toFile())) {
-                      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-                      final ByteBuffer key = allocate(100);
-                      key.putInt(1).flip();
-                      final ByteBuffer val = allocate(100);
-                      val.putInt(1).flip();
-                      db.put(key, val); // error
-                    }
-                  });
+              try (final TempDir tempDir = new TempDir()) {
+                final Path dir = tempDir.createTempDir();
+                try (final Env<ByteBuffer> env = create().setMaxReaders(1).open(dir.toFile())) {
+                  final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                  final ByteBuffer key = allocate(100);
+                  key.putInt(1).flip();
+                  final ByteBuffer val = allocate(100);
+                  val.putInt(1).flip();
+                  db.put(key, val); // error
+                }
+              }
             })
         .isInstanceOf(BufferMustBeDirectException.class);
   }
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index bff6593e..dd33e885 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -16,162 +16,175 @@
 
 package org.lmdbjava;
 
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.CsvFileSource;
-import org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy;
-import org.lmdbjava.CursorIterable.KeyVal;
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static java.nio.ByteBuffer.allocateDirect;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.DbiFlags.*;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.TestUtils.*;
 
 import java.io.*;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
-import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Comparator;
 import java.util.EnumSet;
 import java.util.function.BiConsumer;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvFileSource;
+import org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy;
+import org.lmdbjava.CursorIterable.KeyVal;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
-import static java.nio.ByteBuffer.allocateDirect;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.lmdbjava.DbiFlags.*;
-import static org.lmdbjava.Env.create;
-import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
-import static org.lmdbjava.TestUtils.*;
-
-/**
- * Test {@link CursorIterable}.
- */
+/** Test {@link CursorIterable}. */
 public final class CursorIterableRangeTest {
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testSignedComparator.csv")
-  void testSignedComparator(final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(ByteBuffer::compareTo,
-            true,
-            createBasicDBPopulator(),
-            EnumSet.of(MDB_CREATE),
-            keyType,
-            startKey,
-            stopKey,
-            expectedKV);
+  void testSignedComparator(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        ByteBuffer::compareTo,
+        true,
+        createBasicDBPopulator(),
+        EnumSet.of(MDB_CREATE),
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparator.csv")
-  void testUnsignedComparator(final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(AbstractByteBufferProxy::compareBuff,
-            false,
-            createBasicDBPopulator(),
-            EnumSet.of(MDB_CREATE),
-            keyType,
-            startKey,
-            stopKey,
-            expectedKV);
+  void testUnsignedComparator(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        AbstractByteBufferProxy::compareBuff,
+        false,
+        createBasicDBPopulator(),
+        EnumSet.of(MDB_CREATE),
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testSignedComparatorDupsort.csv")
-  void testSignedComparatorDupsort(final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(ByteBuffer::compareTo,
-            true,
-            createMultiDBPopulator(2),
-            EnumSet.of(MDB_CREATE, MDB_DUPSORT),
-            keyType,
-            startKey,
-            stopKey,
-            expectedKV);
+  void testSignedComparatorDupsort(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        ByteBuffer::compareTo,
+        true,
+        createMultiDBPopulator(2),
+        EnumSet.of(MDB_CREATE, MDB_DUPSORT),
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv")
-  void testUnsignedComparatorDupsort(final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(AbstractByteBufferProxy::compareBuff,
-            false,
-            createMultiDBPopulator(2),
-            EnumSet.of(MDB_CREATE, MDB_DUPSORT),
-            keyType,
-            startKey,
-            stopKey,
-            expectedKV);
+  void testUnsignedComparatorDupsort(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        AbstractByteBufferProxy::compareBuff,
+        false,
+        createMultiDBPopulator(2),
+        EnumSet.of(MDB_CREATE, MDB_DUPSORT),
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testIntegerKey.csv")
-  void testIntegerKey(final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(AbstractByteBufferProxy::compareBuff,
-            false,
-            createIntegerDBPopulator(),
-            EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
-            keyType,
-            startKey,
-            stopKey,
-            expectedKV,
-            Integer.BYTES,
-            ByteOrder.LITTLE_ENDIAN);
+  void testIntegerKey(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        AbstractByteBufferProxy::compareBuff,
+        false,
+        createIntegerDBPopulator(),
+        EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        Integer.BYTES,
+        ByteOrder.LITTLE_ENDIAN);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testLongKey.csv")
-  void testLongKey(final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(AbstractByteBufferProxy::compareBuff,
-            false,
-            createLongDBPopulator(),
-            EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
-            keyType,
-            startKey,
-            stopKey,
-            expectedKV,
-            Long.BYTES,
-            ByteOrder.LITTLE_ENDIAN);
+  void testLongKey(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        AbstractByteBufferProxy::compareBuff,
+        false,
+        createLongDBPopulator(),
+        EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        Long.BYTES,
+        ByteOrder.LITTLE_ENDIAN);
   }
 
-
-  private void testCSV(final Comparator<ByteBuffer> comparator,
-                       final boolean nativeCb,
-                       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
-                       final EnumSet<DbiFlags> flags,
-                       final String keyType,
-                       final String startKey,
-                       final String stopKey,
-                       final String expectedKV) {
-    testCSV(comparator, nativeCb, dbPopulator, flags, keyType, startKey, stopKey, expectedKV, Integer.BYTES, ByteOrder.BIG_ENDIAN);
+  private void testCSV(
+      final Comparator<ByteBuffer> comparator,
+      final boolean nativeCb,
+      final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
+      final EnumSet<DbiFlags> flags,
+      final String keyType,
+      final String startKey,
+      final String stopKey,
+      final String expectedKV) {
+    testCSV(
+        comparator,
+        nativeCb,
+        dbPopulator,
+        flags,
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        Integer.BYTES,
+        ByteOrder.BIG_ENDIAN);
   }
 
-  private void testCSV(final Comparator<ByteBuffer> comparator,
-                       final boolean nativeCb,
-                       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
-                       final EnumSet<DbiFlags> flags,
-                       final String keyType,
-                       final String startKey,
-                       final String stopKey,
-                       final String expectedKV,
-                       final int keyLen,
-                       final ByteOrder byteOrder) {
-    FileUtil.useTempFile(file -> {
+  private void testCSV(
+      final Comparator<ByteBuffer> comparator,
+      final boolean nativeCb,
+      final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
+      final EnumSet<DbiFlags> flags,
+      final String keyType,
+      final String startKey,
+      final String stopKey,
+      final String expectedKV,
+      final int keyLen,
+      final ByteOrder byteOrder) {
+    try (final TempDir tempDir = new TempDir()) {
+      final Path file = tempDir.createTempFile();
       try (final Env<ByteBuffer> env =
-                   create()
-                           .setMapSize(KIBIBYTES.toBytes(256))
-                           .setMaxReaders(1)
-                           .setMaxDbs(1)
-                           .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
-        final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, comparator, nativeCb, flags.toArray(new DbiFlags[0]));
+          create()
+              .setMapSize(KIBIBYTES.toBytes(256))
+              .setMaxReaders(1)
+              .setMaxDbs(1)
+              .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
+        final Dbi<ByteBuffer> dbi =
+            env.openDbi(DB_1, comparator, nativeCb, flags.toArray(new DbiFlags[0]));
         dbPopulator.accept(env, dbi);
-
-//      final File tests = new File("src/test/resources/CursorIterableRangeTest/tests.csv");
-//      final File actual = tests.getParentFile().toPath().resolve(testName + ".actual").toFile();
-//      final File expected = tests.getParentFile().toPath().resolve(testName + ".expected").toFile();
-//      final String csv = readFile(tests);
-//      final String[] parts = csv.split("\n");
         try (final Writer writer = new StringWriter()) {
-//        for (final String part : parts) {
-//          final String[] params = part.split(",");
           final KeyRangeType keyRangeType = KeyRangeType.valueOf(keyType.trim());
           ByteBuffer start = parseKey(startKey, keyLen, byteOrder);
           ByteBuffer stop = parseKey(stopKey, keyLen, byteOrder);
 
           final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
           try (Txn<ByteBuffer> txn = env.txnRead();
-               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
+              CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
             for (final KeyVal<ByteBuffer> kv : c) {
               final long key = getLong(kv.key(), byteOrder);
               final long val = getLong(kv.val(), byteOrder);
@@ -186,19 +199,11 @@ private void testCSV(final Comparator<ByteBuffer> comparator,
         } catch (final IOException e) {
           throw new UncheckedIOException(e);
         }
-
-
-//      // Compare files.
-//      final String act = readFile(actual);
-//      final String exp = readFile(expected);
-//      assertThat(act).withFailMessage("Files are not equal").isEqualTo(exp);
       }
-    });
+    }
   }
 
-  private ByteBuffer parseKey(final String key,
-                              final int keyLen,
-                              final ByteOrder byteOrder) {
+  private ByteBuffer parseKey(final String key, final int keyLen, final ByteOrder byteOrder) {
     if (key != null) {
       if (ByteOrder.LITTLE_ENDIAN.equals(byteOrder)) {
         if (keyLen == Integer.BYTES) {
@@ -217,8 +222,7 @@ private ByteBuffer parseKey(final String key,
     return null;
   }
 
-  private long getLong(final ByteBuffer byteBuffer,
-                       final ByteOrder byteOrder) {
+  private long getLong(final ByteBuffer byteBuffer, final ByteOrder byteOrder) {
     byteBuffer.order(byteOrder);
     if (byteBuffer.remaining() == Integer.BYTES) {
       return byteBuffer.getInt();
@@ -227,92 +231,95 @@ private long getLong(final ByteBuffer byteBuffer,
     }
   }
 
-//
-//  @Test
-//  void testSignedComparator() throws IOException {
-//    test(ByteBuffer::compareTo, true, "testSignedComparator", 1, MDB_CREATE);
-//  }
-//
-//  @Test
-//  void testUnsignedComparator() throws IOException {
-//    test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparator", 1, MDB_CREATE);
-//  }
-//
-//  @Test
-//  void testSignedComparatorDupsort() throws IOException {
-//    test(ByteBuffer::compareTo, true, "testSignedComparatorDupsort", 2, MDB_CREATE, MDB_DUPSORT);
-//  }
-//
-//  @Test
-//  void testUnsignedComparatorDupsort() throws IOException {
-//    test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparatorDupsort", 2, MDB_CREATE, MDB_DUPSORT);
-//  }
-
-  private void test(final Comparator<ByteBuffer> comparator,
-                    final boolean nativeCb,
-                    final String testName,
-                    final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
-                    final DbiFlags... flags) throws IOException {
-    final Path dbPath = Files.createTempFile("test", "db");
-    try (final Env<ByteBuffer> env =
-                 create()
-                         .setMapSize(KIBIBYTES.toBytes(256))
-                         .setMaxReaders(1)
-                         .setMaxDbs(1)
-                         .open(dbPath.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
-      final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, comparator, nativeCb, flags);
-      dbPopulator.accept(env, dbi);
-
-      final File tests = new File("src/test/resources/CursorIterableRangeTest/tests.csv");
-      final File actual = tests.getParentFile().toPath().resolve(testName + ".actual").toFile();
-      final File expected = tests.getParentFile().toPath().resolve(testName + ".expected").toFile();
-      final String csv = readFile(tests);
-      final String[] parts = csv.split("\n");
-      try (final Writer writer = new FileWriter(actual)) {
-        for (final String part : parts) {
-          final String[] params = part.split(",");
-          final KeyRangeType keyRangeType = KeyRangeType.valueOf(params[0].trim());
-          ByteBuffer start = null;
-          ByteBuffer stop = null;
-          if (params.length > 1 && params[1].trim().length() > 0) {
-            start = bb(Integer.parseInt(params[1].trim()));
-          }
-          if (params.length > 2 && params[2].trim().length() > 0) {
-            stop = bb(Integer.parseInt(params[2].trim()));
-          }
-
-          for (int i = 0; i < 3; i++) {
-            if (params.length > i) {
-              writer.append(params[i].trim());
-            }
-            writer.append(",");
-          }
-
-          final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
-          try (Txn<ByteBuffer> txn = env.txnRead();
-               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
-            for (final KeyVal<ByteBuffer> kv : c) {
-              final int key = kv.key().getInt();
-              final int val = kv.val().getInt();
-              writer.append("[");
-              writer.append(String.valueOf(key));
-              writer.append(" ");
-              writer.append(String.valueOf(val));
-              writer.append("]");
-            }
-          }
-          writer.append("\n");
-        }
-      }
-
-      // Compare files.
-      final String act = readFile(actual);
-      final String exp = readFile(expected);
-      assertThat(act).withFailMessage("Files are not equal").isEqualTo(exp);
-    } finally {
-      FileUtil.deleteFile(dbPath);
-    }
-  }
+  //
+  //  @Test
+  //  void testSignedComparator() throws IOException {
+  //    test(ByteBuffer::compareTo, true, "testSignedComparator", 1, MDB_CREATE);
+  //  }
+  //
+  //  @Test
+  //  void testUnsignedComparator() throws IOException {
+  //    test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparator", 1, MDB_CREATE);
+  //  }
+  //
+  //  @Test
+  //  void testSignedComparatorDupsort() throws IOException {
+  //    test(ByteBuffer::compareTo, true, "testSignedComparatorDupsort", 2, MDB_CREATE,
+  // MDB_DUPSORT);
+  //  }
+  //
+  //  @Test
+  //  void testUnsignedComparatorDupsort() throws IOException {
+  //    test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparatorDupsort", 2,
+  // MDB_CREATE, MDB_DUPSORT);
+  //  }
+  //
+  //  private void test(final Comparator<ByteBuffer> comparator,
+  //                    final boolean nativeCb,
+  //                    final String testName,
+  //                    final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
+  //                    final DbiFlags... flags) throws IOException {
+  //    final Path dbPath = Files.createTempFile("test", "db");
+  //    try (final Env<ByteBuffer> env =
+  //                 create()
+  //                         .setMapSize(KIBIBYTES.toBytes(256))
+  //                         .setMaxReaders(1)
+  //                         .setMaxDbs(1)
+  //                         .open(dbPath.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
+  //      final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, comparator, nativeCb, flags);
+  //      dbPopulator.accept(env, dbi);
+  //
+  //      final File tests = new File("src/test/resources/CursorIterableRangeTest/tests.csv");
+  //      final File actual = tests.getParentFile().toPath().resolve(testName + ".actual").toFile();
+  //      final File expected = tests.getParentFile().toPath().resolve(testName +
+  // ".expected").toFile();
+  //      final String csv = readFile(tests);
+  //      final String[] parts = csv.split("\n");
+  //      try (final Writer writer = new FileWriter(actual)) {
+  //        for (final String part : parts) {
+  //          final String[] params = part.split(",");
+  //          final KeyRangeType keyRangeType = KeyRangeType.valueOf(params[0].trim());
+  //          ByteBuffer start = null;
+  //          ByteBuffer stop = null;
+  //          if (params.length > 1 && params[1].trim().length() > 0) {
+  //            start = bb(Integer.parseInt(params[1].trim()));
+  //          }
+  //          if (params.length > 2 && params[2].trim().length() > 0) {
+  //            stop = bb(Integer.parseInt(params[2].trim()));
+  //          }
+  //
+  //          for (int i = 0; i < 3; i++) {
+  //            if (params.length > i) {
+  //              writer.append(params[i].trim());
+  //            }
+  //            writer.append(",");
+  //          }
+  //
+  //          final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
+  //          try (Txn<ByteBuffer> txn = env.txnRead();
+  //               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
+  //            for (final KeyVal<ByteBuffer> kv : c) {
+  //              final int key = kv.key().getInt();
+  //              final int val = kv.val().getInt();
+  //              writer.append("[");
+  //              writer.append(String.valueOf(key));
+  //              writer.append(" ");
+  //              writer.append(String.valueOf(val));
+  //              writer.append("]");
+  //            }
+  //          }
+  //          writer.append("\n");
+  //        }
+  //      }
+  //
+  //      // Compare files.
+  //      final String act = readFile(actual);
+  //      final String exp = readFile(expected);
+  //      assertThat(act).withFailMessage("Files are not equal").isEqualTo(exp);
+  //    } finally {
+  //      FileUtil.deleteFile(dbPath);
+  //    }
+  //  }
 
   private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createBasicDBPopulator() {
     return (env, dbi) -> {
@@ -367,16 +374,15 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createLongDBPopulator() {
         c.put(bbLeLong(Long.MIN_VALUE), bb(1));
         c.put(bbLeLong(-1000), bb(2));
         c.put(bbLeLong(0), bb(3));
-        c.put(bbLeLong( 1000), bb(4));
+        c.put(bbLeLong(1000), bb(4));
         c.put(bbLeLong(Long.MAX_VALUE), bb(5));
         txn.commit();
       }
     };
   }
 
-  private void populateDatabase(final Env<ByteBuffer> env,
-                                final Dbi<ByteBuffer> dbi,
-                                final int copies) {
+  private void populateDatabase(
+      final Env<ByteBuffer> env, final Dbi<ByteBuffer> dbi, final int copies) {
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       for (int i = 0; i < copies; i++) {
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 9cceb437..5e515fee 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -48,7 +48,6 @@
 
 import com.google.common.primitives.UnsignedBytes;
 import java.nio.ByteBuffer;
-import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Deque;
@@ -64,20 +63,20 @@
 /** Test {@link CursorIterable}. */
 public final class CursorIterableTest {
 
-  private Path file;
+  private TempDir tempDir;
   private Dbi<ByteBuffer> db;
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
   @BeforeEach
   void beforeEach() {
-    file = FileUtil.createTempFile();
+    tempDir = new TempDir();
     env =
         create()
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
             .setMaxDbs(1)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .open(tempDir.createTempFile().toFile(), POSIX_MODE, MDB_NOSUBDIR);
     db = env.openDbi(DB_1, MDB_CREATE);
     populateDatabase(db);
   }
@@ -98,7 +97,7 @@ private void populateDatabase(final Dbi<ByteBuffer> dbi) {
   @AfterEach
   void afterEach() {
     env.close();
-    FileUtil.deleteFile(file);
+    tempDir.cleanup();
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 1a3604be..7f0bad8a 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -58,7 +58,8 @@ public final class CursorParamTest {
 
   static Stream<Arguments> data() {
     return Stream.of(
-        Arguments.argumentSet("ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
+        Arguments.argumentSet(
+            "ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
         Arguments.argumentSet("ByteBufferRunner(PROXY_SAFE)", new ByteBufferRunner(PROXY_SAFE)),
         Arguments.argumentSet("ByteArrayRunner(PROXY_BA)", new ByteArrayRunner(PROXY_BA)),
         Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index f44a9a44..530b2e80 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -54,12 +54,13 @@
 /** Test {@link Cursor}. */
 public final class CursorTest {
 
-  private Path file;
   private Env<ByteBuffer> env;
+  private TempDir tempDir;
 
   @BeforeEach
   void beforeEach() {
-    file = FileUtil.createTempFile();
+    tempDir = new TempDir();
+    Path file = tempDir.createTempFile();
     env =
         create(PROXY_OPTIMAL)
             .setMapSize(MEBIBYTES.toBytes(1))
@@ -71,7 +72,7 @@ void beforeEach() {
   @AfterEach
   void afterEach() {
     env.close();
-    FileUtil.deleteFile(file);
+    tempDir.cleanup();
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index cb106550..2c4a90b7 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -62,21 +62,21 @@
 /** Test {@link Dbi}. */
 public final class DbiTest {
 
-  private Path file;
+  private TempDir tempDir;
   private Env<ByteBuffer> env;
-  private Path fileBa;
   private Env<byte[]> envBa;
 
   @BeforeEach
   void beforeEach() {
-    file = FileUtil.createTempFile();
+    tempDir = new TempDir();
+    final Path file = tempDir.createTempFile();
     env =
         create()
             .setMapSize(MEBIBYTES.toBytes(64))
             .setMaxReaders(2)
             .setMaxDbs(2)
             .open(file.toFile(), MDB_NOSUBDIR);
-    fileBa = FileUtil.createTempFile();
+    final Path fileBa = tempDir.createTempFile();
     envBa =
         create(PROXY_BA)
             .setMapSize(MEBIBYTES.toBytes(64))
@@ -89,8 +89,7 @@ void beforeEach() {
   void afterEach() {
     env.close();
     envBa.close();
-    FileUtil.deleteFile(file);
-    FileUtil.deleteFile(fileBa);
+    tempDir.cleanup();
   }
 
   @Test
@@ -362,26 +361,24 @@ void putCommitGet() {
 
   @Test
   void putCommitGetByteArray() {
-    FileUtil.useTempFile(
-        file -> {
-          try (Env<byte[]> envBa =
-              create(PROXY_BA)
-                  .setMapSize(MEBIBYTES.toBytes(64))
-                  .setMaxReaders(1)
-                  .setMaxDbs(2)
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
-            final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
-            try (Txn<byte[]> txn = envBa.txnWrite()) {
-              db.put(txn, ba(5), ba(5));
-              txn.commit();
-            }
-            try (Txn<byte[]> txn = envBa.txnWrite()) {
-              final byte[] found = db.get(txn, ba(5));
-              assertThat(found).isNotNull();
-              assertThat(fromBa(txn.val())).isEqualTo(5);
-            }
-          }
-        });
+    final Path file = tempDir.createTempFile();
+    try (Env<byte[]> envBa =
+        create(PROXY_BA)
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(1)
+            .setMaxDbs(2)
+            .open(file.toFile(), MDB_NOSUBDIR)) {
+      final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
+      try (Txn<byte[]> txn = envBa.txnWrite()) {
+        db.put(txn, ba(5), ba(5));
+        txn.commit();
+      }
+      try (Txn<byte[]> txn = envBa.txnWrite()) {
+        final byte[] found = db.get(txn, ba(5));
+        assertThat(found).isNotNull();
+        assertThat(fromBa(txn.val())).isEqualTo(5);
+      }
+    }
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 904159bb..d66aa3a3 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -37,43 +37,49 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Random;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.lmdbjava.Env.AlreadyClosedException;
-import org.lmdbjava.Env.AlreadyOpenException;
-import org.lmdbjava.Env.Builder;
-import org.lmdbjava.Env.InvalidCopyDestination;
-import org.lmdbjava.Env.MapFullException;
+import org.lmdbjava.Env.*;
 import org.lmdbjava.Txn.BadReaderLockException;
 
 /** Test {@link Env}. */
 public final class EnvTest {
 
+  private TempDir tempDir;
+
+  @BeforeEach
+  void beforeEach() {
+    tempDir = new TempDir();
+  }
+
+  @AfterEach
+  void afterEach() {
+    tempDir.cleanup();
+  }
+
   @Test
   void byteUnit() {
-    FileUtil.useTempFile(
-        file -> {
-          try (Env<ByteBuffer> env =
-              create()
-                  .setMaxReaders(1)
-                  .setMapSize(MEBIBYTES.toBytes(1))
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
-            final EnvInfo info = env.info();
-            assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
-          }
-        });
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        create()
+            .setMaxReaders(1)
+            .setMapSize(MEBIBYTES.toBytes(1))
+            .open(file.toFile(), MDB_NOSUBDIR)) {
+      final EnvInfo info = env.info();
+      assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
+    }
   }
 
   @Test
   void cannotChangeMapSizeAfterOpen() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
-                      builder.setMapSize(1);
-                    }
-                  });
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                builder.setMapSize(1);
+              }
             })
         .isInstanceOf(AlreadyOpenException.class);
   }
@@ -82,13 +88,11 @@ void cannotChangeMapSizeAfterOpen() {
   void cannotChangeMaxDbsAfterOpen() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
-                      builder.setMaxDbs(1);
-                    }
-                  });
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                builder.setMaxDbs(1);
+              }
             })
         .isInstanceOf(AlreadyOpenException.class);
   }
@@ -97,13 +101,11 @@ void cannotChangeMaxDbsAfterOpen() {
   void cannotChangeMaxReadersAfterOpen() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
-                      builder.setMaxReaders(1);
-                    }
-                  });
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                builder.setMaxReaders(1);
+              }
             })
         .isInstanceOf(AlreadyOpenException.class);
   }
@@ -112,13 +114,11 @@ void cannotChangeMaxReadersAfterOpen() {
   void cannotInfoOnceClosed() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
-                    env.close();
-                    env.info();
-                  });
+              final Path file = tempDir.createTempFile();
+              final Env<ByteBuffer> env =
+                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+              env.close();
+              env.info();
             })
         .isInstanceOf(AlreadyClosedException.class);
   }
@@ -127,12 +127,10 @@ void cannotInfoOnceClosed() {
   void cannotOpenTwice() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    builder.open(file.toFile(), MDB_NOSUBDIR).close();
-                    builder.open(file.toFile(), MDB_NOSUBDIR);
-                  });
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+              builder.open(file.toFile(), MDB_NOSUBDIR).close();
+              builder.open(file.toFile(), MDB_NOSUBDIR);
             })
         .isInstanceOf(AlreadyOpenException.class);
   }
@@ -153,13 +151,11 @@ void cannotOverflowMapSize() {
   void cannotStatOnceClosed() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
-                    env.close();
-                    env.stat();
-                  });
+              final Path file = tempDir.createTempFile();
+              final Env<ByteBuffer> env =
+                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+              env.close();
+              env.stat();
             })
         .isInstanceOf(AlreadyClosedException.class);
   }
@@ -168,48 +164,38 @@ void cannotStatOnceClosed() {
   void cannotSyncOnceClosed() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
-                    env.close();
-                    env.sync(false);
-                  });
+              final Path file = tempDir.createTempFile();
+              final Env<ByteBuffer> env =
+                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+              env.close();
+              env.sync(false);
             })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void copyDirectoryBased() {
-    FileUtil.useTempDir(
-        dest -> {
-          assertThat(Files.exists(dest)).isTrue();
-          assertThat(Files.isDirectory(dest)).isTrue();
-          assertThat(FileUtil.count(dest)).isEqualTo(0);
-          FileUtil.useTempDir(
-              src -> {
-                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-                  env.copy(dest.toFile(), MDB_CP_COMPACT);
-                  assertThat(FileUtil.count(dest)).isEqualTo(1);
-                }
-              });
-        });
+    final Path dest = tempDir.createTempDir();
+    assertThat(Files.exists(dest)).isTrue();
+    assertThat(Files.isDirectory(dest)).isTrue();
+    assertThat(FileUtil.count(dest)).isEqualTo(0);
+    final Path src = tempDir.createTempDir();
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
+      env.copy(dest.toFile(), MDB_CP_COMPACT);
+      assertThat(FileUtil.count(dest)).isEqualTo(1);
+    }
   }
 
   @Test
   void copyDirectoryRejectsFileDestination() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempDir(
-                  dest -> {
-                    FileUtil.deleteDir(dest);
-                    FileUtil.useTempDir(
-                        src -> {
-                          try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-                            env.copy(dest.toFile(), MDB_CP_COMPACT);
-                          }
-                        });
-                  });
+              final Path dest = tempDir.createTempDir();
+              FileUtil.deleteDir(dest);
+              final Path src = tempDir.createTempDir();
+              try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
+                env.copy(dest.toFile(), MDB_CP_COMPACT);
+              }
             })
         .isInstanceOf(InvalidCopyDestination.class);
   }
@@ -218,21 +204,16 @@ void copyDirectoryRejectsFileDestination() {
   void copyDirectoryRejectsMissingDestination() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempDir(
-                  dest -> {
-                    try {
-                      Files.delete(dest);
-                      FileUtil.useTempDir(
-                          src -> {
-                            try (Env<ByteBuffer> env =
-                                create().setMaxReaders(1).open(src.toFile())) {
-                              env.copy(dest.toFile(), MDB_CP_COMPACT);
-                            }
-                          });
-                    } catch (final IOException e) {
-                      throw new UncheckedIOException(e);
-                    }
-                  });
+              final Path dest = tempDir.createTempDir();
+              try {
+                Files.delete(dest);
+                final Path src = tempDir.createTempDir();
+                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
+                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                }
+              } catch (final IOException e) {
+                throw new UncheckedIOException(e);
+              }
             })
         .isInstanceOf(InvalidCopyDestination.class);
   }
@@ -241,260 +222,227 @@ void copyDirectoryRejectsMissingDestination() {
   void copyDirectoryRejectsNonEmptyDestination() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempDir(
-                  dest -> {
-                    try {
-                      final Path subDir = dest.resolve("hello");
-                      Files.createDirectory(subDir);
-                      assertThat(Files.isDirectory(subDir)).isTrue();
-                      FileUtil.useTempDir(
-                          src -> {
-                            try (Env<ByteBuffer> env =
-                                create().setMaxReaders(1).open(src.toFile())) {
-                              env.copy(dest.toFile(), MDB_CP_COMPACT);
-                            }
-                          });
-                    } catch (final IOException e) {
-                      throw new UncheckedIOException(e);
-                    }
-                  });
+              final Path dest = tempDir.createTempDir();
+              try {
+                final Path subDir = dest.resolve("hello");
+                Files.createDirectory(subDir);
+                assertThat(Files.isDirectory(subDir)).isTrue();
+                final Path src = tempDir.createTempDir();
+                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
+                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                }
+              } catch (final IOException e) {
+                throw new UncheckedIOException(e);
+              }
             })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
   void copyFileBased() {
-    FileUtil.useTempFile(
-        dest -> {
-          FileUtil.deleteFile(dest);
-          assertThat(Files.exists(dest)).isFalse();
-          FileUtil.useTempFile(
-              src -> {
-                try (Env<ByteBuffer> env =
-                    create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
-                  env.copy(dest.toFile(), MDB_CP_COMPACT);
-                }
-                assertThat(FileUtil.size(dest)).isGreaterThan(0L);
-              });
-        });
+    final Path dest = tempDir.createTempFile();
+    assertThat(Files.exists(dest)).isFalse();
+    final Path src = tempDir.createTempFile();
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+      env.copy(dest.toFile(), MDB_CP_COMPACT);
+    }
+    assertThat(FileUtil.size(dest)).isGreaterThan(0L);
   }
 
   @Test
   void copyFileRejectsExistingDestination() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  dest -> {
-                    assertThat(Files.exists(dest)).isTrue();
-                    FileUtil.useTempFile(
-                        src -> {
-                          try (Env<ByteBuffer> env =
-                              create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
-                            env.copy(dest.toFile(), MDB_CP_COMPACT);
-                          }
-                        });
-                  });
+              final Path dest = tempDir.createTempFile();
+              Files.createFile(dest);
+              assertThat(Files.exists(dest)).isTrue();
+              final Path src = tempDir.createTempFile();
+              try (Env<ByteBuffer> env =
+                  create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                env.copy(dest.toFile(), MDB_CP_COMPACT);
+              }
             })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
   void createAsDirectory() {
-    FileUtil.useTempDir(
-        dest -> {
-          final Env<ByteBuffer> env = create().setMaxReaders(1).open(dest.toFile());
-          assertThat(Files.isDirectory(dest)).isTrue();
-          env.sync(false);
-          env.close();
-          assertThat(env.isClosed()).isTrue();
-          env.close(); // safe to repeat
-        });
+    final Path dest = tempDir.createTempDir();
+    final Env<ByteBuffer> env = create().setMaxReaders(1).open(dest.toFile());
+    assertThat(Files.isDirectory(dest)).isTrue();
+    env.sync(false);
+    env.close();
+    assertThat(env.isClosed()).isTrue();
+    env.close(); // safe to repeat
   }
 
   @Test
   void createAsFile() {
-    FileUtil.useTempFile(
-        file -> {
-          try (Env<ByteBuffer> env =
-              create()
-                  .setMapSize(MEBIBYTES.toBytes(1))
-                  .setMaxDbs(1)
-                  .setMaxReaders(1)
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
-            env.sync(true);
-            assertThat(Files.isRegularFile(file)).isTrue();
-          }
-        });
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        create()
+            .setMapSize(MEBIBYTES.toBytes(1))
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .open(file.toFile(), MDB_NOSUBDIR)) {
+      env.sync(true);
+      assertThat(Files.isRegularFile(file)).isTrue();
+    }
   }
 
   @Test
   void detectTransactionThreadViolation() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    try (Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
-                      env.txnRead();
-                      env.txnRead();
-                    }
-                  });
+              final Path file = tempDir.createTempFile();
+              try (Env<ByteBuffer> env =
+                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+                env.txnRead();
+                env.txnRead();
+              }
             })
         .isInstanceOf(BadReaderLockException.class);
   }
 
   @Test
   void info() {
-    FileUtil.useTempFile(
-        file -> {
-          try (Env<ByteBuffer> env =
-              create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
-            final EnvInfo info = env.info();
-            assertThat(info).isNotNull();
-            assertThat(info.lastPageNumber).isEqualTo(1L);
-            assertThat(info.lastTransactionId).isEqualTo(0L);
-            assertThat(info.mapAddress).isEqualTo(0L);
-            assertThat(info.mapSize).isEqualTo(123_456L);
-            assertThat(info.maxReaders).isEqualTo(4);
-            assertThat(info.numReaders).isEqualTo(0);
-            assertThat(info.toString()).contains("maxReaders=");
-            assertThat(env.getMaxKeySize()).isEqualTo(511);
-          }
-        });
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
+      final EnvInfo info = env.info();
+      assertThat(info).isNotNull();
+      assertThat(info.lastPageNumber).isEqualTo(1L);
+      assertThat(info.lastTransactionId).isEqualTo(0L);
+      assertThat(info.mapAddress).isEqualTo(0L);
+      assertThat(info.mapSize).isEqualTo(123_456L);
+      assertThat(info.maxReaders).isEqualTo(4);
+      assertThat(info.numReaders).isEqualTo(0);
+      assertThat(info.toString()).contains("maxReaders=");
+      assertThat(env.getMaxKeySize()).isEqualTo(511);
+    }
   }
 
   @Test
   void mapFull() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempDir(
-                  dir -> {
-                    final byte[] k = new byte[500];
-                    final ByteBuffer key = allocateDirect(500);
-                    final ByteBuffer val = allocateDirect(1_024);
-                    final Random rnd = new Random();
-                    try (Env<ByteBuffer> env =
-                        create()
-                            .setMaxReaders(1)
-                            .setMapSize(MEBIBYTES.toBytes(8))
-                            .setMaxDbs(1)
-                            .open(dir.toFile())) {
-                      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-                      for (; ; ) {
-                        rnd.nextBytes(k);
-                        key.clear();
-                        key.put(k).flip();
-                        val.clear();
-                        db.put(key, val);
-                      }
-                    }
-                  });
+              final Path dir = tempDir.createTempDir();
+              final byte[] k = new byte[500];
+              final ByteBuffer key = allocateDirect(500);
+              final ByteBuffer val = allocateDirect(1_024);
+              final Random rnd = new Random();
+              try (Env<ByteBuffer> env =
+                  create()
+                      .setMaxReaders(1)
+                      .setMapSize(MEBIBYTES.toBytes(8))
+                      .setMaxDbs(1)
+                      .open(dir.toFile())) {
+                final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                for (; ; ) {
+                  rnd.nextBytes(k);
+                  key.clear();
+                  key.put(k).flip();
+                  val.clear();
+                  db.put(key, val);
+                }
+              }
             })
         .isInstanceOf(MapFullException.class);
   }
 
   @Test
   void readOnlySupported() {
-    FileUtil.useTempDir(
-        dir -> {
-          try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(dir.toFile())) {
-            final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
-            rwDb.put(bb(1), bb(42));
-          }
-          try (Env<ByteBuffer> roEnv =
-              create().setMaxReaders(1).open(dir.toFile(), MDB_RDONLY_ENV)) {
-            final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
-            try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
-              assertThat(roDb.get(roTxn, bb(1))).isNotNull();
-            }
-          }
-        });
+    final Path dir = tempDir.createTempDir();
+    try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(dir.toFile())) {
+      final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
+      rwDb.put(bb(1), bb(42));
+    }
+    try (Env<ByteBuffer> roEnv = create().setMaxReaders(1).open(dir.toFile(), MDB_RDONLY_ENV)) {
+      final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
+      try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
+        assertThat(roDb.get(roTxn, bb(1))).isNotNull();
+      }
+    }
   }
 
   @Test
   void setMapSize() {
-    FileUtil.useTempDir(
-        dir -> {
-          final byte[] k = new byte[500];
-          final ByteBuffer key = allocateDirect(500);
-          final ByteBuffer val = allocateDirect(1_024);
-          final Random rnd = new Random();
-          try (Env<ByteBuffer> env =
-              create()
-                  .setMaxReaders(1)
-                  .setMapSize(KIBIBYTES.toBytes(256))
-                  .setMaxDbs(1)
-                  .open(dir.toFile())) {
-            final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-
-            db.put(bb(1), bb(42));
-            boolean mapFullExThrown = false;
-            try {
-              for (int i = 0; i < 70; i++) {
-                rnd.nextBytes(k);
-                key.clear();
-                key.put(k).flip();
-                val.clear();
-                db.put(key, val);
-              }
-            } catch (final MapFullException mfE) {
-              mapFullExThrown = true;
-            }
-            assertThat(mapFullExThrown).isTrue();
-
-            env.setMapSize(KIBIBYTES.toBytes(1024));
-
-            try (Txn<ByteBuffer> roTxn = env.txnRead()) {
-              final ByteBuffer byteBuffer = db.get(roTxn, bb(1));
-              assertThat(byteBuffer).isNotNull();
-              assertThat(byteBuffer.getInt()).isEqualTo(42);
-            }
-
-            mapFullExThrown = false;
-            try {
-              for (int i = 0; i < 70; i++) {
-                rnd.nextBytes(k);
-                key.clear();
-                key.put(k).flip();
-                val.clear();
-                db.put(key, val);
-              }
-            } catch (final MapFullException mfE) {
-              mapFullExThrown = true;
-            }
-            assertThat(mapFullExThrown).isFalse();
-          }
-        });
+    final Path dir = tempDir.createTempDir();
+    final byte[] k = new byte[500];
+    final ByteBuffer key = allocateDirect(500);
+    final ByteBuffer val = allocateDirect(1_024);
+    final Random rnd = new Random();
+    try (Env<ByteBuffer> env =
+        create()
+            .setMaxReaders(1)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxDbs(1)
+            .open(dir.toFile())) {
+      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+      db.put(bb(1), bb(42));
+      boolean mapFullExThrown = false;
+      try {
+        for (int i = 0; i < 70; i++) {
+          rnd.nextBytes(k);
+          key.clear();
+          key.put(k).flip();
+          val.clear();
+          db.put(key, val);
+        }
+      } catch (final MapFullException mfE) {
+        mapFullExThrown = true;
+      }
+      assertThat(mapFullExThrown).isTrue();
+
+      env.setMapSize(KIBIBYTES.toBytes(1024));
+
+      try (Txn<ByteBuffer> roTxn = env.txnRead()) {
+        final ByteBuffer byteBuffer = db.get(roTxn, bb(1));
+        assertThat(byteBuffer).isNotNull();
+        assertThat(byteBuffer.getInt()).isEqualTo(42);
+      }
+
+      mapFullExThrown = false;
+      try {
+        for (int i = 0; i < 70; i++) {
+          rnd.nextBytes(k);
+          key.clear();
+          key.put(k).flip();
+          val.clear();
+          db.put(key, val);
+        }
+      } catch (final MapFullException mfE) {
+        mapFullExThrown = true;
+      }
+      assertThat(mapFullExThrown).isFalse();
+    }
   }
 
   @Test
   void stats() {
-    FileUtil.useTempFile(
-        file -> {
-          try (Env<ByteBuffer> env = create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
-            final Stat stat = env.stat();
-            assertThat(stat).isNotNull();
-            assertThat(stat.branchPages).isEqualTo(0L);
-            assertThat(stat.depth).isEqualTo(0);
-            assertThat(stat.entries).isEqualTo(0L);
-            assertThat(stat.leafPages).isEqualTo(0L);
-            assertThat(stat.overflowPages).isEqualTo(0L);
-            assertThat(stat.pageSize % 4_096).isEqualTo(0);
-            assertThat(stat.toString()).contains("pageSize=");
-          }
-        });
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+      final Stat stat = env.stat();
+      assertThat(stat).isNotNull();
+      assertThat(stat.branchPages).isEqualTo(0L);
+      assertThat(stat.depth).isEqualTo(0);
+      assertThat(stat.entries).isEqualTo(0L);
+      assertThat(stat.leafPages).isEqualTo(0L);
+      assertThat(stat.overflowPages).isEqualTo(0L);
+      assertThat(stat.pageSize % 4_096).isEqualTo(0);
+      assertThat(stat.toString()).contains("pageSize=");
+    }
   }
 
   @Test
   void testDefaultOpen() {
-    FileUtil.useTempDir(
-        dir -> {
-          try (Env<ByteBuffer> env = open(dir.toFile(), 10)) {
-            final EnvInfo info = env.info();
-            assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
-            final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
-            db.put(allocateDirect(1), allocateDirect(1));
-          }
-        });
+    final Path dir = tempDir.createTempDir();
+    try (Env<ByteBuffer> env = open(dir.toFile(), 10)) {
+      final EnvInfo info = env.info();
+      assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
+      final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
+      db.put(allocateDirect(1), allocateDirect(1));
+    }
   }
 }
diff --git a/src/test/java/org/lmdbjava/FileUtil.java b/src/test/java/org/lmdbjava/FileUtil.java
index 2343c670..cc7ed635 100644
--- a/src/test/java/org/lmdbjava/FileUtil.java
+++ b/src/test/java/org/lmdbjava/FileUtil.java
@@ -25,53 +25,12 @@
 import java.nio.file.Path;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.EnumSet;
-import java.util.function.Consumer;
 import java.util.stream.Stream;
 
 final class FileUtil {
 
   private FileUtil() {}
 
-  static Path createTempDir() {
-    try {
-      return Files.createTempDirectory("lmdbjava");
-    } catch (final IOException e) {
-      throw new UncheckedIOException(e);
-    }
-  }
-
-  static Path createTempFile() {
-    try {
-      return Files.createTempFile("lmdbjava", "db");
-    } catch (final IOException e) {
-      throw new UncheckedIOException(e);
-    }
-  }
-
-  static void useTempDir(final Consumer<Path> consumer) {
-    Path path = null;
-    try {
-      path = createTempDir();
-      consumer.accept(path);
-    } finally {
-      if (path != null) {
-        deleteDir(path);
-      }
-    }
-  }
-
-  static void useTempFile(final Consumer<Path> consumer) {
-    Path path = null;
-    try {
-      path = createTempFile();
-      consumer.accept(path);
-    } finally {
-      if (path != null) {
-        deleteIfExists(path);
-      }
-    }
-  }
-
   public static long size(final Path path) {
     try {
       return Files.size(path);
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index f0aa64e4..36273559 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -23,6 +23,7 @@
 import static org.lmdbjava.Env.create;
 
 import java.nio.ByteBuffer;
+import java.nio.file.Path;
 import org.junit.jupiter.api.Test;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
@@ -35,61 +36,61 @@ public class GarbageCollectionTest {
 
   @Test
   void buffersNotGarbageCollectedTest() {
-    FileUtil.useTempDir(
-        dir -> {
-          try (Env<ByteBuffer> env =
-              create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir.toFile())) {
-            final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+    try (final TempDir tempDir = new TempDir()) {
+      final Path dir = tempDir.createTempDir();
+      try (Env<ByteBuffer> env =
+          create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir.toFile())) {
+        final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
-            try (Txn<ByteBuffer> txn = env.txnWrite()) {
-              for (int i = 0; i < 5_000; i++) {
-                putBuffer(db, txn, i);
-              }
-              txn.commit();
-            }
+        try (Txn<ByteBuffer> txn = env.txnWrite()) {
+          for (int i = 0; i < 5_000; i++) {
+            putBuffer(db, txn, i);
+          }
+          txn.commit();
+        }
 
-            // Call GC before writing to LMDB and after last reference to buffer by
-            // changing the behavior of mask
-            try (MockedStatic<MaskedFlag> mockedStatic = Mockito.mockStatic(MaskedFlag.class)) {
-              mockedStatic
-                  .when(MaskedFlag::mask)
-                  .thenAnswer(
-                      invocationOnMock -> {
-                        System.gc();
-                        return 0;
-                      });
-              final int gcRecordWrites = Integer.getInteger("gcRecordWrites", 50);
-              try (Txn<ByteBuffer> txn = env.txnWrite()) {
-                for (int i = 0; i < gcRecordWrites; i++) {
-                  putBuffer(db, txn, i);
-                }
-                txn.commit();
-              }
+        // Call GC before writing to LMDB and after last reference to buffer by
+        // changing the behavior of mask
+        try (MockedStatic<MaskedFlag> mockedStatic = Mockito.mockStatic(MaskedFlag.class)) {
+          mockedStatic
+              .when(MaskedFlag::mask)
+              .thenAnswer(
+                  invocationOnMock -> {
+                    System.gc();
+                    return 0;
+                  });
+          final int gcRecordWrites = Integer.getInteger("gcRecordWrites", 50);
+          try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            for (int i = 0; i < gcRecordWrites; i++) {
+              putBuffer(db, txn, i);
             }
+            txn.commit();
+          }
+        }
 
-            // Find corrupt keys
-            try (Txn<ByteBuffer> txn = env.txnRead()) {
-              try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
-                if (c.first()) {
-                  do {
-                    final byte[] rkey = new byte[c.key().remaining()];
-                    c.key().get(rkey);
-                    final byte[] rval = new byte[c.val().remaining()];
-                    c.val().get(rval);
-                    final String skey = new String(rkey, UTF_8);
-                    final String sval = new String(rval, UTF_8);
-                    if (!skey.startsWith("Uncorruptedkey")) {
-                      fail("Found corrupt key " + skey);
-                    }
-                    if (!sval.startsWith("Uncorruptedval")) {
-                      fail("Found corrupt val " + sval);
-                    }
-                  } while (c.next());
+        // Find corrupt keys
+        try (Txn<ByteBuffer> txn = env.txnRead()) {
+          try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+            if (c.first()) {
+              do {
+                final byte[] rkey = new byte[c.key().remaining()];
+                c.key().get(rkey);
+                final byte[] rval = new byte[c.val().remaining()];
+                c.val().get(rval);
+                final String skey = new String(rkey, UTF_8);
+                final String sval = new String(rval, UTF_8);
+                if (!skey.startsWith("Uncorruptedkey")) {
+                  fail("Found corrupt key " + skey);
+                }
+                if (!sval.startsWith("Uncorruptedval")) {
+                  fail("Found corrupt val " + sval);
                 }
-              }
+              } while (c.next());
             }
           }
-        });
+        }
+      }
+    }
   }
 
   private void putBuffer(final Dbi<ByteBuffer> db, final Txn<ByteBuffer> txn, final int i) {
diff --git a/src/test/java/org/lmdbjava/TempDir.java b/src/test/java/org/lmdbjava/TempDir.java
new file mode 100644
index 00000000..7d2977b9
--- /dev/null
+++ b/src/test/java/org/lmdbjava/TempDir.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.UUID;
+
+public class TempDir implements AutoCloseable {
+  private final Path root;
+
+  public TempDir() {
+    try {
+      root = Files.createTempDirectory("lmdb");
+    } catch (final IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  public Path createTempFile() {
+    return root.resolve(UUID.randomUUID().toString());
+  }
+
+  public Path createTempDir() {
+    try {
+      final Path dir = root.resolve(UUID.randomUUID().toString());
+      Files.createDirectory(dir);
+      return dir;
+    } catch (final IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  public void cleanup() {
+    FileUtil.deleteDir(root);
+  }
+
+  @Override
+  public void close() {
+    cleanup();
+  }
+}
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 4c5e46ee..23606862 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -56,6 +56,15 @@ static ByteBuffer bb(final long value) {
     return bb;
   }
 
+  static byte[] getBytes(final ByteBuffer byteBuffer) {
+    if (byteBuffer == null) {
+      return null;
+    }
+    final byte[] bytes = new byte[byteBuffer.remaining()];
+    byteBuffer.duplicate().get(bytes);
+    return bytes;
+  }
+
   static void invokePrivateConstructor(final Class<?> clazz) {
     try {
       final Constructor<?> c = clazz.getDeclaredConstructor();
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 1b42b327..8376fbe7 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -27,9 +27,7 @@
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.GetOp.MDB_SET;
-import static org.lmdbjava.SeekOp.MDB_FIRST;
-import static org.lmdbjava.SeekOp.MDB_LAST;
-import static org.lmdbjava.SeekOp.MDB_PREV;
+import static org.lmdbjava.SeekOp.*;
 
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
@@ -37,6 +35,8 @@
 import org.agrona.DirectBuffer;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.lmdbjava.CursorIterable.KeyVal;
 
@@ -57,147 +57,155 @@ public final class TutorialTest {
 
   private static final String DB_NAME = "my DB";
 
+  private TempDir tempDir;
+
+  @BeforeEach
+  void beforeEach() {
+    tempDir = new TempDir();
+  }
+
+  @AfterEach
+  void afterEach() {
+    tempDir.cleanup();
+  }
+
   /** In this first tutorial we will use LmdbJava with some basic defaults. */
   @Test
   void tutorial1() {
     // We need a storage directory first.
     // The path cannot be on a remote file system.
-    FileUtil.useTempDir(
-        dir -> {
-
-          // We always need an Env. An Env owns a physical on-disk storage file. One
-          // Env can store many different databases (ie sorted maps).
-          final Env<ByteBuffer> env =
-              create()
-                  // LMDB also needs to know how large our DB might be. Over-estimating is OK.
-                  .setMapSize(10_485_760)
-                  // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
-                  .setMaxDbs(1)
-                  // Now let's open the Env. The same path can be concurrently opened and
-                  // used in different processes, but do not open the same path twice in
-                  // the same process at the same time.
-                  .open(dir.toFile());
-
-          // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
-          // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
-          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-
-          // We want to store some data, so we will need a direct ByteBuffer.
-          // Note that LMDB keys cannot exceed maxKeySize bytes (511 bytes by default).
-          // Values can be larger.
-          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-          final ByteBuffer val = allocateDirect(700);
-          key.put("greeting".getBytes(UTF_8)).flip();
-          val.put("Hello world".getBytes(UTF_8)).flip();
-          final int valSize = val.remaining();
-
-          // Now store it. Dbi.put() internally begins and commits a transaction (Txn).
-          db.put(key, val);
-
-          // To fetch any data from LMDB we need a Txn. A Txn is very important in
-          // LmdbJava because it offers ACID characteristics and internally holds a
-          // read-only key buffer and read-only value buffer. These read-only buffers
-          // are always the same two Java objects, but point to different LMDB-managed
-          // memory as we use Dbi (and Cursor) methods. These read-only buffers remain
-          // valid only until the Txn is released or the next Dbi or Cursor call. If
-          // you need data afterwards, you should copy the bytes to your own buffer.
-          try (Txn<ByteBuffer> txn = env.txnRead()) {
-            final ByteBuffer found = db.get(txn, key);
-            assertThat(found).isNotNull();
-
-            // The fetchedVal is read-only and points to LMDB memory
-            final ByteBuffer fetchedVal = txn.val();
-            assertThat(fetchedVal.remaining()).isEqualTo(valSize);
-
-            // Let's double-check the fetched value is correct
-            assertThat(UTF_8.decode(fetchedVal).toString()).isEqualTo("Hello world");
-          }
-
-          // We can also delete. The simplest way is to let Dbi allocate a new Txn...
-          db.delete(key);
-
-          // Now if we try to fetch the deleted row, it won't be present
-          try (Txn<ByteBuffer> txn = env.txnRead()) {
-            assertThat(db.get(txn, key)).isNull();
-          }
-
-          env.close();
-        });
+    final Path dir = tempDir.createTempDir();
+
+    // We always need an Env. An Env owns a physical on-disk storage file. One
+    // Env can store many different databases (ie sorted maps).
+    final Env<ByteBuffer> env =
+        create()
+            // LMDB also needs to know how large our DB might be. Over-estimating is OK.
+            .setMapSize(10_485_760)
+            // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
+            .setMaxDbs(1)
+            // Now let's open the Env. The same path can be concurrently opened and
+            // used in different processes, but do not open the same path twice in
+            // the same process at the same time.
+            .open(dir.toFile());
+
+    // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
+    // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
+    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+
+    // We want to store some data, so we will need a direct ByteBuffer.
+    // Note that LMDB keys cannot exceed maxKeySize bytes (511 bytes by default).
+    // Values can be larger.
+    final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+    final ByteBuffer val = allocateDirect(700);
+    key.put("greeting".getBytes(UTF_8)).flip();
+    val.put("Hello world".getBytes(UTF_8)).flip();
+    final int valSize = val.remaining();
+
+    // Now store it. Dbi.put() internally begins and commits a transaction (Txn).
+    db.put(key, val);
+
+    // To fetch any data from LMDB we need a Txn. A Txn is very important in
+    // LmdbJava because it offers ACID characteristics and internally holds a
+    // read-only key buffer and read-only value buffer. These read-only buffers
+    // are always the same two Java objects, but point to different LMDB-managed
+    // memory as we use Dbi (and Cursor) methods. These read-only buffers remain
+    // valid only until the Txn is released or the next Dbi or Cursor call. If
+    // you need data afterwards, you should copy the bytes to your own buffer.
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      final ByteBuffer found = db.get(txn, key);
+      assertThat(found).isNotNull();
+
+      // The fetchedVal is read-only and points to LMDB memory
+      final ByteBuffer fetchedVal = txn.val();
+      assertThat(fetchedVal.remaining()).isEqualTo(valSize);
+
+      // Let's double-check the fetched value is correct
+      assertThat(UTF_8.decode(fetchedVal).toString()).isEqualTo("Hello world");
+    }
+
+    // We can also delete. The simplest way is to let Dbi allocate a new Txn...
+    db.delete(key);
+
+    // Now if we try to fetch the deleted row, it won't be present
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      assertThat(db.get(txn, key)).isNull();
+    }
+
+    env.close();
   }
 
   /** In this second tutorial we'll learn more about LMDB's ACID Txns. */
   @Test
   void tutorial2() {
-    FileUtil.useTempDir(
-        dir -> {
-          try {
-            final Env<ByteBuffer> env = createSimpleEnv(dir);
-            final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-            final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-            final ByteBuffer val = allocateDirect(700);
-
-            // Let's write and commit "key1" via a Txn. A Txn can include multiple Dbis.
-            // Note write Txns block other write Txns, due to writes being serialized.
-            // It's therefore important to avoid unnecessarily long-lived write Txns.
+    final Path dir = tempDir.createTempDir();
+    try {
+      final Env<ByteBuffer> env = createSimpleEnv(dir);
+      final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+      final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+      final ByteBuffer val = allocateDirect(700);
+
+      // Let's write and commit "key1" via a Txn. A Txn can include multiple Dbis.
+      // Note write Txns block other write Txns, due to writes being serialized.
+      // It's therefore important to avoid unnecessarily long-lived write Txns.
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        key.put("key1".getBytes(UTF_8)).flip();
+        val.put("lmdb".getBytes(UTF_8)).flip();
+        db.put(txn, key, val);
+
+        // We can read data too, even though this is a write Txn.
+        final ByteBuffer found = db.get(txn, key);
+        assertThat(found).isNotNull();
+
+        // An explicit commit is required, otherwise Txn.close() rolls it back.
+        txn.commit();
+      }
+
+      // Open a read-only Txn. It only sees data that existed at Txn creation time.
+      final Txn<ByteBuffer> rtx = env.txnRead();
+
+      // Our read Txn can fetch key1 without problem, as it existed at Txn creation.
+      ByteBuffer found = db.get(rtx, key);
+      assertThat(found).isNotNull();
+
+      // Note that our main test thread holds the Txn. Only one Txn per thread is
+      // typically permitted (the exception is a read-only Env with MDB_NOTLS).
+      //
+      // Let's write out a "key2" via a new write Txn in a different thread.
+      final ExecutorService es = newCachedThreadPool();
+      es.execute(
+          () -> {
             try (Txn<ByteBuffer> txn = env.txnWrite()) {
-              key.put("key1".getBytes(UTF_8)).flip();
-              val.put("lmdb".getBytes(UTF_8)).flip();
+              key.clear();
+              key.put("key2".getBytes(UTF_8)).flip();
               db.put(txn, key, val);
-
-              // We can read data too, even though this is a write Txn.
-              final ByteBuffer found = db.get(txn, key);
-              assertThat(found).isNotNull();
-
-              // An explicit commit is required, otherwise Txn.close() rolls it back.
               txn.commit();
             }
-
-            // Open a read-only Txn. It only sees data that existed at Txn creation time.
-            final Txn<ByteBuffer> rtx = env.txnRead();
-
-            // Our read Txn can fetch key1 without problem, as it existed at Txn creation.
-            ByteBuffer found = db.get(rtx, key);
-            assertThat(found).isNotNull();
-
-            // Note that our main test thread holds the Txn. Only one Txn per thread is
-            // typically permitted (the exception is a read-only Env with MDB_NOTLS).
-            //
-            // Let's write out a "key2" via a new write Txn in a different thread.
-            final ExecutorService es = newCachedThreadPool();
-            es.execute(
-                () -> {
-                  try (Txn<ByteBuffer> txn = env.txnWrite()) {
-                    key.clear();
-                    key.put("key2".getBytes(UTF_8)).flip();
-                    db.put(txn, key, val);
-                    txn.commit();
-                  }
-                });
-            es.shutdown();
-            es.awaitTermination(10, SECONDS);
-
-            // Even though key2 has been committed, our read Txn still can't see it.
-            found = db.get(rtx, key);
-            assertThat(found).isNull();
-
-            // To see key2, we could create a new Txn. But a reset/renew is much faster.
-            // Reset/renew is also important to avoid long-lived read Txns, as these
-            // prevent the re-use of free pages by write Txns (ie the DB will grow).
-            rtx.reset();
-            // ... potentially long operation here ...
-            rtx.renew();
-            found = db.get(rtx, key);
-            assertThat(found).isNotNull();
-
-            // Don't forget to close the read Txn now we're completely finished. We could
-            // have avoided this if we used a try-with-resources block, but we wanted to
-            // play around with multiple concurrent Txns to demonstrate the "I" in ACID.
-            rtx.close();
-            env.close();
-          } catch (final InterruptedException e) {
-            throw new RuntimeException(e);
-          }
-        });
+          });
+      es.shutdown();
+      es.awaitTermination(10, SECONDS);
+
+      // Even though key2 has been committed, our read Txn still can't see it.
+      found = db.get(rtx, key);
+      assertThat(found).isNull();
+
+      // To see key2, we could create a new Txn. But a reset/renew is much faster.
+      // Reset/renew is also important to avoid long-lived read Txns, as these
+      // prevent the re-use of free pages by write Txns (ie the DB will grow).
+      rtx.reset();
+      // ... potentially long operation here ...
+      rtx.renew();
+      found = db.get(rtx, key);
+      assertThat(found).isNotNull();
+
+      // Don't forget to close the read Txn now we're completely finished. We could
+      // have avoided this if we used a try-with-resources block, but we wanted to
+      // play around with multiple concurrent Txns to demonstrate the "I" in ACID.
+      rtx.close();
+      env.close();
+    } catch (final InterruptedException e) {
+      throw new RuntimeException(e);
+    }
   }
 
   /**
@@ -207,73 +215,71 @@ void tutorial2() {
    */
   @Test
   void tutorial3() {
-    FileUtil.useTempDir(
-        dir -> {
-          final Env<ByteBuffer> env = createSimpleEnv(dir);
-          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-          final ByteBuffer val = allocateDirect(700);
-
-          try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            // A cursor always belongs to a particular Dbi.
-            final Cursor<ByteBuffer> c = db.openCursor(txn);
-
-            // We can put via a Cursor. Note we're adding keys in a strange order,
-            // as we want to show you that LMDB returns them in sorted order.
-            key.put("zzz".getBytes(UTF_8)).flip();
-            val.put("lmdb".getBytes(UTF_8)).flip();
-            c.put(key, val);
-            key.clear();
-            key.put("aaa".getBytes(UTF_8)).flip();
-            c.put(key, val);
-            key.clear();
-            key.put("ccc".getBytes(UTF_8)).flip();
-            c.put(key, val);
-
-            // We can read from the Cursor by key.
-            c.get(key, MDB_SET);
-            assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("ccc");
-
-            // Let's see that LMDB provides the keys in appropriate order....
-            c.seek(MDB_FIRST);
-            assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("aaa");
-
-            c.seek(MDB_LAST);
-            assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("zzz");
-
-            c.seek(MDB_PREV);
-            assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("ccc");
-
-            // Cursors can also delete the current key.
-            c.delete();
-
-            c.close();
-            txn.commit();
-          }
-
-          // A read-only Cursor can survive its original Txn being closed. This is
-          // useful if you want to close the original Txn (eg maybe you created the
-          // Cursor during the constructor of a singleton with a throw-away Txn). Of
-          // course, you cannot use the Cursor if its Txn is closed or currently reset.
-          final Txn<ByteBuffer> tx1 = env.txnRead();
-          final Cursor<ByteBuffer> c = db.openCursor(tx1);
-          tx1.close();
-
-          // The Cursor becomes usable again by "renewing" it with an active read Txn.
-          final Txn<ByteBuffer> tx2 = env.txnRead();
-          c.renew(tx2);
-          c.seek(MDB_FIRST);
-
-          // As usual with read Txns, we can reset and renew them. The Cursor does
-          // not need any special handling if we do this.
-          tx2.reset();
-          // ... potentially long operation here ...
-          tx2.renew();
-          c.seek(MDB_LAST);
-
-          tx2.close();
-          env.close();
-        });
+    final Path dir = tempDir.createTempDir();
+    final Env<ByteBuffer> env = createSimpleEnv(dir);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+    final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+    final ByteBuffer val = allocateDirect(700);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      // A cursor always belongs to a particular Dbi.
+      final Cursor<ByteBuffer> c = db.openCursor(txn);
+
+      // We can put via a Cursor. Note we're adding keys in a strange order,
+      // as we want to show you that LMDB returns them in sorted order.
+      key.put("zzz".getBytes(UTF_8)).flip();
+      val.put("lmdb".getBytes(UTF_8)).flip();
+      c.put(key, val);
+      key.clear();
+      key.put("aaa".getBytes(UTF_8)).flip();
+      c.put(key, val);
+      key.clear();
+      key.put("ccc".getBytes(UTF_8)).flip();
+      c.put(key, val);
+
+      // We can read from the Cursor by key.
+      c.get(key, MDB_SET);
+      assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("ccc");
+
+      // Let's see that LMDB provides the keys in appropriate order....
+      c.seek(MDB_FIRST);
+      assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("aaa");
+
+      c.seek(MDB_LAST);
+      assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("zzz");
+
+      c.seek(MDB_PREV);
+      assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("ccc");
+
+      // Cursors can also delete the current key.
+      c.delete();
+
+      c.close();
+      txn.commit();
+    }
+
+    // A read-only Cursor can survive its original Txn being closed. This is
+    // useful if you want to close the original Txn (eg maybe you created the
+    // Cursor during the constructor of a singleton with a throw-away Txn). Of
+    // course, you cannot use the Cursor if its Txn is closed or currently reset.
+    final Txn<ByteBuffer> tx1 = env.txnRead();
+    final Cursor<ByteBuffer> c = db.openCursor(tx1);
+    tx1.close();
+
+    // The Cursor becomes usable again by "renewing" it with an active read Txn.
+    final Txn<ByteBuffer> tx2 = env.txnRead();
+    c.renew(tx2);
+    c.seek(MDB_FIRST);
+
+    // As usual with read Txns, we can reset and renew them. The Cursor does
+    // not need any special handling if we do this.
+    tx2.reset();
+    // ... potentially long operation here ...
+    tx2.renew();
+    c.seek(MDB_LAST);
+
+    tx2.close();
+    env.close();
   }
 
   /**
@@ -282,109 +288,105 @@ void tutorial3() {
    */
   @Test
   void tutorial4() {
-    FileUtil.useTempDir(
-        dir -> {
-          final Env<ByteBuffer> env = createSimpleEnv(dir);
-          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-
-          try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-            final ByteBuffer val = allocateDirect(700);
-
-            // Insert some data. Note that ByteBuffer order defaults to Big Endian.
-            // LMDB does not persist the byte order, but it's critical to sort keys.
-            // If your numeric keys don't sort as expected, review buffer byte order.
-            val.putInt(100);
-            key.putInt(1);
-            db.put(txn, key, val);
-            key.clear();
-            key.putInt(2);
-            db.put(txn, key, val);
-            key.clear();
-
-            // Each iterable uses a cursor and must be closed when finished. Iterate
-            // forward in terms of key ordering starting with the first key.
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-              for (final KeyVal<ByteBuffer> kv : ci) {
-                assertThat(kv.key()).isNotNull();
-                assertThat(kv.val()).isNotNull();
-              }
-            }
-
-            // Iterate backward in terms of key ordering starting with the last key.
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.allBackward())) {
-              for (final KeyVal<ByteBuffer> kv : ci) {
-                assertThat(kv.key()).isNotNull();
-                assertThat(kv.val()).isNotNull();
-              }
-            }
-
-            // There are many ways to control the desired key range via KeyRange, such
-            // as arbitrary start and stop values, direction etc. We've adopted Guava's
-            // terminology for our range classes (see KeyRangeType for further details).
-            key.putInt(1);
-            final KeyRange<ByteBuffer> range = KeyRange.atLeastBackward(key);
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, range)) {
-              for (final KeyVal<ByteBuffer> kv : ci) {
-                assertThat(kv.key()).isNotNull();
-                assertThat(kv.val()).isNotNull();
-              }
-            }
-          }
-
-          env.close();
-        });
+    final Path dir = tempDir.createTempDir();
+    final Env<ByteBuffer> env = createSimpleEnv(dir);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+      final ByteBuffer val = allocateDirect(700);
+
+      // Insert some data. Note that ByteBuffer order defaults to Big Endian.
+      // LMDB does not persist the byte order, but it's critical to sort keys.
+      // If your numeric keys don't sort as expected, review buffer byte order.
+      val.putInt(100);
+      key.putInt(1);
+      db.put(txn, key, val);
+      key.clear();
+      key.putInt(2);
+      db.put(txn, key, val);
+      key.clear();
+
+      // Each iterable uses a cursor and must be closed when finished. Iterate
+      // forward in terms of key ordering starting with the first key.
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
+          assertThat(kv.key()).isNotNull();
+          assertThat(kv.val()).isNotNull();
+        }
+      }
+
+      // Iterate backward in terms of key ordering starting with the last key.
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.allBackward())) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
+          assertThat(kv.key()).isNotNull();
+          assertThat(kv.val()).isNotNull();
+        }
+      }
+
+      // There are many ways to control the desired key range via KeyRange, such
+      // as arbitrary start and stop values, direction etc. We've adopted Guava's
+      // terminology for our range classes (see KeyRangeType for further details).
+      key.putInt(1);
+      final KeyRange<ByteBuffer> range = KeyRange.atLeastBackward(key);
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, range)) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
+          assertThat(kv.key()).isNotNull();
+          assertThat(kv.val()).isNotNull();
+        }
+      }
+    }
+
+    env.close();
   }
 
   /** In this fifth tutorial we'll explore multiple values sharing a single key. */
   @Test
   void tutorial5() {
-    FileUtil.useTempDir(
-        dir -> {
-          final Env<ByteBuffer> env = createSimpleEnv(dir);
-
-          // This time we're going to tell the Dbi it can store > 1 value per key.
-          // There are other flags available if we're storing integers etc.
-          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE, MDB_DUPSORT);
-
-          // Duplicate support requires both keys and values to be <= max key size.
-          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-          final ByteBuffer val = allocateDirect(env.getMaxKeySize());
-
-          try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            final Cursor<ByteBuffer> c = db.openCursor(txn);
-
-            // Store one key, but many values, and in non-natural order.
-            key.put("key".getBytes(UTF_8)).flip();
-            val.put("xxx".getBytes(UTF_8)).flip();
-            c.put(key, val);
-            val.clear();
-            val.put("kkk".getBytes(UTF_8)).flip();
-            c.put(key, val);
-            val.clear();
-            val.put("lll".getBytes(UTF_8)).flip();
-            c.put(key, val);
-
-            // Cursor can tell us how many values the current key has.
-            final long count = c.count();
-            assertThat(count).isEqualTo(3L);
-
-            // Let's position the Cursor. Note sorting still works.
-            c.seek(MDB_FIRST);
-            assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("kkk");
-
-            c.seek(MDB_LAST);
-            assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("xxx");
-
-            c.seek(MDB_PREV);
-            assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("lll");
-
-            c.close();
-            txn.commit();
-          }
-
-          env.close();
-        });
+    final Path dir = tempDir.createTempDir();
+    final Env<ByteBuffer> env = createSimpleEnv(dir);
+
+    // This time we're going to tell the Dbi it can store > 1 value per key.
+    // There are other flags available if we're storing integers etc.
+    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE, MDB_DUPSORT);
+
+    // Duplicate support requires both keys and values to be <= max key size.
+    final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+    final ByteBuffer val = allocateDirect(env.getMaxKeySize());
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = db.openCursor(txn);
+
+      // Store one key, but many values, and in non-natural order.
+      key.put("key".getBytes(UTF_8)).flip();
+      val.put("xxx".getBytes(UTF_8)).flip();
+      c.put(key, val);
+      val.clear();
+      val.put("kkk".getBytes(UTF_8)).flip();
+      c.put(key, val);
+      val.clear();
+      val.put("lll".getBytes(UTF_8)).flip();
+      c.put(key, val);
+
+      // Cursor can tell us how many values the current key has.
+      final long count = c.count();
+      assertThat(count).isEqualTo(3L);
+
+      // Let's position the Cursor. Note sorting still works.
+      c.seek(MDB_FIRST);
+      assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("kkk");
+
+      c.seek(MDB_LAST);
+      assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("xxx");
+
+      c.seek(MDB_PREV);
+      assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("lll");
+
+      c.close();
+      txn.commit();
+    }
+
+    env.close();
   }
 
   /**
@@ -393,85 +395,79 @@ void tutorial5() {
    */
   @Test
   void tutorial6() {
-    FileUtil.useTempDir(
-        dir -> {
-          // Note we need to specify the Verifier's DBI_COUNT for the Env.
-          final Env<ByteBuffer> env =
-              create(PROXY_OPTIMAL)
-                  .setMapSize(10_485_760)
-                  .setMaxDbs(Verifier.DBI_COUNT)
-                  .open(dir.toFile());
-
-          // Create a Verifier (it's a Callable<Long> for those needing full control).
-          final Verifier v = new Verifier(env);
-
-          // We now run the verifier for 3 seconds; it raises an exception on failure.
-          // The method returns the number of entries it successfully verified.
-          v.runFor(3, SECONDS);
-
-          env.close();
-        });
+    final Path dir = tempDir.createTempDir();
+    // Note we need to specify the Verifier's DBI_COUNT for the Env.
+    final Env<ByteBuffer> env =
+        create(PROXY_OPTIMAL)
+            .setMapSize(10_485_760)
+            .setMaxDbs(Verifier.DBI_COUNT)
+            .open(dir.toFile());
+
+    // Create a Verifier (it's a Callable<Long> for those needing full control).
+    final Verifier v = new Verifier(env);
+
+    // We now run the verifier for 3 seconds; it raises an exception on failure.
+    // The method returns the number of entries it successfully verified.
+    v.runFor(3, SECONDS);
+
+    env.close();
   }
 
   /** In this final tutorial we'll look at using Agrona's DirectBuffer. */
   @Test
   void tutorial7() {
-    FileUtil.useTempDir(
-        dir -> {
-          // The critical difference is we pass the PROXY_DB field to Env.create().
-          // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
-          // Aside from that and a different type argument, it's the same as usual...
-          final Env<DirectBuffer> env =
-              create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir.toFile());
-
-          final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-
-          final ByteBuffer keyBb = allocateDirect(env.getMaxKeySize());
-          final MutableDirectBuffer key = new UnsafeBuffer(keyBb);
-          final MutableDirectBuffer val = new UnsafeBuffer(allocateDirect(700));
-
-          try (Txn<DirectBuffer> txn = env.txnWrite()) {
-            try (Cursor<DirectBuffer> c = db.openCursor(txn)) {
-              // Agrona is faster than ByteBuffer and its methods are nicer...
-              val.putStringWithoutLengthUtf8(0, "The Value");
-              key.putStringWithoutLengthUtf8(0, "yyy");
-              c.put(key, val);
-
-              key.putStringWithoutLengthUtf8(0, "ggg");
-              c.put(key, val);
-
-              c.seek(MDB_FIRST);
-              assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize()))
-                  .startsWith("ggg");
-
-              c.seek(MDB_LAST);
-              assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize()))
-                  .startsWith("yyy");
-
-              // DirectBuffer has no position concept. Often you don't want to store
-              // the unnecessary bytes of a varying-size buffer. Let's have a look...
-              final int keyLen = key.putStringWithoutLengthUtf8(0, "12characters");
-              assertThat(keyLen).isEqualTo(12);
-              assertThat(key.capacity()).isEqualTo(env.getMaxKeySize());
-
-              // To only store the 12 characters, we simply call wrap:
-              key.wrap(key, 0, keyLen);
-              assertThat(key.capacity()).isEqualTo(keyLen);
-              c.put(key, val);
-              c.seek(MDB_FIRST);
-              assertThat(c.key().capacity()).isEqualTo(keyLen);
-              assertThat(c.key().getStringWithoutLengthUtf8(0, c.key().capacity()))
-                  .isEqualTo("12characters");
-
-              // To store bigger values again, just wrap the original buffer.
-              key.wrap(keyBb);
-              assertThat(key.capacity()).isEqualTo(env.getMaxKeySize());
-            }
-            txn.commit();
-          }
-
-          env.close();
-        });
+    final Path dir = tempDir.createTempDir();
+    // The critical difference is we pass the PROXY_DB field to Env.create().
+    // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
+    // Aside from that and a different type argument, it's the same as usual...
+    final Env<DirectBuffer> env =
+        create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir.toFile());
+
+    final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+
+    final ByteBuffer keyBb = allocateDirect(env.getMaxKeySize());
+    final MutableDirectBuffer key = new UnsafeBuffer(keyBb);
+    final MutableDirectBuffer val = new UnsafeBuffer(allocateDirect(700));
+
+    try (Txn<DirectBuffer> txn = env.txnWrite()) {
+      try (Cursor<DirectBuffer> c = db.openCursor(txn)) {
+        // Agrona is faster than ByteBuffer and its methods are nicer...
+        val.putStringWithoutLengthUtf8(0, "The Value");
+        key.putStringWithoutLengthUtf8(0, "yyy");
+        c.put(key, val);
+
+        key.putStringWithoutLengthUtf8(0, "ggg");
+        c.put(key, val);
+
+        c.seek(MDB_FIRST);
+        assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize())).startsWith("ggg");
+
+        c.seek(MDB_LAST);
+        assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize())).startsWith("yyy");
+
+        // DirectBuffer has no position concept. Often you don't want to store
+        // the unnecessary bytes of a varying-size buffer. Let's have a look...
+        final int keyLen = key.putStringWithoutLengthUtf8(0, "12characters");
+        assertThat(keyLen).isEqualTo(12);
+        assertThat(key.capacity()).isEqualTo(env.getMaxKeySize());
+
+        // To only store the 12 characters, we simply call wrap:
+        key.wrap(key, 0, keyLen);
+        assertThat(key.capacity()).isEqualTo(keyLen);
+        c.put(key, val);
+        c.seek(MDB_FIRST);
+        assertThat(c.key().capacity()).isEqualTo(keyLen);
+        assertThat(c.key().getStringWithoutLengthUtf8(0, c.key().capacity()))
+            .isEqualTo("12characters");
+
+        // To store bigger values again, just wrap the original buffer.
+        key.wrap(keyBb);
+        assertThat(key.capacity()).isEqualTo(env.getMaxKeySize());
+      }
+      txn.commit();
+    }
+
+    env.close();
   }
 
   // You've finished! There are lots of other neat things we could show you (eg
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index b2f04ff6..ebb06137 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -35,7 +35,6 @@
 import static org.lmdbjava.Txn.State.RESET;
 import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
-import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.ArrayList;
@@ -60,9 +59,12 @@ public final class TxnTest {
   private Path file;
   private Env<ByteBuffer> env;
 
+  private TempDir tempDir;
+
   @BeforeEach
   void beforeEach() {
-    file = FileUtil.createTempFile();
+    tempDir = new TempDir();
+    file = tempDir.createTempFile();
     env =
         create()
             .setMapSize(KIBIBYTES.toBytes(256))
@@ -74,11 +76,11 @@ void beforeEach() {
   @AfterEach
   void afterEach() {
     env.close();
-    FileUtil.deleteFile(file);
+    tempDir.cleanup();
   }
 
   @Test
-  void largeKeysRejected() throws IOException {
+  void largeKeysRejected() {
     assertThatThrownBy(
             () -> {
               final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE);
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 64214568..9d127cf8 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -22,6 +22,7 @@
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 
 import java.nio.ByteBuffer;
+import java.nio.file.Path;
 import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.Test;
 
@@ -30,18 +31,18 @@ public final class VerifierTest {
 
   @Test
   void verification() {
-    FileUtil.useTempFile(
-        file -> {
-          try (Env<ByteBuffer> env =
-              create()
-                  .setMaxReaders(1)
-                  .setMaxDbs(Verifier.DBI_COUNT)
-                  .setMapSize(MEBIBYTES.toBytes(10))
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
-            final Verifier v = new Verifier(env);
-            final int seconds = Integer.getInteger("verificationSeconds", 2);
-            assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);
-          }
-        });
+    try (final TempDir tempDir = new TempDir()) {
+      final Path file = tempDir.createTempFile();
+      try (Env<ByteBuffer> env =
+          create()
+              .setMaxReaders(1)
+              .setMaxDbs(Verifier.DBI_COUNT)
+              .setMapSize(MEBIBYTES.toBytes(10))
+              .open(file.toFile(), MDB_NOSUBDIR)) {
+        final Verifier v = new Verifier(env);
+        final int seconds = Integer.getInteger("verificationSeconds", 2);
+        assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);
+      }
+    }
   }
 }
diff --git a/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.csv b/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.csv
index f35dbedc..1a18f426 100644
--- a/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.csv
+++ b/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.csv
@@ -28,7 +28,7 @@ BACKWARD_CLOSED,7,3,[6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED,6,2,[6 8][6 7][4 6][4 5][2 4][2 3]
 BACKWARD_CLOSED,9,3,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED,9,-1,[8 10][8 9][6 8][6 7][4 6][4 5][2 4][2 3][0 2][0 1]
-BACKWARD_CLOSED_OPEN,8,3,[8 9][6 8][6 7][4 6][4 5]
+BACKWARD_CLOSED_OPEN,8,3,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED_OPEN,7,2,[6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED_OPEN,9,3,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED_OPEN,9,-1,[8 10][8 9][6 8][6 7][4 6][4 5][2 4][2 3][0 2][0 1]
diff --git a/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv b/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv
index 01cddbad..e9054cbd 100644
--- a/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv
+++ b/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv
@@ -28,7 +28,7 @@ BACKWARD_CLOSED,7,3,[6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED,6,2,[6 8][6 7][4 6][4 5][2 4][2 3]
 BACKWARD_CLOSED,9,3,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED,9,-1,
-BACKWARD_CLOSED_OPEN,8,3,[8 9][6 8][6 7][4 6][4 5]
+BACKWARD_CLOSED_OPEN,8,3,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED_OPEN,7,2,[6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED_OPEN,9,3,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED_OPEN,9,-1,
@@ -47,3 +47,14 @@ BACKWARD_OPEN_CLOSED,7,2,[6 8][6 7][4 6][4 5][2 4][2 3]
 BACKWARD_OPEN_CLOSED,8,4,[6 8][6 7][4 6][4 5]
 BACKWARD_OPEN_CLOSED,9,4,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_OPEN_CLOSED,9,-1,
+#
+# TEST gh-267
+BACKWARD_AT_LEAST,6,,[6 8][6 7][4 6][4 5][2 4][2 3][0 2][0 1]
+BACKWARD_AT_LEAST,-2,,[-2 -1][-2 0][8 10][8 9][6 8][6 7][4 6][4 5][2 4][2 3][0 2][0 1]
+BACKWARD_AT_LEAST,9,,[8 10][8 9][6 8][6 7][4 6][4 5][2 4][2 3][0 2][0 1]
+BACKWARD_CLOSED,6,3,[6 8][6 7][4 6][4 5]
+BACKWARD_CLOSED,-2,2,[-2 -1][-2 0][8 10][8 9][6 8][6 7][4 6][4 5][2 4][2 3]
+BACKWARD_CLOSED,9,3,[8 10][8 9][6 8][6 7][4 6][4 5]
+BACKWARD_CLOSED_OPEN,6,2,[6 8][6 7][4 6][4 5]
+BACKWARD_CLOSED_OPEN,-2,3,[-2 -1][-2 0][8 10][8 9][6 8][6 7][4 6][4 5]
+BACKWARD_CLOSED_OPEN,9,-1,
\ No newline at end of file

From c4278017c23b10fe2e052e27ecf4fe6702cad5f8 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Tue, 4 Nov 2025 15:01:16 +0000
Subject: [PATCH 21/90] Add/refactor tests

---
 .../java/org/lmdbjava/AbstractFlagSet.java    |  13 +
 .../java/org/lmdbjava/ByteBufferProxy.java    |   4 +-
 src/main/java/org/lmdbjava/Cursor.java        |   2 +-
 src/main/java/org/lmdbjava/DbiBuilder.java    |  21 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     |  17 +-
 .../CursorIterableIntegerDupTest.java         |  39 ++-
 .../CursorIterableIntegerKeyTest.java         | 154 ++++++++----
 .../java/org/lmdbjava/CursorIterableTest.java |  16 +-
 .../java/org/lmdbjava/DbiBuilderTest.java     |   6 +-
 src/test/java/org/lmdbjava/DbiTest.java       |  34 +--
 .../java/org/lmdbjava/PutFlagSetTest.java     | 225 ++++++++++--------
 src/test/java/org/lmdbjava/TestUtils.java     |   8 +
 12 files changed, 351 insertions(+), 188 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 25aa328b..6e9729fb 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -325,6 +325,19 @@ public Builder<E, S> setFlag(final E flag) {
       return this;
     }
 
+    /**
+     * Sets multiple flag in the builder.
+     *
+     * @param flags The flags to set in the builder.
+     * @return this builder instance.
+     */
+    public Builder<E, S> setFlags(final Collection<E> flags) {
+      if (flags != null) {
+        enumSet.addAll(flags);
+      }
+      return this;
+    }
+
     /**
      * Clears any flags already set in this {@link Builder}
      *
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 5d5aa2ca..27ae375e 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -162,7 +162,9 @@ public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer
     public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
-      // Both buffers should be same lenght according to LMDB API.
+      // Both buffers should be same length according to LMDB API.
+      // From the LMDB docs for MDB_INTEGER_KEY
+      // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the same size.
       final int len1 = o1.limit();
       final int len2 = o2.limit();
       if (len1 != len2) {
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index c1ac7374..127fffc0 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -472,7 +472,7 @@ public T reserve(final T key, final int size) {
    * Reserve space for data of the given size, but don't copy the given val. Instead, return a
    * pointer to the reserved space, which the caller can fill in later - before the next update
    * operation or the transaction ends. This saves an extra memcpy if the data is being generated
-   * later. LMDB does nothing else with this memory, the caller is expected to modify all of the
+   * later. LMDB does nothing else with this memory, the caller is expected to modify all the
    * space requested.
    *
    * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 2b4e6ad8..1bf2489d 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -80,6 +80,9 @@ public DbiBuilderStage2<T> withDbName(final byte[] name) {
    * Equivalent to passing null to
    * {@link DbiBuilder#withDbName(String)} or {@link DbiBuilder#withDbName(byte[])}.
    * </p>
+   * <p>Note: The 'unnamed database' is used by LMDB to store the names of named databases, with
+   * the database name being the key. Use of the unnamed database is intended for simple applications
+   * with only one database.</p>
    * @return The next builder stage.
    */
   public DbiBuilderStage2<T> withoutDbName() {
@@ -323,7 +326,7 @@ public DbiBuilderStage3<T> withDbiFlags(final DbiFlagSet dbiFlagSet) {
      * {@link DbiBuilderStage3#withDbiFlags(Collection)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      *
-     * @param dbiFlag to open the database with. A null value is a no-op.
+     * @param dbiFlag to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
      */
     public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
@@ -331,6 +334,22 @@ public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
       return this;
     }
 
+    /**
+     * Adds a dbiFlag to those flags already added to this builder by
+     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)},
+     * {@link DbiBuilderStage3#withDbiFlags(Collection)}
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     *
+     * @param dbiFlagSet to add to any existing flags. A null value is a no-op.
+     * @return this builder instance.
+     */
+    public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
+      if (dbiFlagSet != null) {
+        flagSetBuilder.setFlags(dbiFlagSet.getFlags());
+      }
+      return this;
+    }
+
     /**
      * Use the supplied transaction to open the {@link Dbi}.
      * <p>
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index c7d8333f..fb736f41 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -43,6 +43,7 @@
 import java.nio.ByteOrder;
 import java.time.Duration;
 import java.time.Instant;
+import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -142,9 +143,9 @@ public void unsafeIsDefault() {
   }
 
   /**
-   * For 100 rounds of 1,000,000 comparisons
-   * compareAsIntegerKeys: PT0.267813487S
-   * compareLexicographically: PT0.644165235S
+   * For 100 rounds of 5,000,000 comparisons
+   * compareAsIntegerKeys: PT1.600525631S
+   * compareLexicographically: PT3.381935001S
    */
   @Test
   public void comparatorPerformance() {
@@ -153,7 +154,7 @@ public void comparatorPerformance() {
     final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
     buffer1.limit(Long.BYTES);
     buffer2.limit(Long.BYTES);
-    final long[] values = random.longs(1_000_000).toArray();
+    final long[] values = random.longs(5_000_000).toArray();
 
     Instant time = Instant.now();
     int x = 0;
@@ -195,7 +196,13 @@ public void verifyComparators() {
     buffer2native.limit(Long.BYTES);
     buffer1be.limit(Long.BYTES);
     buffer2be.limit(Long.BYTES);
-    final long[] values = random.longs(10_000_000).toArray();
+    final long[] values = random.longs()
+        .filter(i -> i >= 0)
+        .limit(5_000_000)
+        .toArray();
+    System.out.println("stats: " + Arrays.stream(values)
+        .summaryStatistics()
+        .toString());
 
     final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
     comparators.put("compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 1acf4328..189aad24 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -50,6 +50,7 @@
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.bbNative;
 import static org.lmdbjava.TestUtils.getNativeInt;
+import static org.lmdbjava.TestUtils.getNativeIntOrLong;
 
 import com.google.common.primitives.UnsignedBytes;
 import java.io.File;
@@ -71,6 +72,7 @@
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.Matchers;
 import org.junit.After;
+import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Rule;
@@ -88,7 +90,10 @@
 @RunWith(Parameterized.class)
 public final class CursorIterableIntegerDupTest {
 
-  private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERDUP, MDB_DUPSORT);
+  private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(
+      MDB_CREATE,
+      MDB_INTEGERDUP,
+      MDB_DUPSORT);
   private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
   private static final List<Map.Entry<Integer, Integer>> INPUT_DATA;
 
@@ -122,35 +127,47 @@ public final class CursorIterableIntegerDupTest {
 
   @Parameterized.Parameters(name = "{index}: dbi: {0}")
   public static Object[] data() {
-    final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
+    final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
         env.buildDbi()
             .withDbName(DB_1)
             .withDefaultComparator()
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
+    final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
         env.buildDbi()
             .withDbName(DB_2)
             .withNativeComparator()
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
+    final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
         env.buildDbi()
             .withDbName(DB_3)
-            .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withCallbackComparator(buildComparator())
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
+    final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
         env.buildDbi()
             .withDbName(DB_4)
-            .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withIteratorComparator(buildComparator())
             .withDbiFlags(DBI_FLAGS)
             .open());
     return new Object[]{
-        defaultComparator,
-        nativeComparator,
-        callbackComparator,
-        iteratorComparator};
+        defaultComparatorDb,
+        nativeComparatorDb,
+        callbackComparatorDb,
+        iteratorComparatorDb};
+  }
+
+  private static Comparator<ByteBuffer> buildComparator() {
+    final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
+    return (o1, o2) -> {
+      if (o1.remaining() != o2.remaining()) {
+        // Make sure LMDB is always giving us consistent key lengths.
+        Assert.fail("o1: " + o1 + " " + getNativeIntOrLong(o1)
+            + ", o2: " + o2 + " " + getNativeIntOrLong(o2));
+      }
+      return baseComparator.compare(o1, o2);
+    };
   }
 
   @Before
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index be91ea4c..1e664fb1 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -51,6 +51,8 @@
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.bbNative;
 import static org.lmdbjava.TestUtils.getNativeInt;
+import static org.lmdbjava.TestUtils.getNativeIntOrLong;
+import static org.lmdbjava.TestUtils.getNativeLong;
 import static org.lmdbjava.TestUtils.getString;
 
 import com.google.common.primitives.UnsignedBytes;
@@ -71,6 +73,7 @@
 import java.util.stream.Collectors;
 import org.hamcrest.Matchers;
 import org.junit.After;
+import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -104,35 +107,49 @@ public final class CursorIterableIntegerKeyTest {
 
   @Parameterized.Parameters(name = "{index}: dbi: {0}")
   public static Object[] data() {
-    final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
+    final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
         env.buildDbi()
             .withDbName(DB_1)
             .withDefaultComparator()
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
+    final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
         env.buildDbi()
             .withDbName(DB_2)
             .withNativeComparator()
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
+    final Comparator<ByteBuffer> comparator = buildComparator();
+
+    final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
         env.buildDbi()
             .withDbName(DB_3)
-            .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withCallbackComparator(comparator)
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
+    final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
         env.buildDbi()
             .withDbName(DB_4)
-            .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withIteratorComparator(comparator)
             .withDbiFlags(DBI_FLAGS)
             .open());
     return new Object[]{
-        defaultComparator,
-        nativeComparator,
-        callbackComparator,
-        iteratorComparator};
+        defaultComparatorDb,
+        nativeComparatorDb,
+        callbackComparatorDb,
+        iteratorComparatorDb};
+  }
+
+  private static Comparator<ByteBuffer> buildComparator() {
+    final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
+    return (o1, o2) -> {
+      if (o1.remaining() != o2.remaining()) {
+        // Make sure LMDB is always giving us consistent key lengths.
+        Assert.fail("o1: " + o1 + " " + getNativeIntOrLong(o1)
+            + ", o2: " + o2 + " " + getNativeIntOrLong(o2));
+      }
+      return baseComparator.compare(o1, o2);
+    };
   }
 
   @Before
@@ -162,13 +179,13 @@ public void testNumericOrderLong() {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       long i = 1;
       while (true) {
-//        System.out.println("putting " + i);
+        System.out.println("putting " + i);
         c.put(bbNative(i), bb(i + "-long"));
-          final long i2 = i * 10;
-          if (i2 < i) {
-            // Overflowed
-            break;
-          }
+        final long i2 = i * 10;
+        if (i2 < i) {
+          // Overflowed
+          break;
+        }
         i = i2;
       }
       txn.commit();
@@ -178,8 +195,9 @@ public void testNumericOrderLong() {
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       try (CursorIterable<ByteBuffer> iterable = dbi.iterate(txn)) {
         for (KeyVal<ByteBuffer> keyVal : iterable) {
+          assertThat(keyVal.key().remaining(), is(Long.BYTES));
           final String val = getString(keyVal.val());
-          final long key = TestUtils.getNativeLong(keyVal.key());
+          final long key = getNativeLong(keyVal.key());
           entries.add(new AbstractMap.SimpleEntry<>(key, val));
 //          System.out.println(val);
         }
@@ -208,7 +226,7 @@ public void testNumericOrderInt() {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       int i = 1;
       while (true) {
-//        System.out.println("putting " + i);
+        System.out.println("putting " + i);
         c.put(bbNative(i), bb(i + "-int"));
         final int i2 = i * 10;
         if (i2 < i) {
@@ -224,6 +242,7 @@ public void testNumericOrderInt() {
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       try (CursorIterable<ByteBuffer> iterable = dbi.iterate(txn)) {
         for (KeyVal<ByteBuffer> keyVal : iterable) {
+          assertThat(keyVal.key().remaining(), is(Integer.BYTES));
           final String val = getString(keyVal.val());
           final int key = TestUtils.getNativeInt(keyVal.key());
           entries.add(new AbstractMap.SimpleEntry<>(key, val));
@@ -246,6 +265,41 @@ public void testNumericOrderInt() {
     }
   }
 
+  @Test
+  public void testIntegerKeyKeySize() {
+    final Dbi<ByteBuffer> db = dbiFactory.factory.apply(env);
+    long maxIntAsLong = Integer.MAX_VALUE;
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      System.out.println("Flags: " + db.listFlags(txn));
+      int val = 0;
+      db.put(txn, bbNative(0L), bb("val_" + ++val));
+      db.put(txn, bbNative(10L), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 1_111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 1_111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(Long.MAX_VALUE), bb("val_" + ++val));
+      txn.commit();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> iterable = db.iterate(txn)) {
+        for (KeyVal<ByteBuffer> keyVal : iterable) {
+          final String val = getString(keyVal.val());
+          final long key = getNativeLong(keyVal.key());
+          final int remaining = keyVal.key().remaining();
+          System.out.println("key: " + key + ", val: " + val + ", remaining: " + remaining);
+        }
+      }
+    }
+
+  }
+
   @Test
   public void allBackwardTest() {
     verify(allBackward(), 8, 6, 4, 2);
@@ -365,11 +419,11 @@ public void iterate() {
   @Test(expected = IllegalStateException.class)
   public void iteratorOnlyReturnedOnce() {
     final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        c.iterator(); // ok
-        c.iterator(); // fails
-      }
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      c.iterator(); // ok
+      c.iterator(); // fails
+    }
   }
 
   @Test
@@ -472,57 +526,57 @@ public void removeOddElements() {
   @Test(expected = Env.AlreadyClosedException.class)
   public void nextWithClosedEnvTest() {
     final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          env.close();
-          c.next();
-        }
+        env.close();
+        c.next();
       }
+    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void removeWithClosedEnvTest() {
     final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnWrite()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          final KeyVal<ByteBuffer> keyVal = c.next();
-          assertThat(keyVal, Matchers.notNullValue());
+        final KeyVal<ByteBuffer> keyVal = c.next();
+        assertThat(keyVal, Matchers.notNullValue());
 
-          env.close();
-          c.remove();
-        }
+        env.close();
+        c.remove();
       }
+    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void hasNextWithClosedEnvTest() {
     final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          env.close();
-          c.hasNext();
-        }
+        env.close();
+        c.hasNext();
       }
+    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void forEachRemainingWithClosedEnvTest() {
     final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          env.close();
-          c.forEachRemaining(keyVal -> {
-          });
-        }
+        env.close();
+        c.forEachRemaining(keyVal -> {
+        });
       }
+    }
   }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 7bcbd851..a6b5d7d1 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -93,35 +93,35 @@ public final class CursorIterableTest {
 
   @Parameterized.Parameters(name = "{index}: dbi: {0}")
   public static Object[] data() {
-    final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
+    final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
         env.buildDbi()
             .withDbName(DB_1)
             .withDefaultComparator()
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
+    final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
         env.buildDbi()
             .withDbName(DB_2)
             .withNativeComparator()
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
+    final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
         env.buildDbi()
             .withDbName(DB_3)
             .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
+    final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
         env.buildDbi()
             .withDbName(DB_4)
             .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
             .withDbiFlags(DBI_FLAGS)
             .open());
     return new Object[] {
-        defaultComparator,
-        nativeComparator,
-        callbackComparator,
-        iteratorComparator};
+        defaultComparatorDb,
+        nativeComparatorDb,
+        callbackComparatorDb,
+        iteratorComparatorDb};
   }
 
   @Before
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index 74fbd8f5..6f6a4f39 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -60,13 +60,12 @@ public void unnamed() {
         .withDefaultComparator()
         .withDbiFlags(DbiFlags.MDB_CREATE)
         .open();
-
+    assertThat(dbi.getName(), Matchers.nullValue());
+    assertThat(dbi.getNameAsString(), Matchers.emptyString());
     assertThat(env.getDbiNames().size(), Matchers.is(0));
-
     assertPutAndGet(dbi);
   }
 
-
   @Test
   public void named() {
     final Dbi<ByteBuffer> dbi = env.buildDbi()
@@ -89,6 +88,7 @@ private void assertPutAndGet(Dbi<ByteBuffer> dbi) {
 
     try (Txn<ByteBuffer> readTxn = env.txnRead()) {
       final ByteBuffer byteBuffer = dbi.get(readTxn, bb(123));
+      assertThat(byteBuffer, Matchers.notNullValue());
       final int val = byteBuffer.getInt();
       assertThat(val, Matchers.is(123_000));
     }
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 2209e614..962aacab 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -74,10 +74,13 @@
 import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.LmdbNativeException.ConstantDerivedException;
 
-/** Test {@link Dbi}. */
+/**
+ * Test {@link Dbi}.
+ */
 public final class DbiTest {
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
   private Env<ByteBuffer> env;
   private Env<byte[]> envBa;
 
@@ -105,10 +108,13 @@ public void before() throws IOException {
   }
 
 
-
   @Test(expected = ConstantDerivedException.class)
   public void close() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db = env.buildDbi()
+        .withDbName(DB_1)
+        .withDefaultComparator()
+        .addDbiFlag(MDB_CREATE)
+        .open();
     db.put(bb(1), bb(42));
     db.close();
     db.put(bb(2), bb(42)); // error
@@ -154,7 +160,7 @@ private <T> void doCustomComparator(
       txn.commit();
     }
     try (Txn<T> txn = env.txnRead();
-        CursorIterable<T> ci = db.iterate(txn, atMost(serializer.apply(4)))) {
+         CursorIterable<T> ci = db.iterate(txn, atMost(serializer.apply(4)))) {
       final Iterator<KeyVal<T>> iter = ci.iterator();
       assertThat(deserializer.applyAsInt(iter.next().key()), is(8));
       assertThat(deserializer.applyAsInt(iter.next().key()), is(6));
@@ -186,7 +192,7 @@ public <T> void doDbiWithComparatorThreadSafety(
       Supplier<Comparator<T>> comparatorSupplier,
       IntFunction<T> serializer,
       ToIntFunction<T> deserializer) {
-    final DbiFlags[] flags = new DbiFlags[] {MDB_CREATE, MDB_INTEGERKEY};
+    final DbiFlags[] flags = new DbiFlags[]{MDB_CREATE, MDB_INTEGERKEY};
     final Comparator<T> c = comparatorSupplier.get();
     final Dbi<T> db = env.openDbi(DB_1, c, true, flags);
 
@@ -212,7 +218,7 @@ public <T> void doDbiWithComparatorThreadSafety(
     }
 
     try (Txn<T> txn = env.txnRead();
-        CursorIterable<T> ci = db.iterate(txn)) {
+         CursorIterable<T> ci = db.iterate(txn)) {
       final Iterator<KeyVal<T>> iter = ci.iterator();
       final List<Integer> result = new ArrayList<>();
       while (iter.hasNext()) {
@@ -292,8 +298,8 @@ public void getName() {
 
   @Test
   public void getNamesWhenDbisPresent() {
-    final byte[] dbHello = new byte[] {'h', 'e', 'l', 'l', 'o'};
-    final byte[] dbWorld = new byte[] {'w', 'o', 'r', 'l', 'd'};
+    final byte[] dbHello = new byte[]{'h', 'e', 'l', 'l', 'o'};
+    final byte[] dbWorld = new byte[]{'w', 'o', 'r', 'l', 'd'};
     env.openDbi(dbHello, MDB_CREATE);
     env.openDbi(dbWorld, MDB_CREATE);
     final List<byte[]> dbiNames = env.getDbiNames();
@@ -369,11 +375,11 @@ public void putCommitGet() {
   public void putCommitGetByteArray() throws IOException {
     final File path = tmp.newFile();
     try (Env<byte[]> envBa =
-        create(PROXY_BA)
-            .setMapSize(MEBIBYTES.toBytes(64))
-            .setMaxReaders(1)
-            .setMaxDbs(2)
-            .open(path, MDB_NOSUBDIR)) {
+             create(PROXY_BA)
+                 .setMapSize(MEBIBYTES.toBytes(64))
+                 .setMaxReaders(1)
+                 .setMaxDbs(2)
+                 .open(path, MDB_NOSUBDIR)) {
       final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
       try (Txn<byte[]> txn = envBa.txnWrite()) {
         db.put(txn, ba(5), ba(5));
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 3e402732..b8b44254 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -19,113 +19,150 @@
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+import java.time.Duration;
+import java.time.Instant;
 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import org.junit.Test;
 
 public class PutFlagSetTest {
 
-    @Test
-    public void testEmpty() {
-        final PutFlagSet putFlagSet = PutFlagSet.empty();
-        assertThat(
-                putFlagSet.getMask(),
-                is(0));
-        assertThat(
-                putFlagSet.size(),
-                is(0));
-        assertThat(
-                putFlagSet.isEmpty(),
-                is(true));
-        assertThat(
-                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
-                is(false));
-        final PutFlagSet putFlagSet2 = PutFlagSet.builder()
-            .build();
-        assertThat(putFlagSet, is(putFlagSet2));
-        assertThat(putFlagSet, not(PutFlagSet.of(PutFlags.MDB_APPEND)));
-        assertThat(putFlagSet, not(PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_RESERVE)));
-        assertThat(putFlagSet, not(PutFlagSet.builder()
-            .setFlag(PutFlags.MDB_CURRENT)
-            .setFlag(PutFlags.MDB_MULTIPLE)
-            .build()));
+  @Test
+  public void testEmpty() {
+    final PutFlagSet putFlagSet = PutFlagSet.empty();
+    assertThat(
+        putFlagSet.getMask(),
+        is(0));
+    assertThat(
+        putFlagSet.size(),
+        is(0));
+    assertThat(
+        putFlagSet.isEmpty(),
+        is(true));
+    assertThat(
+        putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+        is(false));
+    final PutFlagSet putFlagSet2 = PutFlagSet.builder()
+        .build();
+    assertThat(putFlagSet, is(putFlagSet2));
+    assertThat(putFlagSet, not(PutFlagSet.of(PutFlags.MDB_APPEND)));
+    assertThat(putFlagSet, not(PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_RESERVE)));
+    assertThat(putFlagSet, not(PutFlagSet.builder()
+        .setFlag(PutFlags.MDB_CURRENT)
+        .setFlag(PutFlags.MDB_MULTIPLE)
+        .build()));
+  }
+
+  @Test
+  public void testOf() {
+    final PutFlags putFlag = PutFlags.MDB_APPEND;
+    final PutFlagSet putFlagSet = PutFlagSet.of(putFlag);
+    assertThat(
+        putFlagSet.getMask(),
+        is(MaskedFlag.mask(putFlag)));
+    assertThat(
+        putFlagSet.size(),
+        is(1));
+    assertThat(
+        putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+        is(false));
+    for (PutFlags flag : putFlagSet) {
+      assertThat(
+          putFlagSet.isSet(flag),
+          is(true));
     }
 
-    @Test
-    public void testOf() {
-        final PutFlags putFlag = PutFlags.MDB_APPEND;
-        final PutFlagSet putFlagSet = PutFlagSet.of(putFlag);
-        assertThat(
-                putFlagSet.getMask(),
-                is(MaskedFlag.mask(putFlag)));
-        assertThat(
-                putFlagSet.size(),
-                is(1));
-        assertThat(
-                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
-                is(false));
-        for (PutFlags flag : putFlagSet) {
-            assertThat(
-                    putFlagSet.isSet(flag),
-                    is(true));
-        }
+    final PutFlagSet putFlagSet2 = PutFlagSet.builder()
+        .setFlag(putFlag)
+        .build();
+    assertThat(putFlagSet, is(putFlagSet2));
+  }
 
-        final PutFlagSet putFlagSet2 = PutFlagSet.builder()
-            .setFlag(putFlag)
-            .build();
-        assertThat(putFlagSet, is(putFlagSet2));
+  @Test
+  public void testOf2() {
+    final PutFlags putFlag1 = PutFlags.MDB_APPEND;
+    final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
+    final PutFlagSet putFlagSet = PutFlagSet.of(putFlag1, putFlag2);
+    assertThat(
+        putFlagSet.getMask(),
+        is(MaskedFlag.mask(putFlag1, putFlag2)));
+    assertThat(
+        putFlagSet.size(),
+        is(2));
+    assertThat(
+        putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+        is(false));
+    for (PutFlags flag : putFlagSet) {
+      assertThat(
+          putFlagSet.isSet(flag),
+          is(true));
     }
+  }
 
-    @Test
-    public void testOf2() {
-        final PutFlags putFlag1 = PutFlags.MDB_APPEND;
-        final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
-        final PutFlagSet putFlagSet = PutFlagSet.of(putFlag1, putFlag2);
-        assertThat(
-                putFlagSet.getMask(),
-                is(MaskedFlag.mask(putFlag1, putFlag2)));
-        assertThat(
-                putFlagSet.size(),
-                is(2));
-        assertThat(
-                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
-                is(false));
-        for (PutFlags flag : putFlagSet) {
-            assertThat(
-                    putFlagSet.isSet(flag),
-                    is(true));
-        }
+  @Test
+  public void testBuilder() {
+    final PutFlags putFlag1 = PutFlags.MDB_APPEND;
+    final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
+    final PutFlagSet putFlagSet = PutFlagSet.builder()
+        .setFlag(putFlag1)
+        .setFlag(putFlag2)
+        .build();
+    assertThat(
+        putFlagSet.getMask(),
+        is(MaskedFlag.mask(putFlag1, putFlag2)));
+    assertThat(
+        putFlagSet.size(),
+        is(2));
+    assertThat(
+        putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+        is(false));
+    for (PutFlags flag : putFlagSet) {
+      assertThat(
+          putFlagSet.isSet(flag),
+          is(true));
     }
+    final PutFlagSet putFlagSet2 = PutFlagSet.builder()
+        .withFlags(putFlag1, putFlag2)
+        .build();
+    final PutFlagSet putFlagSet3 = PutFlagSet.builder()
+        .withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2)))
+        .build();
+    assertThat(putFlagSet, is(putFlagSet2));
+    assertThat(putFlagSet, is(putFlagSet3));
+  }
 
-    @Test
-    public void testBuilder() {
-        final PutFlags putFlag1 = PutFlags.MDB_APPEND;
-        final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
-        final PutFlagSet putFlagSet = PutFlagSet.builder()
-                .setFlag(putFlag1)
-                .setFlag(putFlag2)
-                .build();
-        assertThat(
-                putFlagSet.getMask(),
-                is(MaskedFlag.mask(putFlag1, putFlag2)));
-        assertThat(
-                putFlagSet.size(),
-                is(2));
-        assertThat(
-                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
-                is(false));
-        for (PutFlags flag : putFlagSet) {
-            assertThat(
-                    putFlagSet.isSet(flag),
-                    is(true));
+  @Test
+  public void testAddFlagVsCheckPresence() {
+
+    final int cnt = 10_000_000;
+    final int[] arr = new int[cnt];
+    final List<PutFlagSet> flagSets = IntStream.range(0, cnt)
+        .boxed()
+        .map(i -> PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_NOOVERWRITE, PutFlags.MDB_RESERVE))
+        .collect(Collectors.toList());
+
+    Instant time;
+    for (int i = 0; i < 5; i++) {
+      time = Instant.now();
+      for (int j = 0; j < flagSets.size(); j++) {
+        PutFlagSet flagSet = flagSets.get(j);
+        if (!flagSet.isSet(PutFlags.MDB_RESERVE)) {
+          throw new RuntimeException("Not set");
         }
-        final PutFlagSet putFlagSet2 = PutFlagSet.builder()
-                .withFlags(putFlag1, putFlag2)
-                .build();
-        final PutFlagSet putFlagSet3 = PutFlagSet.builder()
-                .withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2)))
-                .build();
-        assertThat(putFlagSet, is(putFlagSet2));
-        assertThat(putFlagSet, is(putFlagSet3));
+        arr[j] = flagSet.getMask();
+      }
+      System.out.println("Check: " + Duration.between(time, Instant.now()));
+
+      time = Instant.now();
+      for (int j = 0; j < flagSets.size(); j++) {
+        PutFlagSet flagSet = flagSets.get(j);
+        final int mask = flagSet.getMaskWith(PutFlags.MDB_RESERVE);
+        arr[j] = mask;
+      }
+      System.out.println("Append:" + Duration.between(time, Instant.now()));
     }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 511619fe..94ceb3a7 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -93,6 +93,14 @@ static long getNativeLong(final ByteBuffer bb) {
     return val;
   }
 
+  static long getNativeIntOrLong(final ByteBuffer bb) {
+    if (bb.remaining() == BYTES) {
+      return getNativeInt(bb);
+    } else {
+      return getNativeLong(bb);
+    }
+  }
+
   static String getString(final ByteBuffer bb) {
     final String str = StandardCharsets.UTF_8.decode(bb)
         .toString();

From e2be6bf145a100fb2b8d40446dd3b70a54f51e2d Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 5 Nov 2025 13:06:57 +0000
Subject: [PATCH 22/90] Add integer key comparator tests

---
 .../java/org/lmdbjava/AbstractFlagSet.java    |   2 -
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  74 +++-
 .../java/org/lmdbjava/ByteBufferProxy.java    |   5 +-
 src/main/java/org/lmdbjava/DbiBuilder.java    |  38 +-
 .../java/org/lmdbjava/DirectBufferProxy.java  |  18 +-
 src/main/java/org/lmdbjava/Env.java           | 185 +++++++--
 .../org/lmdbjava/ByteBufferProxyTest.java     |  17 +-
 .../lmdbjava/ComparatorIntegerKeyTest.java    | 369 ++++++++++++++++++
 .../java/org/lmdbjava/ComparatorTest.java     |  10 +
 .../CursorIterableIntegerDupTest.java         |  30 +-
 .../CursorIterableIntegerKeyTest.java         |  32 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  |  12 +-
 .../java/org/lmdbjava/CursorIterableTest.java |  56 +--
 .../java/org/lmdbjava/DbiBuilderTest.java     | 125 +++++-
 src/test/java/org/lmdbjava/DbiTest.java       |   2 +-
 src/test/java/org/lmdbjava/TestUtils.java     |  35 ++
 .../java/org/lmdbjava/TxnFlagSetTest.java     | 111 +++---
 17 files changed, 906 insertions(+), 215 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 6e9729fb..058969de 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -26,8 +26,6 @@
 
 /**
  * Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
- *
- * @param <T>
  */
 public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
 
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 319256fb..19d94392 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -23,6 +23,7 @@
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.PooledByteBufAllocator;
 import java.lang.reflect.Field;
+import java.nio.ByteOrder;
 import java.util.Comparator;
 import jnr.ffi.Pointer;
 
@@ -44,13 +45,6 @@ public final class ByteBufProxy extends BufferProxy<ByteBuf> {
   private static final String FIELD_NAME_ADDRESS = "memoryAddress";
   private static final String FIELD_NAME_LENGTH = "length";
   private static final String NAME = "io.netty.buffer.PooledUnsafeDirectByteBuf";
-  private static final Comparator<ByteBuf> comparator =
-      (o1, o2) -> {
-        requireNonNull(o1);
-        requireNonNull(o2);
-
-        return o1.compareTo(o2);
-      };
   private final long lengthOffset;
   private final long addressOffset;
 
@@ -81,6 +75,66 @@ public ByteBufProxy(final PooledByteBufAllocator allocator) {
     }
   }
 
+  /**
+   * Lexicographically compare two buffers.
+   *
+   * @param o1 left operand (required)
+   * @param o2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  public static int compareLexicographically(final ByteBuf o1, final ByteBuf o2) {
+    requireNonNull(o1);
+    requireNonNull(o2);
+    return o1.compareTo(o2);
+  }
+
+  /**
+   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
+   * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+   *
+   * @param o1 left operand (required)
+   * @param o2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  public static int compareAsIntegerKeys(final ByteBuf o1, final ByteBuf o2) {
+    requireNonNull(o1);
+    requireNonNull(o2);
+    // Both buffers should be same length according to LMDB API.
+    // From the LMDB docs for MDB_INTEGER_KEY
+    // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the same size.
+    final int len1 = o1.readableBytes();
+    final int len2 = o2.readableBytes();
+    if (len1 != len2) {
+      throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
+          + ". Lengths must be identical and either 4 or 8 bytes.");
+    }
+    if (len1 == 8) {
+      final long lw;
+      final long rw;
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        lw = o1.readLongLE();
+        rw = o2.readLongLE();
+      } else {
+        lw = o1.readLong();
+        rw = o2.readLong();
+      }
+      return Long.compareUnsigned(lw, rw);
+    } else if (len1 == 4) {
+      final int lw;
+      final int rw;
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        lw = o1.readIntLE();
+        rw = o2.readIntLE();
+      } else {
+        lw = o1.readInt();
+        rw = o2.readInt();
+      }
+      return Integer.compareUnsigned(lw, rw);
+    } else {
+      return compareLexicographically(o1, o2);
+    }
+  }
+
   static Field findField(final String c, final String name) {
     Class<?> clazz;
     try {
@@ -115,7 +169,11 @@ protected ByteBuf allocate() {
 
   @Override
   public Comparator<ByteBuf> getComparator(final DbiFlagSet dbiFlagSet) {
-    return comparator;
+    if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
+      return ByteBufProxy::compareAsIntegerKeys;
+    } else {
+      return ByteBufProxy::compareLexicographically;
+    }
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 27ae375e..c682bec8 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -60,6 +60,7 @@ public final class ByteBufferProxy {
    */
   public static final BufferProxy<ByteBuffer> PROXY_SAFE;
 
+  private static final ByteOrder NATIVE_ORDER = ByteOrder.nativeOrder();
 
   static {
     PROXY_SAFE = new ReflectiveProxy();
@@ -172,8 +173,8 @@ public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2)
             + ". Lengths must be identical and either 4 or 8 bytes.");
       }
       // Keys for MDB_INTEGER_KEY are written in native order so ensure we read them in that order
-      o1.order(ByteOrder.nativeOrder());
-      o2.order(ByteOrder.nativeOrder());
+      o1.order(NATIVE_ORDER);
+      o2.order(NATIVE_ORDER);
       // TODO it might be worth the DbiBuilder having a method to capture fixedKeyLength() or -1
       //  for variable length keys. This can be passed to getComparator(..) so it can return a
       //  comparator that doesn't need to test the length every time. There may be other benefits
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 1bf2489d..f94118a7 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -53,12 +53,12 @@ public class DbiBuilder<T> {
    *            (see also {@link DbiBuilder#withoutDbName()})
    * @return The next builder stage.
    */
-  public DbiBuilderStage2<T> withDbName(final String name) {
+  public DbiBuilderStage2<T> setDbName(final String name) {
     // Null name is allowed so no null check
     final byte[] nameBytes = name == null
         ? null
         : name.getBytes(Env.DEFAULT_NAME_CHARSET);
-    return withDbName(nameBytes);
+    return setDbName(nameBytes);
   }
 
   /**
@@ -66,7 +66,7 @@ public DbiBuilderStage2<T> withDbName(final String name) {
    * @param name The name of the database in byte form.
    * @return The next builder stage.
    */
-  public DbiBuilderStage2<T> withDbName(final byte[] name) {
+  public DbiBuilderStage2<T> setDbName(final byte[] name) {
     // Null name is allowed so no null check
     this.name = name;
     return new DbiBuilderStage2<>(this);
@@ -78,7 +78,7 @@ public DbiBuilderStage2<T> withDbName(final byte[] name) {
    * </p>
    * <p>
    * Equivalent to passing null to
-   * {@link DbiBuilder#withDbName(String)} or {@link DbiBuilder#withDbName(byte[])}.
+   * {@link DbiBuilder#setDbName(String)} or {@link DbiBuilder#setDbName(byte[])}.
    * </p>
    * <p>Note: The 'unnamed database' is used by LMDB to store the names of named databases, with
    * the database name being the key. Use of the unnamed database is intended for simple applications
@@ -86,7 +86,7 @@ public DbiBuilderStage2<T> withDbName(final byte[] name) {
    * @return The next builder stage.
    */
   public DbiBuilderStage2<T> withoutDbName() {
-    return withDbName((byte[]) null);
+    return setDbName((byte[]) null);
   }
 
 
@@ -254,8 +254,8 @@ private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
      * </p>
      * <p>
      * Clears all flags currently set by previous calls to
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)},
-     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
+     * {@link DbiBuilderStage3#setDbiFlags(Collection)},
+     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      * </p>
      *
@@ -263,7 +263,7 @@ private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
      *                 A null {@link Collection} will just clear all set flags.
      *                 Null items are ignored.
      */
-    public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
+    public DbiBuilderStage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
         dbiFlags.stream()
@@ -279,8 +279,8 @@ public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
      * </p>
      * <p>
      * Clears all flags currently set by previous calls to
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)},
-     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
+     * {@link DbiBuilderStage3#setDbiFlags(Collection)},
+     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      * </p>
      *
@@ -288,7 +288,7 @@ public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
      *                 A null array will just clear all set flags.
      *                 Null items are ignored.
      */
-    public DbiBuilderStage3<T> withDbiFlags(final DbiFlags... dbiFlags) {
+    public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
         Arrays.stream(dbiFlags)
@@ -304,15 +304,15 @@ public DbiBuilderStage3<T> withDbiFlags(final DbiFlags... dbiFlags) {
      * </p>
      * <p>
      * Clears all flags currently set by previous calls to
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)},
-     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
+     * {@link DbiBuilderStage3#setDbiFlags(Collection)},
+     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlagSet to open the database with.
      *                 A null value will just clear all set flags.
      */
-    public DbiBuilderStage3<T> withDbiFlags(final DbiFlagSet dbiFlagSet) {
+    public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
       flagSetBuilder.clear();
       if (dbiFlagSet != null) {
         this.flagSetBuilder.withFlags(dbiFlagSet.getFlags());
@@ -322,8 +322,8 @@ public DbiBuilderStage3<T> withDbiFlags(final DbiFlagSet dbiFlagSet) {
 
     /**
      * Adds a dbiFlag to those flags already added to this builder by
-     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)},
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)}
+     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)},
+     * {@link DbiBuilderStage3#setDbiFlags(Collection)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlag to add to any existing flags. A null value is a no-op.
@@ -336,8 +336,8 @@ public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
 
     /**
      * Adds a dbiFlag to those flags already added to this builder by
-     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)},
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)}
+     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)},
+     * {@link DbiBuilderStage3#setDbiFlags(Collection)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlagSet to add to any existing flags. A null value is a no-op.
@@ -367,7 +367,7 @@ public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
      *            else it needs to be a read/write {@link Txn}.
      * @return this builder instance.
      */
-    public DbiBuilderStage3<T> withTxn(final Txn<T> txn) {
+    public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
       this.txn = Objects.requireNonNull(txn);
       return this;
     }
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 180eee0a..46bdfd22 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -22,6 +22,7 @@
 import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.util.ArrayDeque;
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -50,6 +51,8 @@ public final class DirectBufferProxy extends BufferProxy<DirectBuffer> {
   private static final ThreadLocal<ArrayDeque<DirectBuffer>> BUFFERS =
       withInitial(() -> new ArrayDeque<>(16));
 
+  private static final ByteOrder NATIVE_ORDER = ByteOrder.nativeOrder();
+
   private DirectBufferProxy() {}
 
   /**
@@ -110,16 +113,19 @@ public static int compareAsIntegerKeys(final DirectBuffer o1, final DirectBuffer
           + ". Lengths must be identical and either 4 or 8 bytes.");
     }
     if (len1 == 8) {
-      final long lw = o1.getLong(0, BIG_ENDIAN);
-      final long rw = o2.getLong(0, BIG_ENDIAN);
+      final long lw = o1.getLong(0, NATIVE_ORDER);
+      final long rw = o2.getLong(0, NATIVE_ORDER);
       return Long.compareUnsigned(lw, rw);
     } else if (len1 == 4) {
-      final int lw = o1.getInt(0, BIG_ENDIAN);
-      final int rw = o2.getInt(0, BIG_ENDIAN);
+      final int lw = o1.getInt(0, NATIVE_ORDER);
+      final int rw = o2.getInt(0, NATIVE_ORDER);
       return Integer.compareUnsigned(lw, rw);
     } else {
-      throw new RuntimeException("Unexpected length len1: " + len1 + ", len2: " + len2
-          + ". Lengths must be identical and either 4 or 8 bytes.");
+      // size_t and int are likely to be 8bytes and 4bytes respectively on 64bit.
+      // If 32bit then would be 4/2 respectively.
+      // Short.compareUnsigned is not available in Java8.
+      // For now just fall back to our standard comparator
+      return compareLexicographically(o1, o2);
     }
   }
 
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 8ea08ccb..b8003cbb 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -23,18 +23,20 @@
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.Library.LIB;
 import static org.lmdbjava.Library.RUNTIME;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 
 import java.io.File;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Objects;
 import jnr.ffi.Pointer;
 import jnr.ffi.byref.IntByReference;
 import jnr.ffi.byref.PointerByReference;
@@ -102,6 +104,8 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
   }
 
   /**
+   * @deprecated Instead use {@link Env#create()} or {@link Env#create(BufferProxy)}
+   * <p>
    * Opens an environment with a single default database in 0664 mode using the {@link
    * ByteBufferProxy#PROXY_OPTIMAL}.
    *
@@ -110,6 +114,7 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
    * @param flags the flags for this new environment
    * @return env the environment (never null)
    */
+  @Deprecated
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
     return new Builder<>(PROXY_OPTIMAL)
         .setMapSize(size * 1_024L * 1_024L)
@@ -496,18 +501,6 @@ public Txn<T> txn(final Txn<T> parent) {
     return new Txn<>(this, parent, proxy, TxnFlagSet.EMPTY);
   }
 
-  /**
-   * Obtain a transaction with the requested parent and flags.
-   *
-   * @param parent parent transaction (may be null if no parent)
-   * @param flag   applicable flag (eg for a reusable, read-only transaction)
-   * @return a transaction (never null)
-   */
-  public Txn<T> txn(final Txn<T> parent, final TxnFlags flag) {
-    checkNotClosed();
-    return new Txn<>(this, parent, proxy, flag);
-  }
-
   /**
    * Obtain a transaction with the requested parent and flags.
    *
@@ -616,6 +609,10 @@ public AlreadyOpenException() {
     }
   }
 
+
+  // --------------------------------------------------------------------------------
+
+
   /**
    * Builder for configuring and opening Env.
    *
@@ -629,6 +626,8 @@ public static final class Builder<T> {
     private int maxReaders = MAX_READERS_DEFAULT;
     private boolean opened;
     private final BufferProxy<T> proxy;
+    private int mode = 0664;
+    private AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> flagSetBuilder = EnvFlagSet.builder();
 
     Builder(final BufferProxy<T> proxy) {
       requireNonNull(proxy);
@@ -642,10 +641,49 @@ public static final class Builder<T> {
      * @param mode  Unix permissions to set on created files and semaphores
      * @param flags the flags for this new environment
      * @return an environment ready for use
+     * @deprecated Instead use {@link Builder#open(Path)}, {@link Builder#setFilePermissions(int)}
+     * and {@link Builder#setEnvFlags(EnvFlags...)}.
      */
+    @Deprecated
     public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
-      // TODO Use EnvFlagSet and deprecate
-      // TODO Make setUnixPermissions(int) method on builder.
+      setFilePermissions(mode);
+      setEnvFlags(flags);
+      return open(requireNonNull(path).toPath());
+    }
+
+    /**
+     * Opens the environment.
+     *
+     * @param path file system destination
+     * @return an environment ready for use
+     * @deprecated Instead use {@link Builder#open(Path)}
+     */
+    @Deprecated
+    public Env<T> open(final File path) {
+      return open(requireNonNull(path).toPath());
+    }
+
+    /**
+     * Opens the environment with 0664 mode.
+     *
+     * @param path  file system destination
+     * @param flags the flags for this new environment
+     * @return an environment ready for use
+     * @deprecated Instead use {@link Builder#open(Path)} and {@link Builder#setEnvFlags(EnvFlags...)}.
+     */
+    @Deprecated
+    public Env<T> open(final File path, final EnvFlags... flags) {
+      setEnvFlags(flags);
+      return open(requireNonNull(path).toPath());
+    }
+
+    /**
+     * Opens the environment.
+     *
+     * @param path file system destination
+     * @return an environment ready for use
+     */
+    public Env<T> open(final Path path) {
       requireNonNull(path);
       if (opened) {
         throw new AlreadyOpenException();
@@ -658,10 +696,10 @@ public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
         checkRc(LIB.mdb_env_set_mapsize(ptr, mapSize));
         checkRc(LIB.mdb_env_set_maxdbs(ptr, maxDbs));
         checkRc(LIB.mdb_env_set_maxreaders(ptr, maxReaders));
-        final int flagsMask = mask(flags);
-        final boolean readOnly = isSet(flagsMask, MDB_RDONLY_ENV);
-        final boolean noSubDir = isSet(flagsMask, MDB_NOSUBDIR);
-        checkRc(LIB.mdb_env_open(ptr, path.getAbsolutePath(), flagsMask, mode));
+        final EnvFlagSet flags = flagSetBuilder.build();
+        final boolean readOnly = flags.isSet(MDB_RDONLY_ENV);
+        final boolean noSubDir = flags.isSet(MDB_NOSUBDIR);
+        checkRc(LIB.mdb_env_open(ptr, path.toAbsolutePath().toString(), flags.getMask(), mode));
         return new Env<>(proxy, ptr, readOnly, noSubDir);
       } catch (final LmdbNativeException e) {
         LIB.mdb_env_close(ptr);
@@ -670,19 +708,7 @@ public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
     }
 
     /**
-     * Opens the environment with 0664 mode.
-     *
-     * @param path  file system destination
-     * @param flags the flags for this new environment
-     * @return an environment ready for use
-     */
-    public Env<T> open(final File path, final EnvFlags... flags) {
-      // TODO make constant
-      return open(path, 0664, flags);
-    }
-
-    /**
-     * Sets the map size.
+     * Sets the map size in bytes.
      *
      * @param mapSize new limit in bytes
      * @return the builder
@@ -725,6 +751,99 @@ public Builder<T> setMaxReaders(final int readers) {
       this.maxReaders = readers;
       return this;
     }
+
+    /**
+     * Sets the Unix file permissions to use on created files and semaphores, e.g. {@code 0664}.
+     * If this method is not called, the default of {@code 0664} will be used.
+     *
+     * @param mode Unix permissions to set on created files and semaphores
+     * @return the builder
+     */
+    public Builder<T> setFilePermissions(final int mode) {
+      if (opened) {
+        throw new AlreadyOpenException();
+      }
+      this.mode = mode;
+      return this;
+    }
+
+    /**
+     * Sets all the flags used to open this {@link Env}.
+     *
+     * @param envFlags The flags to use.
+     *                 Clears any existing flags.
+     *                 A null value results in no flags being set.
+     * @return this builder instance.
+     */
+    public Builder<T> setEnvFlags(final Collection<EnvFlags> envFlags) {
+      flagSetBuilder.clear();
+      if (envFlags != null) {
+        envFlags.stream()
+            .filter(Objects::nonNull)
+            .forEach(envFlags::add);
+      }
+      return this;
+    }
+
+    /**
+     * Sets all the flags used to open this {@link Env}.
+     *
+     * @param envFlags The flags to use.
+     *                 Clears any existing flags.
+     *                 A null value results in no flags being set.
+     * @return this builder instance.
+     */
+    public Builder<T> setEnvFlags(final EnvFlags... envFlags) {
+      flagSetBuilder.clear();
+      if (envFlags != null) {
+        Arrays.stream(envFlags)
+            .filter(Objects::nonNull)
+            .forEach(this.flagSetBuilder::setFlag);
+      }
+      return this;
+    }
+
+    /**
+     * Sets all the flags used to open this {@link Env}.
+     *
+     * @param envFlagSet The flags to use.
+     *                   Clears any existing flags.
+     *                   A null value results in no flags being set.
+     * @return this builder instance.
+     */
+    public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
+      flagSetBuilder.clear();
+      if (envFlagSet != null) {
+        this.flagSetBuilder.withFlags(envFlagSet.getFlags());
+      }
+      return this;
+    }
+
+    /**
+     * Adds a single {@link EnvFlags} to any existing flags.
+     *
+     * @param dbiFlag The flag to add to any existing flags.
+     *                A null value is a no-op.
+     * @return this builder instance.
+     */
+    public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
+      this.flagSetBuilder.setFlag(dbiFlag);
+      return this;
+    }
+
+    /**
+     * Adds a set of {@link EnvFlags} to any existing flags.
+     *
+     * @param dbiFlagSet The set of flags to add to any existing flags.
+     *                   A null value is a no-op.
+     * @return this builder instance.
+     */
+    public Builder<T> addEnvFlags(final EnvFlagSet dbiFlagSet) {
+      if (dbiFlagSet != null) {
+        flagSetBuilder.setFlags(dbiFlagSet.getFlags());
+      }
+      return this;
+    }
   }
 
   /**
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index 0c83f31e..dc034f7f 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -39,7 +39,6 @@
 import java.nio.ByteOrder;
 import java.time.Duration;
 import java.time.Instant;
-import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -65,8 +64,14 @@ void buffersMustBeDirect() {
         () -> {
           FileUtil.useTempDir(
               dir -> {
-                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(dir.toFile())) {
-                  final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                try (Env<ByteBuffer> env = create()
+                    .setMaxReaders(1)
+                    .open(dir)) {
+                  final Dbi<ByteBuffer> db = env.buildDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE)
+                      .open();
                   final ByteBuffer key = allocate(100);
                   key.putInt(1).flip();
                   final ByteBuffer val = allocate(100);
@@ -201,9 +206,9 @@ public void verifyComparators() {
         .filter(i -> i >= 0)
         .limit(5_000_000)
         .toArray();
-    System.out.println("stats: " + Arrays.stream(values)
-        .summaryStatistics()
-        .toString());
+//    System.out.println("stats: " + Arrays.stream(values)
+//        .summaryStatistics()
+//        .toString());
 
     final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
     comparators.put("compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
new file mode 100644
index 00000000..5b9e0761
--- /dev/null
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -0,0 +1,369 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.lmdbjava;
+
+import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
+import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
+import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
+
+import io.netty.buffer.ByteBuf;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Random;
+import java.util.stream.Stream;
+import org.agrona.DirectBuffer;
+import org.agrona.concurrent.UnsafeBuffer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Tests comparator functions are consistent across buffers.
+ */
+public final class ComparatorIntegerKeyTest {
+
+  static Stream<Arguments> comparatorProvider() {
+    return Stream.of(
+        Arguments.argumentSet("LongRunner", new DirectBufferRunner()),
+        Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
+        Arguments.argumentSet("ByteBufferRunner", new ByteBufferRunner()),
+        Arguments.argumentSet("NettyRunner", new NettyRunner()));
+  }
+
+  private static byte[] buffer(final int... bytes) {
+    final byte[] array = new byte[bytes.length];
+    for (int i = 0; i < bytes.length; i++) {
+      array[i] = (byte) bytes[i];
+    }
+    return array;
+  }
+
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testLong(final ComparatorRunner comparator) {
+
+    assertThat(get(comparator.compare(0L, 0L))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(Long.MAX_VALUE, Long.MAX_VALUE))).isEqualTo(EQUAL_TO);
+
+    assertThat(get(comparator.compare(0L, 1L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0L, Long.MAX_VALUE))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0L, 10L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10L, 100L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10L, 100L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10L, 1000L))).isEqualTo(LESS_THAN);
+
+    assertThat(get(comparator.compare(1L, 0L))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(Long.MAX_VALUE, 0L))).isEqualTo(GREATER_THAN);
+  }
+
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testInt(final ComparatorRunner comparator) {
+
+    assertThat(get(comparator.compare(0, 0))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(Integer.MAX_VALUE, Integer.MAX_VALUE))).isEqualTo(EQUAL_TO);
+
+    assertThat(get(comparator.compare(0, 1))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0, Integer.MAX_VALUE))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0, 10))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10, 100))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10, 100))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10, 1000))).isEqualTo(LESS_THAN);
+
+    assertThat(get(comparator.compare(1, 0))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(Integer.MAX_VALUE, 0))).isEqualTo(GREATER_THAN);
+  }
+
+  @Test
+  void testRandomLong() {
+    final Random random = new Random(3239480);
+    final Map<String, ComparatorRunner> nameToRunnerMap = new LinkedHashMap<>();
+    nameToRunnerMap.put("DirectBufferRunner", new DirectBufferRunner());
+    nameToRunnerMap.put("ByteBufferRunner", new ByteBufferRunner());
+    nameToRunnerMap.put("NettyRunner", new NettyRunner());
+
+    // 5mil random longs to compare
+    final long[] values = random.longs()
+        .filter(i -> i >= 0)
+        .limit(5_000_000)
+        .toArray();
+
+    for (int i = 1; i < values.length; i++) {
+      final long long1 = values[i - 1];
+      final long long2 = values[i];
+      for (Map.Entry<String, ComparatorRunner> entry : nameToRunnerMap.entrySet()) {
+        final String name = entry.getKey();
+        final ComparatorRunner runner = entry.getValue();
+        // Make sure the comparator under test gives the same outcome as just comparing two longs
+        final ComparatorTest.ComparatorResult result = get(runner.compare(long1, long2));
+        final ComparatorTest.ComparatorResult expectedResult = get(Long.compare(long1, long2));
+
+        assertThat(result)
+            .withFailMessage(() -> "Compare mismatch for " + name + " - long1: " + long1
+                + ", long2: " + long2
+                + ", expected: " + expectedResult
+                + ", actual: " + result)
+            .isEqualTo(expectedResult);
+
+        final ComparatorTest.ComparatorResult result2 = get(runner.compare(long2, long1));
+        final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+
+        assertThat(result)
+            .withFailMessage(() -> "Compare mismatch for " + name + " - long2: " + long2
+                + ", long1: " + long1
+                + ", expected2: " + expectedResult2
+                + ", actual2: " + result2)
+            .isEqualTo(expectedResult);
+      }
+    }
+  }
+
+  @Test
+  void testRandomInt() {
+    final Random random = new Random(3239480);
+    final Map<String, ComparatorRunner> nameToRunnerMap = new LinkedHashMap<>();
+    nameToRunnerMap.put("DirectBufferRunner", new DirectBufferRunner());
+    nameToRunnerMap.put("ByteBufferRunner", new ByteBufferRunner());
+    nameToRunnerMap.put("NettyRunner", new NettyRunner());
+
+    // 5mil random ints to compare
+    final int[] values = random.ints()
+        .filter(i -> i >= 0)
+        .limit(5_000_000)
+        .toArray();
+
+    for (int i = 1; i < values.length; i++) {
+      final int int1 = values[i - 1];
+      final int int2 = values[i];
+      for (Map.Entry<String, ComparatorRunner> entry : nameToRunnerMap.entrySet()) {
+        final String name = entry.getKey();
+        final ComparatorRunner runner = entry.getValue();
+        // Make sure the comparator under test gives the same outcome as just comparing two ints
+        final ComparatorTest.ComparatorResult result = get(runner.compare(int1, int2));
+        final ComparatorTest.ComparatorResult expectedResult = get(Integer.compare(int1, int2));
+
+        assertThat(result)
+            .withFailMessage(() -> "Compare mismatch for " + name + " - int1: " + int1
+                + ", int2: " + int2
+                + ", expected: " + expectedResult
+                + ", actual: " + result)
+            .isEqualTo(expectedResult);
+
+        final ComparatorTest.ComparatorResult result2 = get(runner.compare(int2, int1));
+        final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+
+        assertThat(result)
+            .withFailMessage(() -> "Compare mismatch for " + name + " - int2: " + int2
+                + ", int1: " + int1
+                + ", expected2: " + expectedResult2
+                + ", actual2: " + result2)
+            .isEqualTo(expectedResult);
+      }
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  /**
+   * Tests {@link ByteBufferProxy}.
+   */
+  private static final class ByteBufferRunner implements ComparatorRunner {
+
+    private static final Comparator<ByteBuffer> COMPARATOR = PROXY_OPTIMAL.getComparator(DbiFlags.MDB_INTEGERKEY);
+
+    @Override
+    public int compare(long long1, long long2) {
+      // Convert arrays to buffers that are larger than the array, with
+      // limit set at the array length. One buffer bigger than the other.
+      ByteBuffer o1b = longToBuffer(long1, Long.BYTES * 3);
+      ByteBuffer o2b = longToBuffer(long2, Long.BYTES * 2);
+      final int result = COMPARATOR.compare(o1b, o2b);
+
+      // Now swap which buffer is bigger
+      o1b = longToBuffer(long1, Long.BYTES * 2);
+      o2b = longToBuffer(long2, Long.BYTES * 3);
+      final int result2 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result2).isEqualTo(result);
+
+      // Now try with buffers sized to the array.
+      o1b = longToBuffer(long1, Long.BYTES);
+      o2b = longToBuffer(long2, Long.BYTES);
+      final int result3 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result3).isEqualTo(result);
+      return result;
+    }
+
+    @Override
+    public int compare(int int1, int int2) {
+      // Convert arrays to buffers that are larger than the array, with
+      // limit set at the array length. One buffer bigger than the other.
+      ByteBuffer o1b = intToBuffer(int1, Integer.BYTES * 3);
+      ByteBuffer o2b = intToBuffer(int2, Integer.BYTES * 2);
+      final int result = COMPARATOR.compare(o1b, o2b);
+
+      // Now swap which buffer is bigger
+      o1b = intToBuffer(int1, Integer.BYTES * 2);
+      o2b = intToBuffer(int2, Integer.BYTES * 3);
+      final int result2 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result2).isEqualTo(result);
+
+      // Now try with buffers sized to the array.
+      o1b = intToBuffer(int1, Integer.BYTES);
+      o2b = intToBuffer(int2, Integer.BYTES);
+      final int result3 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result3).isEqualTo(result);
+      return result;
+    }
+
+    private ByteBuffer longToBuffer(final long val, final int bufferCapacity) {
+      final ByteBuffer byteBuffer = ByteBuffer.allocate(bufferCapacity);
+      byteBuffer.order(ByteOrder.nativeOrder());
+      byteBuffer.putLong(0, val);
+      byteBuffer.limit(Long.BYTES);
+      byteBuffer.position(0);
+      return byteBuffer;
+    }
+
+    private ByteBuffer intToBuffer(final int val, final int bufferCapacity) {
+      final ByteBuffer byteBuffer = ByteBuffer.allocate(bufferCapacity);
+      byteBuffer.order(ByteOrder.nativeOrder());
+      byteBuffer.putInt(0, val);
+      byteBuffer.limit(Integer.BYTES);
+      byteBuffer.position(0);
+      return byteBuffer;
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  /**
+   * Tests {@link DirectBufferProxy}.
+   */
+  private static final class DirectBufferRunner implements ComparatorRunner {
+    private static final Comparator<DirectBuffer> COMPARATOR = PROXY_DB.getComparator(DbiFlags.MDB_INTEGERKEY);
+
+    @Override
+    public int compare(long long1, long long2) {
+      final UnsafeBuffer o1b = new UnsafeBuffer(new byte[Long.BYTES]);
+      final UnsafeBuffer o2b = new UnsafeBuffer(new byte[Long.BYTES]);
+      o1b.putLong(0, long1, ByteOrder.nativeOrder());
+      o2b.putLong(0, long2, ByteOrder.nativeOrder());
+      return COMPARATOR.compare(o1b, o2b);
+    }
+
+    @Override
+    public int compare(int int1, int int2) {
+      final UnsafeBuffer o1b = new UnsafeBuffer(new byte[Integer.BYTES]);
+      final UnsafeBuffer o2b = new UnsafeBuffer(new byte[Integer.BYTES]);
+      o1b.putInt(0, int1, ByteOrder.nativeOrder());
+      o2b.putInt(0, int2, ByteOrder.nativeOrder());
+      return COMPARATOR.compare(o1b, o2b);
+    }
+  }
+
+  /**
+   * Tests {@link ByteBufProxy}.
+   */
+  private static final class NettyRunner implements ComparatorRunner {
+
+    private static final Comparator<ByteBuf> COMPARATOR = PROXY_NETTY.getComparator(DbiFlags.MDB_INTEGERKEY);
+
+    @Override
+    public int compare(long long1, long long2) {
+      final ByteBuf o1b = DEFAULT.directBuffer(Long.BYTES);
+      final ByteBuf o2b = DEFAULT.directBuffer(Long.BYTES);
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        o1b.writeLongLE(long1);
+        o2b.writeLongLE(long2);
+      } else {
+        o1b.writeLong(long1);
+        o2b.writeLong(long2);
+      }
+      o1b.resetReaderIndex();
+      o2b.resetReaderIndex();
+      final int res = COMPARATOR.compare(o1b, o2b);
+      o1b.release();
+      o2b.release();
+      return res;
+    }
+
+    @Override
+    public int compare(int int1, int int2) {
+      final ByteBuf o1b = DEFAULT.directBuffer(Integer.BYTES);
+      final ByteBuf o2b = DEFAULT.directBuffer(Integer.BYTES);
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        o1b.writeIntLE(int1);
+        o2b.writeIntLE(int2);
+      } else {
+        o1b.writeInt(int1);
+        o2b.writeInt(int2);
+      }
+      o1b.resetReaderIndex();
+      o2b.resetReaderIndex();
+      final int res = COMPARATOR.compare(o1b, o2b);
+      o1b.release();
+      o2b.release();
+      return res;
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  /**
+   * Interface that can test a {@link BufferProxy} <code>compare</code> method.
+   */
+  private interface ComparatorRunner {
+
+    /**
+     * Write the two longs to a buffer using native order and compare the resulting buffers.
+     *
+     * @param long1 lhs value
+     * @param long2 rhs value
+     * @return as per {@link Comparable}
+     */
+    int compare(final long long1, final long long2);
+
+    /**
+     * Write the two int to a buffer using native order and compare the resulting buffers.
+     *
+     * @param int1 lhs value
+     * @param int2 rhs value
+     * @return as per {@link Comparable}
+     */
+    int compare(final int int1, final int int2);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index bc7ddefe..1d4ed4c8 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -259,6 +259,16 @@ static ComparatorResult get(final int comparatorResult) {
       }
       return comparatorResult < 0 ? LESS_THAN : GREATER_THAN;
     }
+
+    ComparatorResult opposite() {
+      if (this == LESS_THAN) {
+        return GREATER_THAN;
+      } else if (this == GREATER_THAN) {
+        return LESS_THAN;
+      } else {
+        return EQUAL_TO;
+      }
+    }
   }
 
   /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index c55687c4..393065a3 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -191,11 +191,11 @@ private void populateDatabase(final Dbi<ByteBuffer> dbi) {
     try (Txn<ByteBuffer> txn = env.txnRead();
          CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
 
-      for (final KeyVal<ByteBuffer> kv : c) {
-        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
-        System.out.print(", ");
-      }
-      System.out.println();
+//      for (final KeyVal<ByteBuffer> kv : c) {
+//        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
+//        System.out.print(", ");
+//      }
+//      System.out.println();
     }
   }
 
@@ -480,14 +480,14 @@ private void verify(final KeyRange<ByteBuffer> range,
         .collect(Collectors.toList());
 
     final List<Integer> results = new ArrayList<>();
-    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
+//    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
 
     try (Txn<ByteBuffer> txn = env.txnRead();
          CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = getNativeInt(kv.key());
         final int val = kv.val().getInt();
-        System.out.println(key + " => " + val);
+//        System.out.println(key + " => " + val);
         results.add(val);
         assertThat(val).satisfiesAnyOf(
             v -> assertThat(v).isEqualTo((key * 10) + 1),
@@ -544,27 +544,27 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
                                                         ExtensionContext context) throws Exception {
       final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
           env.buildDbi()
-              .withDbName(DB_1)
+              .setDbName(DB_1)
               .withDefaultComparator()
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
           env.buildDbi()
-              .withDbName(DB_2)
+              .setDbName(DB_2)
               .withNativeComparator()
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
           env.buildDbi()
-              .withDbName(DB_3)
+              .setDbName(DB_3)
               .withCallbackComparator(buildComparator())
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
           env.buildDbi()
-              .withDbName(DB_4)
+              .setDbName(DB_4)
               .withIteratorComparator(buildComparator())
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       return Stream.of(
               defaultComparatorDb,
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 21d34d30..aa23235a 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -20,7 +20,6 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
-import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.KeyRange.all;
 import static org.lmdbjava.KeyRange.allBackward;
@@ -45,7 +44,6 @@
 import static org.lmdbjava.TestUtils.DB_2;
 import static org.lmdbjava.TestUtils.DB_3;
 import static org.lmdbjava.TestUtils.DB_4;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.bbNative;
 import static org.lmdbjava.TestUtils.getNativeInt;
@@ -101,16 +99,16 @@ public final class CursorIterableIntegerKeyTest {
   @Parameter
   public DbiFactory dbiFactory;
 
-
   @BeforeEach
   public void before() throws IOException {
     file = FileUtil.createTempFile();
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env = create(bufferProxy)
+    env = Env.create(bufferProxy)
         .setMapSize(KIBIBYTES.toBytes(256))
         .setMaxReaders(1)
         .setMaxDbs(3)
-        .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+        .setEnvFlags(MDB_NOSUBDIR)
+        .open(file);
 
     populateTestDataList();
   }
@@ -129,7 +127,7 @@ public void testNumericOrderLong() {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       long i = 1;
       while (true) {
-        System.out.println("putting " + i);
+//        System.out.println("putting " + i);
         c.put(bbNative(i), bb(i + "-long"));
         final long i2 = i * 10;
         if (i2 < i) {
@@ -176,7 +174,7 @@ public void testNumericOrderInt() {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       int i = 1;
       while (true) {
-        System.out.println("putting " + i);
+//        System.out.println("putting " + i);
         c.put(bbNative(i), bb(i + "-int"));
         final int i2 = i * 10;
         if (i2 < i) {
@@ -221,7 +219,7 @@ public void testIntegerKeyKeySize() {
     long maxIntAsLong = Integer.MAX_VALUE;
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      System.out.println("Flags: " + db.listFlags(txn));
+//      System.out.println("Flags: " + db.listFlags(txn));
       int val = 0;
       db.put(txn, bbNative(0L), bb("val_" + ++val));
       db.put(txn, bbNative(10L), bb("val_" + ++val));
@@ -243,7 +241,7 @@ public void testIntegerKeyKeySize() {
           final String val = getString(keyVal.val());
           final long key = getNativeLong(keyVal.key());
           final int remaining = keyVal.key().remaining();
-          System.out.println("key: " + key + ", val: " + val + ", remaining: " + remaining);
+//          System.out.println("key: " + key + ", val: " + val + ", remaining: " + remaining);
         }
       }
     }
@@ -603,29 +601,29 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
                                                         ExtensionContext context) throws Exception {
       final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
           env.buildDbi()
-              .withDbName(DB_1)
+              .setDbName(DB_1)
               .withDefaultComparator()
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
           env.buildDbi()
-              .withDbName(DB_2)
+              .setDbName(DB_2)
               .withNativeComparator()
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final Comparator<ByteBuffer> comparator = buildComparator();
 
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
           env.buildDbi()
-              .withDbName(DB_3)
+              .setDbName(DB_3)
               .withCallbackComparator(comparator)
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
           env.buildDbi()
-              .withDbName(DB_4)
+              .setDbName(DB_4)
               .withIteratorComparator(comparator)
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       return Stream.of(
               defaultComparatorDb,
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 6bf1ee71..008695fd 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -65,22 +65,22 @@ public void before() throws IOException {
     final DbiFlagSet dbiFlagSet = MDB_CREATE;
     // Use a java comparator for start/stop keys only
     dbJavaComparator = env.buildDbi()
-        .withDbName("JavaComparator")
+        .setDbName("JavaComparator")
         .withDefaultComparator()
-        .withDbiFlags(dbiFlagSet)
+        .setDbiFlags(dbiFlagSet)
         .open();
     // Use LMDB comparator for start/stop keys
     dbLmdbComparator = env.buildDbi()
-        .withDbName("LmdbComparator")
+        .setDbName("LmdbComparator")
         .withNativeComparator()
-        .withDbiFlags(dbiFlagSet)
+        .setDbiFlags(dbiFlagSet)
         .open();
 
     // Use a java comparator for start/stop keys and as a callback comparator
     dbCallbackComparator = env.buildDbi()
-        .withDbName("CallBackComparator")
+        .setDbName("CallBackComparator")
         .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
-        .withDbiFlags(dbiFlagSet)
+        .setDbiFlags(dbiFlagSet)
         .open();
 
     dbs.add(dbJavaComparator);
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 30894a9c..0286fa88 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -46,7 +46,6 @@
 import static org.lmdbjava.TestUtils.DB_2;
 import static org.lmdbjava.TestUtils.DB_3;
 import static org.lmdbjava.TestUtils.DB_4;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
 import com.google.common.primitives.UnsignedBytes;
@@ -95,42 +94,6 @@ public final class CursorIterableTest {
   @Parameter
   public DbiFactory dbiFactory;
 
-//  ArgumentsSource
-
-//  @Parameterized.Parameters(name = "{index}: dbi: {0}")
-
-//  public static Object[] data() {
-//    final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-//        env.buildDbi()
-//            .withDbName(DB_1)
-//            .withDefaultComparator()
-//            .withDbiFlags(DBI_FLAGS)
-//            .open());
-//    final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-//        env.buildDbi()
-//            .withDbName(DB_2)
-//            .withNativeComparator()
-//            .withDbiFlags(DBI_FLAGS)
-//            .open());
-//    final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-//        env.buildDbi()
-//            .withDbName(DB_3)
-//            .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
-//            .withDbiFlags(DBI_FLAGS)
-//            .open());
-//    final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-//        env.buildDbi()
-//            .withDbName(DB_4)
-//            .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
-//            .withDbiFlags(DBI_FLAGS)
-//            .open());
-//    return new Object[]{
-//        defaultComparatorDb,
-//        nativeComparatorDb,
-//        callbackComparatorDb,
-//        iteratorComparatorDb};
-//  }
-
   @BeforeEach
   void beforeEach() {
     file = FileUtil.createTempFile();
@@ -139,7 +102,8 @@ void beforeEach() {
         .setMapSize(KIBIBYTES.toBytes(256))
         .setMaxReaders(1)
         .setMaxDbs(3)
-        .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+        .setEnvFlags(MDB_NOSUBDIR)
+        .open(file);
 
     populateTestDataList();
   }
@@ -571,27 +535,27 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
                                                         ExtensionContext context) throws Exception {
       final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
           env.buildDbi()
-              .withDbName(DB_1)
+              .setDbName(DB_1)
               .withDefaultComparator()
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
           env.buildDbi()
-              .withDbName(DB_2)
+              .setDbName(DB_2)
               .withNativeComparator()
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
           env.buildDbi()
-              .withDbName(DB_3)
+              .setDbName(DB_3)
               .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
           env.buildDbi()
-              .withDbName(DB_4)
+              .setDbName(DB_4)
               .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       return Stream.of(
               defaultComparatorDb,
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index fa0a4792..25e622bf 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -20,11 +20,15 @@
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.getString;
 
-import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -35,18 +39,20 @@ public class DbiBuilderTest {
   private Env<ByteBuffer> env;
 
   @BeforeEach
-  public void before() throws IOException {
+  public void before() {
     file = FileUtil.createTempFile();
     env = create()
         .setMapSize(MEBIBYTES.toBytes(64))
         .setMaxReaders(2)
         .setMaxDbs(2)
-        .open(file.toFile(), MDB_NOSUBDIR);
+        .setEnvFlags(MDB_NOSUBDIR)
+        .open(file);
   }
 
   @AfterEach
   public void after() {
     env.close();
+    FileUtil.delete(file);
   }
 
   @Test
@@ -54,7 +60,7 @@ public void unnamed() {
     final Dbi<ByteBuffer> dbi = env.buildDbi()
         .withoutDbName()
         .withDefaultComparator()
-        .withDbiFlags(DbiFlags.MDB_CREATE)
+        .setDbiFlags(DbiFlags.MDB_CREATE)
         .open();
     assertThat(dbi.getName()).isNull();
     assertThat(dbi.getNameAsString()).isEmpty();
@@ -65,15 +71,120 @@ public void unnamed() {
   @Test
   public void named() {
     final Dbi<ByteBuffer> dbi = env.buildDbi()
-        .withDbName("foo")
+        .setDbName("foo")
         .withDefaultComparator()
-        .withDbiFlags(DbiFlags.MDB_CREATE)
+        .setDbiFlags(DbiFlags.MDB_CREATE)
         .open();
 
     assertPutAndGet(dbi);
 
     assertThat(env.getDbiNames()).hasSize(1);
-    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8)).isEqualTo("foo");
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8))
+        .isEqualTo("foo");
+    assertThat(dbi.getNameAsString())
+        .isEqualTo("foo");
+    assertThat(dbi.getNameAsString(StandardCharsets.UTF_8))
+        .isEqualTo("foo");
+  }
+
+  @Test
+  public void named2() {
+    final Dbi<ByteBuffer> dbi = env.buildDbi()
+        .setDbName("foo".getBytes(StandardCharsets.US_ASCII))
+        .withDefaultComparator()
+        .setDbiFlags(DbiFlags.MDB_CREATE)
+        .open();
+
+    assertPutAndGet(dbi);
+
+    assertThat(env.getDbiNames()).hasSize(1);
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.US_ASCII))
+        .isEqualTo("foo");
+    assertThat(dbi.getNameAsString())
+        .isEqualTo("foo");
+    assertThat(dbi.getNameAsString(StandardCharsets.US_ASCII))
+        .isEqualTo("foo");
+  }
+
+  @Test
+  public void nativeComparator() {
+    final Dbi<ByteBuffer> dbi = env.buildDbi()
+        .setDbName("foo")
+        .withNativeComparator()
+        .addDbiFlags(DbiFlags.MDB_CREATE)
+        .open();
+
+    assertPutAndGet(dbi);
+    assertThat(env.getDbiNames()).hasSize(1);
+  }
+
+  @Test
+  public void callback() {
+    final Comparator<ByteBuffer> proxyOptimal = ByteBufferProxy.PROXY_OPTIMAL.getComparator();
+    // Compare on key length, falling back to default
+    final Comparator<ByteBuffer> comparator = (o1, o2) -> {
+      final int res = Integer.compare(o1.remaining(), o2.remaining());
+      if (res == 0) {
+        return proxyOptimal.compare(o1, o2);
+      } else {
+        return res;
+      }
+    };
+
+    final Dbi<ByteBuffer> dbi = env.buildDbi()
+        .setDbName("foo")
+        .withCallbackComparator(comparator)
+        .addDbiFlags(DbiFlags.MDB_CREATE)
+        .open();
+
+    TestUtils.doWithWriteTxn(env, txn -> {
+      dbi.put(txn, bb("fox"), bb("val_1"));
+      dbi.put(txn, bb("rabbit"), bb("val_2"));
+      dbi.put(txn, bb("deer"), bb("val_3"));
+      dbi.put(txn, bb("badger"), bb("val_4"));
+      txn.commit();
+    });
+
+    final List<String> keys = new ArrayList<>();
+    TestUtils.doWithReadTxn(env, txn -> {
+      try (CursorIterable<ByteBuffer> cursorIterable = dbi.iterate(txn)) {
+        final Iterator<CursorIterable.KeyVal<ByteBuffer>> iterator = cursorIterable.iterator();
+        iterator.forEachRemaining(keyVal -> {
+          keys.add(getString(keyVal.key()));
+        });
+      }
+    });
+    assertThat(keys).containsExactly(
+        "fox",
+        "deer",
+        "badger",
+        "rabbit");
+  }
+
+  @Test
+  public void flags() {
+    final Dbi<ByteBuffer> dbi = env.buildDbi()
+        .setDbName("foo")
+        .withDefaultComparator()
+        .setDbiFlags(DbiFlags.MDB_DUPSORT, DbiFlags.MDB_DUPFIXED) // Will get overwritten
+        .setDbiFlags() // clear them
+        .addDbiFlags(DbiFlags.MDB_CREATE) // Not a dbi flag as far as lmdb is concerned.
+        .addDbiFlags(DbiFlags.MDB_INTEGERKEY)
+        .addDbiFlags(DbiFlags.MDB_REVERSEKEY)
+        .open();
+
+    assertPutAndGet(dbi);
+
+    assertThat(env.getDbiNames()).hasSize(1);
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8))
+        .isEqualTo("foo");
+
+    TestUtils.doWithReadTxn(env, readTxn -> {
+      assertThat(dbi.listFlags(readTxn))
+          .containsExactlyInAnyOrder(
+              DbiFlags.MDB_INTEGERKEY,
+              DbiFlags.MDB_REVERSEKEY);
+    });
   }
 
   private void assertPutAndGet(Dbi<ByteBuffer> dbi) {
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index c369c193..7302018c 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -110,7 +110,7 @@ void close() {
     assertThatThrownBy(
             () -> {
               final Dbi<ByteBuffer> db = env.buildDbi()
-                  .withDbName(DB_1)
+                  .setDbName(DB_1)
                   .withDefaultComparator()
                   .addDbiFlag(MDB_CREATE)
                   .open();
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 94ceb3a7..68d988d1 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -25,6 +25,9 @@
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.charset.StandardCharsets;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
 
@@ -133,4 +136,36 @@ static ByteBuf nb(final int value) {
     b.writeInt(value);
     return b;
   }
+
+  static <T> void doWithReadTxn(final Env<T> env, final Consumer<Txn<T>> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnRead()) {
+      work.accept(readTxn);
+    }
+  }
+
+  static <T, R> R getWithReadTxn(final Env<T> env, final Function<Txn<T>, R> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnRead()) {
+      return work.apply(readTxn);
+    }
+  }
+
+  static <T> void doWithWriteTxn(final Env<T> env, final Consumer<Txn<T>> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnWrite()) {
+      work.accept(readTxn);
+    }
+  }
+
+  static <T, R> R getWithWriteTxn(final Env<T> env, final Function<Txn<T>, R> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnWrite()) {
+      return work.apply(readTxn);
+    }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index bdaf9320..58f75aa6 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -23,57 +23,74 @@
 
 public class TxnFlagSetTest {
 
-    @Test
-    public void testEmpty() {
-        final TxnFlagSet txnFlagSet = TxnFlagSet.empty();
-        assertThat(txnFlagSet.getMask()).isEqualTo(0);
-        assertThat(txnFlagSet.size()).isEqualTo(0);
-        assertThat(txnFlagSet.isEmpty()).isEqualTo(true);
-        assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(false);
-        final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-            .build();
-        assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
-        assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.of(TxnFlags.MDB_RDONLY_TXN));
-        assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.builder()
-            .setFlag(TxnFlags.MDB_RDONLY_TXN)
-            .build());
+  @Test
+  void testSingleEnum() {
+    final TxnFlagSet txnFlagSet = TxnFlags.MDB_RDONLY_TXN;
+    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(TxnFlags.MDB_RDONLY_TXN));
+    assertThat(txnFlagSet.size()).isEqualTo(1);
+    for (TxnFlags flag : txnFlagSet) {
+      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
     }
 
-    @Test
-    public void testOf() {
-        final TxnFlags txnFlag = TxnFlags.MDB_RDONLY_TXN;
-        final TxnFlagSet txnFlagSet = TxnFlagSet.of(txnFlag);
-        assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag));
-        assertThat(txnFlagSet.size()).isEqualTo(1);
-        for (TxnFlags flag : txnFlagSet) {
-            assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
-        }
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+        .setFlag(TxnFlags.MDB_RDONLY_TXN)
+        .build();
+    assertThat(txnFlagSet2.getFlags()).containsExactlyElementsOf(txnFlagSet.getFlags());
+    assertThat(txnFlagSet.areAnySet(TxnFlags.MDB_RDONLY_TXN)).isTrue();
+    assertThat(txnFlagSet.areAnySet(TxnFlagSet.empty())).isFalse();
+  }
 
-        final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-            .setFlag(txnFlag)
-            .build();
-        assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+  @Test
+  public void testEmpty() {
+    final TxnFlagSet txnFlagSet = TxnFlagSet.empty();
+    assertThat(txnFlagSet.getMask()).isEqualTo(0);
+    assertThat(txnFlagSet.size()).isEqualTo(0);
+    assertThat(txnFlagSet.isEmpty()).isEqualTo(true);
+    assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(false);
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+        .build();
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+    assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.of(TxnFlags.MDB_RDONLY_TXN));
+    assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.builder()
+        .setFlag(TxnFlags.MDB_RDONLY_TXN)
+        .build());
+  }
+
+  @Test
+  public void testOf() {
+    final TxnFlags txnFlag = TxnFlags.MDB_RDONLY_TXN;
+    final TxnFlagSet txnFlagSet = TxnFlagSet.of(txnFlag);
+    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag));
+    assertThat(txnFlagSet.size()).isEqualTo(1);
+    for (TxnFlags flag : txnFlagSet) {
+      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
     }
 
-    @Test
-    public void testBuilder() {
-        final TxnFlags txnFlag1 = TxnFlags.MDB_RDONLY_TXN;
-        final TxnFlagSet txnFlagSet = TxnFlagSet.builder()
-                .setFlag(txnFlag1)
-                .build();
-        assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag1));
-        assertThat(txnFlagSet.size()).isEqualTo(1);
-        assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(true);
-        for (TxnFlags flag : txnFlagSet) {
-            assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
-        }
-        final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-                .withFlags(txnFlag1)
-                .build();
-        final TxnFlagSet txnFlagSet3 = TxnFlagSet.builder()
-                .withFlags(new HashSet<>(Collections.singletonList(txnFlag1)))
-                .build();
-        assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
-        assertThat(txnFlagSet).isEqualTo(txnFlagSet3);
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+        .setFlag(txnFlag)
+        .build();
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+  }
+
+  @Test
+  public void testBuilder() {
+    final TxnFlags txnFlag1 = TxnFlags.MDB_RDONLY_TXN;
+    final TxnFlagSet txnFlagSet = TxnFlagSet.builder()
+        .setFlag(txnFlag1)
+        .build();
+    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag1));
+    assertThat(txnFlagSet.size()).isEqualTo(1);
+    assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(true);
+    for (TxnFlags flag : txnFlagSet) {
+      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
     }
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+        .withFlags(txnFlag1)
+        .build();
+    final TxnFlagSet txnFlagSet3 = TxnFlagSet.builder()
+        .withFlags(new HashSet<>(Collections.singletonList(txnFlag1)))
+        .build();
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet3);
+  }
 }

From 7374fde065fd2c71ce5b90ac785a3989a0a92207 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 13:21:08 +0000
Subject: [PATCH 23/90] #267 Fix to establish start key when iterating
 backwards from a start key using DUPSORT

---
 .../java/org/lmdbjava/ComparatorTest.java     | 35 ++++++++++-------
 .../java/org/lmdbjava/CursorParamTest.java    | 38 +++++++++----------
 2 files changed, 40 insertions(+), 33 deletions(-)

diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index a5e010ab..674f4059 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -34,9 +34,12 @@
 import java.util.stream.Stream;
 import org.agrona.DirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
+import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import org.junit.jupiter.params.support.ParameterDeclarations;
 
 /** Tests comparator functions are consistent across buffers. */
 public final class ComparatorTest {
@@ -54,16 +57,20 @@ public final class ComparatorTest {
   private static final byte[] LX = buffer(0);
   private static final byte[] XX = buffer();
 
-  static Stream<Arguments> comparatorProvider() {
-    return Stream.of(
-        Arguments.argumentSet("StringRunner", new StringRunner()),
-        Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
-        Arguments.argumentSet("ByteArrayRunner", new ByteArrayRunner()),
-        Arguments.argumentSet("UnsignedByteArrayRunner", new UnsignedByteArrayRunner()),
-        Arguments.argumentSet("ByteBufferRunner", new ByteBufferRunner()),
-        Arguments.argumentSet("NettyRunner", new NettyRunner()),
-        Arguments.argumentSet("GuavaUnsignedBytes", new GuavaUnsignedBytes()),
-        Arguments.argumentSet("GuavaSignedBytes", new GuavaSignedBytes()));
+  static class MyArgumentProvider implements ArgumentsProvider {
+    @Override
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) {
+      return Stream.of(
+          Arguments.argumentSet("StringRunner", new StringRunner()),
+          Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
+          Arguments.argumentSet("ByteArrayRunner", new ByteArrayRunner()),
+          Arguments.argumentSet("UnsignedByteArrayRunner", new UnsignedByteArrayRunner()),
+          Arguments.argumentSet("ByteBufferRunner", new ByteBufferRunner()),
+          Arguments.argumentSet("NettyRunner", new NettyRunner()),
+          Arguments.argumentSet("GuavaUnsignedBytes", new GuavaUnsignedBytes()),
+          Arguments.argumentSet("GuavaSignedBytes", new GuavaSignedBytes()));
+    }
   }
 
   private static byte[] buffer(final int... bytes) {
@@ -75,7 +82,7 @@ private static byte[] buffer(final int... bytes) {
   }
 
   @ParameterizedTest
-  @MethodSource("comparatorProvider")
+  @ArgumentsSource(MyArgumentProvider.class)
   void atLeastOneBufferHasEightBytes(final ComparatorRunner comparator) {
     assertThat(get(comparator.compare(HLLLLLLL, LLLLLLLL))).isEqualTo(GREATER_THAN);
     assertThat(get(comparator.compare(LLLLLLLL, HLLLLLLL))).isEqualTo(LESS_THAN);
@@ -94,7 +101,7 @@ void atLeastOneBufferHasEightBytes(final ComparatorRunner comparator) {
   }
 
   @ParameterizedTest
-  @MethodSource("comparatorProvider")
+  @ArgumentsSource(MyArgumentProvider.class)
   void buffersOfTwoBytes(final ComparatorRunner comparator) {
     assertThat(get(comparator.compare(LL, XX))).isEqualTo(GREATER_THAN);
     assertThat(get(comparator.compare(XX, LL))).isEqualTo(LESS_THAN);
@@ -110,7 +117,7 @@ void buffersOfTwoBytes(final ComparatorRunner comparator) {
   }
 
   @ParameterizedTest
-  @MethodSource("comparatorProvider")
+  @ArgumentsSource(MyArgumentProvider.class)
   void equalBuffers(final ComparatorRunner comparator) {
     assertThat(get(comparator.compare(LL, LL))).isEqualTo(EQUAL_TO);
     assertThat(get(comparator.compare(HX, HX))).isEqualTo(EQUAL_TO);
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 7f0bad8a..6a0b01cd 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -32,15 +32,8 @@
 import static org.lmdbjava.GetOp.MDB_SET_KEY;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
-import static org.lmdbjava.SeekOp.MDB_FIRST;
-import static org.lmdbjava.SeekOp.MDB_LAST;
-import static org.lmdbjava.SeekOp.MDB_NEXT;
-import static org.lmdbjava.SeekOp.MDB_PREV;
-import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
-import static org.lmdbjava.TestUtils.bb;
-import static org.lmdbjava.TestUtils.mdb;
-import static org.lmdbjava.TestUtils.nb;
+import static org.lmdbjava.SeekOp.*;
+import static org.lmdbjava.TestUtils.*;
 
 import io.netty.buffer.ByteBuf;
 import java.nio.ByteBuffer;
@@ -48,26 +41,33 @@
 import java.util.stream.Stream;
 import org.agrona.DirectBuffer;
 import org.agrona.MutableDirectBuffer;
+import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.api.io.TempDir;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import org.junit.jupiter.params.support.ParameterDeclarations;
 
 /** Test {@link Cursor} with different buffer implementations. */
 public final class CursorParamTest {
 
-  static Stream<Arguments> data() {
-    return Stream.of(
-        Arguments.argumentSet(
-            "ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
-        Arguments.argumentSet("ByteBufferRunner(PROXY_SAFE)", new ByteBufferRunner(PROXY_SAFE)),
-        Arguments.argumentSet("ByteArrayRunner(PROXY_BA)", new ByteArrayRunner(PROXY_BA)),
-        Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
-        Arguments.argumentSet("NettyBufferRunner", new NettyBufferRunner()));
+  static class MyArgumentProvider implements ArgumentsProvider {
+    @Override
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) {
+      return Stream.of(
+          Arguments.argumentSet(
+              "ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
+          Arguments.argumentSet("ByteBufferRunner(PROXY_SAFE)", new ByteBufferRunner(PROXY_SAFE)),
+          Arguments.argumentSet("ByteArrayRunner(PROXY_BA)", new ByteArrayRunner(PROXY_BA)),
+          Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
+          Arguments.argumentSet("NettyBufferRunner", new NettyBufferRunner()));
+    }
   }
 
   @ParameterizedTest
-  @MethodSource("data")
+  @ArgumentsSource(MyArgumentProvider.class)
   void execute(final BufferRunner<?> runner, @TempDir final Path tmp) {
     runner.execute(tmp);
   }

From 787d6d38aa7f161cf2fd8ee3e10d466e69ab20eb Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 13:22:45 +0000
Subject: [PATCH 24/90] #267 Fix to establish start key when iterating
 backwards from a start key using DUPSORT

---
 src/main/java/org/lmdbjava/MaskedFlag.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 58d67d8c..87deb3c9 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -17,7 +17,6 @@
 
 import static java.util.Objects.requireNonNull;
 
-import java.util.Arrays;
 import java.util.Objects;
 import java.util.function.Predicate;
 import java.util.stream.Stream;

From c289763641e81d0b8c3e94e73725eb3abb36d9f2 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 13:43:06 +0000
Subject: [PATCH 25/90] #267 Fix to establish start key when iterating
 backwards from a start key using DUPSORT

---
 .gitignore                                    |   1 -
 .../java/org/lmdbjava/CursorIterable.java     |   6 +-
 .../java/org/lmdbjava/ComparatorTest.java     |   5 +-
 .../org/lmdbjava/CursorIterableRangeTest.java | 106 +++---------------
 .../java/org/lmdbjava/CursorParamTest.java    |  11 +-
 src/test/java/org/lmdbjava/DbiTest.java       |  16 ++-
 src/test/java/org/lmdbjava/EnvTest.java       |   6 +-
 src/test/java/org/lmdbjava/TutorialTest.java  |   4 +-
 8 files changed, 52 insertions(+), 103 deletions(-)

diff --git a/.gitignore b/.gitignore
index 44fe1d51..5f3ff273 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,5 +16,4 @@ dependency-reduced-pom.xml
 gpg-sign.json
 mvn-sync.json
 secrets.tar
-openldap
 pom.xml.versionsBackup
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index b6d58e3d..80fd5ef3 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -15,7 +15,11 @@
  */
 package org.lmdbjava;
 
-import static org.lmdbjava.CursorIterable.State.*;
+import static org.lmdbjava.CursorIterable.State.RELEASED;
+import static org.lmdbjava.CursorIterable.State.REQUIRES_INITIAL_OP;
+import static org.lmdbjava.CursorIterable.State.REQUIRES_ITERATOR_OP;
+import static org.lmdbjava.CursorIterable.State.REQUIRES_NEXT_OP;
+import static org.lmdbjava.CursorIterable.State.TERMINATED;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
 
 import java.util.Comparator;
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 674f4059..2fabb3da 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -22,7 +22,10 @@
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.*;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 
 import com.google.common.primitives.SignedBytes;
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index dd33e885..0802c047 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -19,12 +19,22 @@
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static java.nio.ByteBuffer.allocateDirect;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.lmdbjava.DbiFlags.*;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
-import static org.lmdbjava.TestUtils.*;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
 
-import java.io.*;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringWriter;
+import java.io.UncheckedIOException;
+import java.io.Writer;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.file.Path;
@@ -231,96 +241,6 @@ private long getLong(final ByteBuffer byteBuffer, final ByteOrder byteOrder) {
     }
   }
 
-  //
-  //  @Test
-  //  void testSignedComparator() throws IOException {
-  //    test(ByteBuffer::compareTo, true, "testSignedComparator", 1, MDB_CREATE);
-  //  }
-  //
-  //  @Test
-  //  void testUnsignedComparator() throws IOException {
-  //    test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparator", 1, MDB_CREATE);
-  //  }
-  //
-  //  @Test
-  //  void testSignedComparatorDupsort() throws IOException {
-  //    test(ByteBuffer::compareTo, true, "testSignedComparatorDupsort", 2, MDB_CREATE,
-  // MDB_DUPSORT);
-  //  }
-  //
-  //  @Test
-  //  void testUnsignedComparatorDupsort() throws IOException {
-  //    test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparatorDupsort", 2,
-  // MDB_CREATE, MDB_DUPSORT);
-  //  }
-  //
-  //  private void test(final Comparator<ByteBuffer> comparator,
-  //                    final boolean nativeCb,
-  //                    final String testName,
-  //                    final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
-  //                    final DbiFlags... flags) throws IOException {
-  //    final Path dbPath = Files.createTempFile("test", "db");
-  //    try (final Env<ByteBuffer> env =
-  //                 create()
-  //                         .setMapSize(KIBIBYTES.toBytes(256))
-  //                         .setMaxReaders(1)
-  //                         .setMaxDbs(1)
-  //                         .open(dbPath.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
-  //      final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, comparator, nativeCb, flags);
-  //      dbPopulator.accept(env, dbi);
-  //
-  //      final File tests = new File("src/test/resources/CursorIterableRangeTest/tests.csv");
-  //      final File actual = tests.getParentFile().toPath().resolve(testName + ".actual").toFile();
-  //      final File expected = tests.getParentFile().toPath().resolve(testName +
-  // ".expected").toFile();
-  //      final String csv = readFile(tests);
-  //      final String[] parts = csv.split("\n");
-  //      try (final Writer writer = new FileWriter(actual)) {
-  //        for (final String part : parts) {
-  //          final String[] params = part.split(",");
-  //          final KeyRangeType keyRangeType = KeyRangeType.valueOf(params[0].trim());
-  //          ByteBuffer start = null;
-  //          ByteBuffer stop = null;
-  //          if (params.length > 1 && params[1].trim().length() > 0) {
-  //            start = bb(Integer.parseInt(params[1].trim()));
-  //          }
-  //          if (params.length > 2 && params[2].trim().length() > 0) {
-  //            stop = bb(Integer.parseInt(params[2].trim()));
-  //          }
-  //
-  //          for (int i = 0; i < 3; i++) {
-  //            if (params.length > i) {
-  //              writer.append(params[i].trim());
-  //            }
-  //            writer.append(",");
-  //          }
-  //
-  //          final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
-  //          try (Txn<ByteBuffer> txn = env.txnRead();
-  //               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
-  //            for (final KeyVal<ByteBuffer> kv : c) {
-  //              final int key = kv.key().getInt();
-  //              final int val = kv.val().getInt();
-  //              writer.append("[");
-  //              writer.append(String.valueOf(key));
-  //              writer.append(" ");
-  //              writer.append(String.valueOf(val));
-  //              writer.append("]");
-  //            }
-  //          }
-  //          writer.append("\n");
-  //        }
-  //      }
-  //
-  //      // Compare files.
-  //      final String act = readFile(actual);
-  //      final String exp = readFile(expected);
-  //      assertThat(act).withFailMessage("Files are not equal").isEqualTo(exp);
-  //    } finally {
-  //      FileUtil.deleteFile(dbPath);
-  //    }
-  //  }
-
   private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createBasicDBPopulator() {
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 6a0b01cd..e228e968 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -32,8 +32,15 @@
 import static org.lmdbjava.GetOp.MDB_SET_KEY;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
-import static org.lmdbjava.SeekOp.*;
-import static org.lmdbjava.TestUtils.*;
+import static org.lmdbjava.SeekOp.MDB_FIRST;
+import static org.lmdbjava.SeekOp.MDB_LAST;
+import static org.lmdbjava.SeekOp.MDB_NEXT;
+import static org.lmdbjava.SeekOp.MDB_PREV;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.mdb;
+import static org.lmdbjava.TestUtils.nb;
 
 import io.netty.buffer.ByteBuf;
 import java.nio.ByteBuffer;
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 2c4a90b7..563215c4 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -29,14 +29,20 @@
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import static org.lmdbjava.DbiFlags.*;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
+import static org.lmdbjava.DbiFlags.MDB_REVERSEKEY;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.GetOp.MDB_SET_KEY;
 import static org.lmdbjava.KeyRange.atMost;
 import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
-import static org.lmdbjava.TestUtils.*;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.ba;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.fromBa;
 
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
@@ -44,7 +50,11 @@
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
-import java.util.concurrent.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index d66aa3a3..6c24c406 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -40,7 +40,11 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.lmdbjava.Env.*;
+import org.lmdbjava.Env.AlreadyClosedException;
+import org.lmdbjava.Env.AlreadyOpenException;
+import org.lmdbjava.Env.Builder;
+import org.lmdbjava.Env.InvalidCopyDestination;
+import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.Txn.BadReaderLockException;
 
 /** Test {@link Env}. */
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 8376fbe7..6af2599b 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -27,7 +27,9 @@
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.GetOp.MDB_SET;
-import static org.lmdbjava.SeekOp.*;
+import static org.lmdbjava.SeekOp.MDB_FIRST;
+import static org.lmdbjava.SeekOp.MDB_LAST;
+import static org.lmdbjava.SeekOp.MDB_PREV;
 
 import java.nio.ByteBuffer;
 import java.nio.file.Path;

From 1acd9711efb752013b6588e5e3d106474afa5822 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 5 Nov 2025 16:57:43 +0000
Subject: [PATCH 26/90] Add ComparatorFactory

---
 src/main/java/org/lmdbjava/DbiBuilder.java    |  50 +++++---
 .../lmdbjava/ComparatorIntegerKeyTest.java    | 109 ++++++++----------
 .../CursorIterableIntegerDupTest.java         |   6 +-
 .../CursorIterableIntegerKeyTest.java         |   8 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  |   2 +-
 .../java/org/lmdbjava/CursorIterableTest.java |  11 +-
 .../java/org/lmdbjava/DbiBuilderTest.java     |   2 +-
 7 files changed, 96 insertions(+), 92 deletions(-)

diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index f94118a7..9cb85616 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -49,8 +49,9 @@ public class DbiBuilder<T> {
    * <p>
    * The name will be converted into bytes using {@link StandardCharsets#UTF_8}.
    * </p>
+   *
    * @param name The name of the database or null for the unnamed database
-   *            (see also {@link DbiBuilder#withoutDbName()})
+   *             (see also {@link DbiBuilder#withoutDbName()})
    * @return The next builder stage.
    */
   public DbiBuilderStage2<T> setDbName(final String name) {
@@ -63,6 +64,7 @@ public DbiBuilderStage2<T> setDbName(final String name) {
 
   /**
    * Create the {@link Dbi} with the passed name in byte[] form.
+   *
    * @param name The name of the database in byte form.
    * @return The next builder stage.
    */
@@ -83,6 +85,7 @@ public DbiBuilderStage2<T> setDbName(final byte[] name) {
    * <p>Note: The 'unnamed database' is used by LMDB to store the names of named databases, with
    * the database name being the key. Use of the unnamed database is intended for simple applications
    * with only one database.</p>
+   *
    * @return The next builder stage.
    */
   public DbiBuilderStage2<T> withoutDbName() {
@@ -102,7 +105,7 @@ public static class DbiBuilderStage2<T> {
 
     private final DbiBuilder<T> dbiBuilder;
 
-    private java.util.Comparator<T> customComparator;
+    private ComparatorFactory<T> comparatorFactory;
     private ComparatorType comparatorType;
 
     private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
@@ -130,7 +133,7 @@ private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
      * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
      * you choose {@link DbiBuilderStage2#withNativeComparator()},
      * {@link DbiBuilderStage2#withDefaultComparator()} or
-     * {@link DbiBuilderStage2#withIteratorComparator(Comparator)} as these comparators will
+     * {@link DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will
      * never be used.
      * </p>
      *
@@ -157,7 +160,7 @@ public DbiBuilderStage3<T> withDefaultComparator() {
      * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
      * you choose {@link DbiBuilderStage2#withNativeComparator()},
      * {@link DbiBuilderStage2#withDefaultComparator()} or
-     * {@link DbiBuilderStage2#withIteratorComparator(Comparator)} as these comparators will
+     * {@link DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will
      * never be used.
      * </p>
      *
@@ -186,11 +189,13 @@ public DbiBuilderStage3<T> withNativeComparator() {
      * are stored in the database.
      * </p>
      *
-     * @param comparator for all key comparison operations.
+     * @param comparatorFactory A factory to create a comparator. {@link ComparatorFactory#create(DbiFlagSet)}
+     *                          will be called once during the initialisation of the {@link Dbi}. It must
+     *                          not return null.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withCallbackComparator(final Comparator<T> comparator) {
-      this.customComparator = Objects.requireNonNull(comparator);
+    public DbiBuilderStage3<T> withCallbackComparator(final ComparatorFactory<T> comparatorFactory) {
+      this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.CALLBACK;
       return new DbiBuilderStage3<>(this);
     }
@@ -215,15 +220,17 @@ public DbiBuilderStage3<T> withCallbackComparator(final Comparator<T> comparator
      * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
      * you choose {@link DbiBuilderStage2#withNativeComparator()},
      * {@link DbiBuilderStage2#withDefaultComparator()} or
-     * {@link DbiBuilderStage2#withIteratorComparator(Comparator)} as these comparators will
+     * {@link DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will
      * never be used.
      * </p>
      *
-     * @param comparator The comparator to use with {@link CursorIterable}.
+     * @param comparatorFactory The comparator to use with {@link CursorIterable}.
+     *                          {@link ComparatorFactory#create(DbiFlagSet)} will be called once during the
+     *                          initialisation of the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withIteratorComparator(final Comparator<T> comparator) {
-      this.customComparator = Objects.requireNonNull(comparator);
+    public DbiBuilderStage3<T> withIteratorComparator(final ComparatorFactory<T> comparatorFactory) {
+      this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.ITERATOR;
       return new DbiBuilderStage3<>(this);
     }
@@ -267,8 +274,8 @@ public DbiBuilderStage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
         dbiFlags.stream()
-                .filter(Objects::nonNull)
-                .forEach(dbiFlags::add);
+            .filter(Objects::nonNull)
+            .forEach(dbiFlags::add);
       }
       return this;
     }
@@ -310,7 +317,7 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
      * </p>
      *
      * @param dbiFlagSet to open the database with.
-     *                 A null value will just clear all set flags.
+     *                   A null value will just clear all set flags.
      */
     public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
       flagSetBuilder.clear();
@@ -413,7 +420,9 @@ private Comparator<T> getComparator(final DbiBuilder<T> dbiBuilder,
           break;
         case CALLBACK:
         case ITERATOR:
-          comparator = dbiBuilderStage2.customComparator;
+          comparator = Objects.requireNonNull(
+              dbiBuilderStage2.comparatorFactory.create(dbiFlagSet),
+              () -> "comparatorFactory returned null");
           break;
         case NATIVE:
           break;
@@ -465,4 +474,15 @@ private enum ComparatorType {
     ITERATOR,
     ;
   }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  @FunctionalInterface
+  public interface ComparatorFactory<T> {
+
+    Comparator<T> create(final DbiFlagSet dbiFlagSet);
+
+  }
 }
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
index 5b9e0761..32e0c8c5 100644
--- a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -30,13 +30,10 @@
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.Comparator;
-import java.util.LinkedHashMap;
-import java.util.Map;
 import java.util.Random;
 import java.util.stream.Stream;
 import org.agrona.DirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
-import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -98,13 +95,10 @@ void testInt(final ComparatorRunner comparator) {
     assertThat(get(comparator.compare(Integer.MAX_VALUE, 0))).isEqualTo(GREATER_THAN);
   }
 
-  @Test
-  void testRandomLong() {
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testRandomLong(final ComparatorRunner runner) {
     final Random random = new Random(3239480);
-    final Map<String, ComparatorRunner> nameToRunnerMap = new LinkedHashMap<>();
-    nameToRunnerMap.put("DirectBufferRunner", new DirectBufferRunner());
-    nameToRunnerMap.put("ByteBufferRunner", new ByteBufferRunner());
-    nameToRunnerMap.put("NettyRunner", new NettyRunner());
 
     // 5mil random longs to compare
     final long[] values = random.longs()
@@ -115,40 +109,33 @@ void testRandomLong() {
     for (int i = 1; i < values.length; i++) {
       final long long1 = values[i - 1];
       final long long2 = values[i];
-      for (Map.Entry<String, ComparatorRunner> entry : nameToRunnerMap.entrySet()) {
-        final String name = entry.getKey();
-        final ComparatorRunner runner = entry.getValue();
-        // Make sure the comparator under test gives the same outcome as just comparing two longs
-        final ComparatorTest.ComparatorResult result = get(runner.compare(long1, long2));
-        final ComparatorTest.ComparatorResult expectedResult = get(Long.compare(long1, long2));
-
-        assertThat(result)
-            .withFailMessage(() -> "Compare mismatch for " + name + " - long1: " + long1
-                + ", long2: " + long2
-                + ", expected: " + expectedResult
-                + ", actual: " + result)
-            .isEqualTo(expectedResult);
-
-        final ComparatorTest.ComparatorResult result2 = get(runner.compare(long2, long1));
-        final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
-
-        assertThat(result)
-            .withFailMessage(() -> "Compare mismatch for " + name + " - long2: " + long2
-                + ", long1: " + long1
-                + ", expected2: " + expectedResult2
-                + ", actual2: " + result2)
-            .isEqualTo(expectedResult);
-      }
+      // Make sure the comparator under test gives the same outcome as just comparing two longs
+      final ComparatorTest.ComparatorResult result = get(runner.compare(long1, long2));
+      final ComparatorTest.ComparatorResult expectedResult = get(Long.compare(long1, long2));
+
+      assertThat(result)
+          .withFailMessage(() -> "Compare mismatch - long1: " + long1
+              + ", long2: " + long2
+              + ", expected: " + expectedResult
+              + ", actual: " + result)
+          .isEqualTo(expectedResult);
+
+      final ComparatorTest.ComparatorResult result2 = get(runner.compare(long2, long1));
+      final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+
+      assertThat(result)
+          .withFailMessage(() -> "Compare mismatch for - long2: " + long2
+              + ", long1: " + long1
+              + ", expected2: " + expectedResult2
+              + ", actual2: " + result2)
+          .isEqualTo(expectedResult);
     }
   }
 
-  @Test
-  void testRandomInt() {
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testRandomInt(final ComparatorRunner runner) {
     final Random random = new Random(3239480);
-    final Map<String, ComparatorRunner> nameToRunnerMap = new LinkedHashMap<>();
-    nameToRunnerMap.put("DirectBufferRunner", new DirectBufferRunner());
-    nameToRunnerMap.put("ByteBufferRunner", new ByteBufferRunner());
-    nameToRunnerMap.put("NettyRunner", new NettyRunner());
 
     // 5mil random ints to compare
     final int[] values = random.ints()
@@ -159,30 +146,26 @@ void testRandomInt() {
     for (int i = 1; i < values.length; i++) {
       final int int1 = values[i - 1];
       final int int2 = values[i];
-      for (Map.Entry<String, ComparatorRunner> entry : nameToRunnerMap.entrySet()) {
-        final String name = entry.getKey();
-        final ComparatorRunner runner = entry.getValue();
-        // Make sure the comparator under test gives the same outcome as just comparing two ints
-        final ComparatorTest.ComparatorResult result = get(runner.compare(int1, int2));
-        final ComparatorTest.ComparatorResult expectedResult = get(Integer.compare(int1, int2));
-
-        assertThat(result)
-            .withFailMessage(() -> "Compare mismatch for " + name + " - int1: " + int1
-                + ", int2: " + int2
-                + ", expected: " + expectedResult
-                + ", actual: " + result)
-            .isEqualTo(expectedResult);
-
-        final ComparatorTest.ComparatorResult result2 = get(runner.compare(int2, int1));
-        final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
-
-        assertThat(result)
-            .withFailMessage(() -> "Compare mismatch for " + name + " - int2: " + int2
-                + ", int1: " + int1
-                + ", expected2: " + expectedResult2
-                + ", actual2: " + result2)
-            .isEqualTo(expectedResult);
-      }
+      // Make sure the comparator under test gives the same outcome as just comparing two ints
+      final ComparatorTest.ComparatorResult result = get(runner.compare(int1, int2));
+      final ComparatorTest.ComparatorResult expectedResult = get(Integer.compare(int1, int2));
+
+      assertThat(result)
+          .withFailMessage(() -> "Compare mismatch for - int1: " + int1
+              + ", int2: " + int2
+              + ", expected: " + expectedResult
+              + ", actual: " + result)
+          .isEqualTo(expectedResult);
+
+      final ComparatorTest.ComparatorResult result2 = get(runner.compare(int2, int1));
+      final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+
+      assertThat(result)
+          .withFailMessage(() -> "Compare mismatch for - int2: " + int2
+              + ", int1: " + int1
+              + ", expected2: " + expectedResult2
+              + ", actual2: " + result2)
+          .isEqualTo(expectedResult);
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 393065a3..775ac4bc 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -557,13 +557,13 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
           env.buildDbi()
               .setDbName(DB_3)
-              .withCallbackComparator(buildComparator())
+              .withCallbackComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
           env.buildDbi()
               .setDbName(DB_4)
-              .withIteratorComparator(buildComparator())
+              .withIteratorComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       return Stream.of(
@@ -574,7 +574,7 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
           .map(Arguments::of);
     }
 
-    private static Comparator<ByteBuffer> buildComparator() {
+    private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSet) {
       final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
       return (o1, o2) -> {
         if (o1.remaining() != o2.remaining()) {
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index aa23235a..a0d9ab0c 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -611,18 +611,16 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
               .withNativeComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
-      final Comparator<ByteBuffer> comparator = buildComparator();
-
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
           env.buildDbi()
               .setDbName(DB_3)
-              .withCallbackComparator(comparator)
+              .withCallbackComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
           env.buildDbi()
               .setDbName(DB_4)
-              .withIteratorComparator(comparator)
+              .withIteratorComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       return Stream.of(
@@ -633,7 +631,7 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
           .map(Arguments::of);
     }
 
-    private static Comparator<ByteBuffer> buildComparator() {
+    private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSet) {
       final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
       return (o1, o2) -> {
         if (o1.remaining() != o2.remaining()) {
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 008695fd..e0a40fd9 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -79,7 +79,7 @@ public void before() throws IOException {
     // Use a java comparator for start/stop keys and as a callback comparator
     dbCallbackComparator = env.buildDbi()
         .setDbName("CallBackComparator")
-        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
+        .withCallbackComparator(bufferProxy::getComparator)
         .setDbiFlags(dbiFlagSet)
         .open();
 
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 0286fa88..e48f1e69 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -83,7 +83,6 @@ public final class CursorIterableTest {
   private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
 
   private Path file;
-  private Dbi<ByteBuffer> db;
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
@@ -309,7 +308,11 @@ void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    final Dbi<ByteBuffer> guavaDbi = env.buildDbi()
+        .setDbName(DB_1)
+        .withDefaultComparator()
+        .setDbiFlags(MDB_CREATE)
+        .open();
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bb(7), bb(2)), guavaDbi, 6, 4, 2);
     verify(openClosedBackward(bb(8), bb(4)), guavaDbi, 6, 4);
@@ -548,13 +551,13 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
           env.buildDbi()
               .setDbName(DB_3)
-              .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+              .withCallbackComparator(BUFFER_PROXY::getComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
           env.buildDbi()
               .setDbName(DB_4)
-              .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+              .withIteratorComparator(BUFFER_PROXY::getComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       return Stream.of(
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index 25e622bf..d01f6417 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -133,7 +133,7 @@ public void callback() {
 
     final Dbi<ByteBuffer> dbi = env.buildDbi()
         .setDbName("foo")
-        .withCallbackComparator(comparator)
+        .withCallbackComparator(ignored -> comparator)
         .addDbiFlags(DbiFlags.MDB_CREATE)
         .open();
 

From 69eb5b742dcaad89275c9896bc05366a62374101 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 17:01:14 +0000
Subject: [PATCH 27/90] #269 Initial iterator performance enhancements and
 testing.

---
 .../org/lmdbjava/CursorIterableRangeTest.java |  40 +++----
 .../CursorIterableRangeTest/testLongKey.csv   | 108 +++++++++---------
 2 files changed, 74 insertions(+), 74 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 0802c047..f0471bab 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -123,7 +123,7 @@ void testIntegerKey(
         stopKey,
         expectedKV,
         Integer.BYTES,
-        ByteOrder.LITTLE_ENDIAN);
+        ByteOrder.nativeOrder());
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
@@ -140,7 +140,7 @@ void testLongKey(
         stopKey,
         expectedKV,
         Long.BYTES,
-        ByteOrder.LITTLE_ENDIAN);
+        ByteOrder.nativeOrder());
   }
 
   private void testCSV(
@@ -197,7 +197,7 @@ private void testCSV(
               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
             for (final KeyVal<ByteBuffer> kv : c) {
               final long key = getLong(kv.key(), byteOrder);
-              final long val = getLong(kv.val(), byteOrder);
+              final long val = getLong(kv.val(), ByteOrder.BIG_ENDIAN);
               writer.append("[");
               writer.append(String.valueOf(key));
               writer.append(" ");
@@ -215,11 +215,11 @@ private void testCSV(
 
   private ByteBuffer parseKey(final String key, final int keyLen, final ByteOrder byteOrder) {
     if (key != null) {
-      if (ByteOrder.LITTLE_ENDIAN.equals(byteOrder)) {
+      if (ByteOrder.nativeOrder().equals(byteOrder)) {
         if (keyLen == Integer.BYTES) {
-          return bbLeInt(Integer.parseInt(key.trim()));
+          return bbNativeInt(Integer.parseInt(key.trim()));
         } else {
-          return bbLeLong(Long.parseLong(key.trim()));
+          return bbNativeLong(Long.parseLong(key.trim()));
         }
       } else {
         if (keyLen == Integer.BYTES) {
@@ -277,11 +277,11 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createIntegerDBPopulator()
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-        c.put(bbLeInt(Integer.MIN_VALUE), bb(1));
-        c.put(bbLeInt(-1000), bb(2));
-        c.put(bbLeInt(0), bb(3));
-        c.put(bbLeInt(1000), bb(4));
-        c.put(bbLeInt(Integer.MAX_VALUE), bb(5));
+        c.put(bbNativeInt(0), bb(1));
+        c.put(bbNativeInt(1000), bb(2));
+        c.put(bbNativeInt(1000000), bb(3));
+        c.put(bbNativeInt(-1000000), bb(4));
+        c.put(bbNativeInt(-1000), bb(5));
         txn.commit();
       }
     };
@@ -291,11 +291,11 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createLongDBPopulator() {
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-        c.put(bbLeLong(Long.MIN_VALUE), bb(1));
-        c.put(bbLeLong(-1000), bb(2));
-        c.put(bbLeLong(0), bb(3));
-        c.put(bbLeLong(1000), bb(4));
-        c.put(bbLeLong(Long.MAX_VALUE), bb(5));
+        c.put(bbNativeLong(0), bb(1));
+        c.put(bbNativeLong(1000), bb(2));
+        c.put(bbNativeLong(1000000), bb(3));
+        c.put(bbNativeLong(-1000000), bb(4));
+        c.put(bbNativeLong(-1000), bb(5));
         txn.commit();
       }
     };
@@ -329,14 +329,14 @@ private String readFile(final File file) throws IOException {
     return result.toString();
   }
 
-  static ByteBuffer bbLeInt(final int value) {
-    final ByteBuffer bb = allocateDirect(Integer.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+  static ByteBuffer bbNativeInt(final int value) {
+    final ByteBuffer bb = allocateDirect(Integer.BYTES).order(ByteOrder.nativeOrder());
     bb.putInt(value).flip();
     return bb;
   }
 
-  static ByteBuffer bbLeLong(final long value) {
-    final ByteBuffer bb = allocateDirect(Long.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+  static ByteBuffer bbNativeLong(final long value) {
+    final ByteBuffer bb = allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
     bb.putLong(value).flip();
     return bb;
   }
diff --git a/src/test/resources/CursorIterableRangeTest/testLongKey.csv b/src/test/resources/CursorIterableRangeTest/testLongKey.csv
index f3504662..d8d6dc35 100644
--- a/src/test/resources/CursorIterableRangeTest/testLongKey.csv
+++ b/src/test/resources/CursorIterableRangeTest/testLongKey.csv
@@ -1,55 +1,55 @@
-FORWARD_ALL,,,[0 50331648][1000 67108864][9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_AT_LEAST,999,,[1000 67108864][9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_AT_LEAST,1000,,[1000 67108864][9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_AT_LEAST,1001,,[9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_AT_MOST,,999,[0 50331648]
-FORWARD_AT_MOST,,1000,[0 50331648][1000 67108864]
-FORWARD_AT_MOST,,1001,[0 50331648][1000 67108864]
-FORWARD_CLOSED,999,1001,[1000 67108864]
-FORWARD_CLOSED,1000,1000,[1000 67108864]
-FORWARD_CLOSED_OPEN,999,1001,[1000 67108864]
+FORWARD_ALL,,,[0 1][1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_LEAST,999,,[1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_LEAST,1000,,[1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_LEAST,1001,,[1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_MOST,,999,[0 1]
+FORWARD_AT_MOST,,1000,[0 1][1000 2]
+FORWARD_AT_MOST,,1001,[0 1][1000 2]
+FORWARD_CLOSED,999,1001,[1000 2]
+FORWARD_CLOSED,1000,1000,[1000 2]
+FORWARD_CLOSED_OPEN,999,1001,[1000 2]
 FORWARD_CLOSED_OPEN,1000,1000,
-FORWARD_CLOSED_OPEN,1000,1001,[1000 67108864]
-FORWARD_GREATER_THAN,999,,[1000 67108864][9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_GREATER_THAN,1000,,[9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_GREATER_THAN,1001,,[9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_LESS_THAN,,999,[0 50331648]
-FORWARD_LESS_THAN,,1000,[0 50331648]
-FORWARD_LESS_THAN,,1001,[0 50331648][1000 67108864]
-
-
-#FORWARD_OPEN,3,7,[4 5][6 7]
-#FORWARD_OPEN,2,8,[4 5][6 7]
-#FORWARD_OPEN_CLOSED,3,8,[4 5][6 7][8 9]
-#FORWARD_OPEN_CLOSED,2,6,[4 5][6 7]
-#BACKWARD_ALL,,,[-2 -1][8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,5,,[4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,6,,[6 7][4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,9,,[8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,-1,,[-2 -1][8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_AT_MOST,,5,[-2 -1][8 9][6 7]
-#BACKWARD_AT_MOST,,6,[-2 -1][8 9][6 7]
-#BACKWARD_AT_MOST,,-1,
-#BACKWARD_CLOSED,7,3,[6 7][4 5]
-#BACKWARD_CLOSED,6,2,[6 7][4 5][2 3]
-#BACKWARD_CLOSED,9,3,[8 9][6 7][4 5]
-#BACKWARD_CLOSED,9,-1,
-#BACKWARD_CLOSED_OPEN,8,3,[8 9][6 7][4 5]
-#BACKWARD_CLOSED_OPEN,7,2,[6 7][4 5]
-#BACKWARD_CLOSED_OPEN,9,3,[8 9][6 7][4 5]
-#BACKWARD_CLOSED_OPEN,9,-1,
-#BACKWARD_GREATER_THAN,6,,[4 5][2 3][0 1]
-#BACKWARD_GREATER_THAN,7,,[6 7][4 5][2 3][0 1]
-#BACKWARD_GREATER_THAN,9,,[8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_GREATER_THAN,-1,,[-2 -1][8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_LESS_THAN,,5,[-2 -1][8 9][6 7]
-#BACKWARD_LESS_THAN,,2,[-2 -1][8 9][6 7][4 5]
-#BACKWARD_LESS_THAN,,-1,
-#BACKWARD_OPEN,7,2,[6 7][4 5]
-#BACKWARD_OPEN,8,1,[6 7][4 5][2 3]
-#BACKWARD_OPEN,9,4,[8 9][6 7]
-#BACKWARD_OPEN,9,-1,
-#BACKWARD_OPEN_CLOSED,7,2,[6 7][4 5][2 3]
-#BACKWARD_OPEN_CLOSED,8,4,[6 7][4 5]
-#BACKWARD_OPEN_CLOSED,9,4,[8 9][6 7][4 5]
-#BACKWARD_OPEN_CLOSED,9,-1,
+FORWARD_CLOSED_OPEN,1000,1001,[1000 2]
+FORWARD_GREATER_THAN,999,,[1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_GREATER_THAN,1000,,[1000000 3][-1000000 4][-1000 5]
+FORWARD_GREATER_THAN,1001,,[1000000 3][-1000000 4][-1000 5]
+FORWARD_LESS_THAN,,999,[0 1]
+FORWARD_LESS_THAN,,1000,[0 1]
+FORWARD_LESS_THAN,,1001,[0 1][1000 2]
+FORWARD_OPEN,999,1001,[1000 2]
+FORWARD_OPEN,999,1000,
+FORWARD_OPEN,1000,1000,
+FORWARD_OPEN,1000,1001,
+FORWARD_OPEN_CLOSED,999,1001,[1000 2]
+FORWARD_OPEN_CLOSED,999,1000,[1000 2]
+FORWARD_OPEN_CLOSED,1000,1000,
+FORWARD_OPEN_CLOSED,1000,1001,
+BACKWARD_ALL,,,[-1000 5][-1000000 4][1000000 3][1000 2][0 1]
+BACKWARD_AT_LEAST,999,,[0 1]
+BACKWARD_AT_LEAST,1000,,[1000 2][0 1]
+BACKWARD_AT_LEAST,1001,,[1000 2][0 1]
+BACKWARD_AT_MOST,,999,[-1000 5][-1000000 4][1000000 3][1000 2]
+BACKWARD_AT_MOST,,1000,[-1000 5][-1000000 4][1000000 3][1000 2]
+BACKWARD_AT_MOST,,1001,[-1000 5][-1000000 4][1000000 3]
+BACKWARD_CLOSED,1001,999,[1000 2]
+BACKWARD_CLOSED,1000,1000,[1000 2]
+BACKWARD_CLOSED_OPEN,1001,999,[1000 2]
+BACKWARD_CLOSED_OPEN,1000,999,[1000 2]
+BACKWARD_CLOSED_OPEN,1000,1000,
+BACKWARD_CLOSED_OPEN,1001,1000,
+BACKWARD_GREATER_THAN,999,,[0 1]
+BACKWARD_GREATER_THAN,1000,,[0 1]
+BACKWARD_GREATER_THAN,1001,,[1000 2][0 1]
+BACKWARD_LESS_THAN,,999,[-1000 5][-1000000 4][1000000 3][1000 2]
+BACKWARD_LESS_THAN,,1000,[-1000 5][-1000000 4][1000000 3]
+BACKWARD_LESS_THAN,,1001,[-1000 5][-1000000 4][1000000 3]
+BACKWARD_OPEN,999,1001,[1000 2]
+BACKWARD_OPEN,999,1000,
+BACKWARD_OPEN,999,1001,[1000 2]
+BACKWARD_OPEN,1000,1000,
+BACKWARD_OPEN,1000,1001,
+BACKWARD_OPEN_CLOSED,999,1001,[1000 2]
+BACKWARD_OPEN_CLOSED,999,1000,[1000 2]
+BACKWARD_OPEN_CLOSED,1000,1000,
+BACKWARD_OPEN_CLOSED,1000,1001,
+BACKWARD_OPEN_CLOSED,1000,1001,

From 915edce19bdb9e30d719fdd9af0906df25723ec4 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 17:01:55 +0000
Subject: [PATCH 28/90] #269 Initial iterator performance enhancements and
 testing.

---
 .../testIntegerKey.csv                        | 104 +++++++++---------
 1 file changed, 55 insertions(+), 49 deletions(-)

diff --git a/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv b/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv
index ceda992a..d8d6dc35 100644
--- a/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv
+++ b/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv
@@ -1,49 +1,55 @@
-FORWARD_ALL,,,[0 50331648][1000 67108864][2147483647 83886080][-2147483648 16777216][-1000 33554432]
-#FORWARD_AT_LEAST,5,,[1000 67108864][2147483647 83886080][-2147483648 16777216][-1000 33554432]
-#FORWARD_AT_LEAST,6,,[1000 67108864][2147483647 83886080][-2147483648 16777216][-1000 33554432]
-#FORWARD_AT_MOST,,5,[0 50331648]
-#FORWARD_AT_MOST,,2147483647,[0 50331648]
-#FORWARD_CLOSED,3,7,
-#FORWARD_CLOSED,2,6,
-#FORWARD_CLOSED,1,7,
-#FORWARD_CLOSED_OPEN,3,8,[4 5][6 7]
-#FORWARD_CLOSED_OPEN,2,6,[2 3][4 5]
-#FORWARD_GREATER_THAN,4,,[6 7][8 9][-2 -1]
-#FORWARD_GREATER_THAN,3,,[4 5][6 7][8 9][-2 -1]
-#FORWARD_LESS_THAN,,5,[0 1][2 3][4 5]
-#FORWARD_LESS_THAN,,8,[0 1][2 3][4 5][6 7]
-#FORWARD_OPEN,3,7,[4 5][6 7]
-#FORWARD_OPEN,2,8,[4 5][6 7]
-#FORWARD_OPEN_CLOSED,3,8,[4 5][6 7][8 9]
-#FORWARD_OPEN_CLOSED,2,6,[4 5][6 7]
-#BACKWARD_ALL,,,[-2 -1][8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,5,,[4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,6,,[6 7][4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,9,,[8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,-1,,[-2 -1][8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_AT_MOST,,5,[-2 -1][8 9][6 7]
-#BACKWARD_AT_MOST,,6,[-2 -1][8 9][6 7]
-#BACKWARD_AT_MOST,,-1,
-#BACKWARD_CLOSED,7,3,[6 7][4 5]
-#BACKWARD_CLOSED,6,2,[6 7][4 5][2 3]
-#BACKWARD_CLOSED,9,3,[8 9][6 7][4 5]
-#BACKWARD_CLOSED,9,-1,
-#BACKWARD_CLOSED_OPEN,8,3,[8 9][6 7][4 5]
-#BACKWARD_CLOSED_OPEN,7,2,[6 7][4 5]
-#BACKWARD_CLOSED_OPEN,9,3,[8 9][6 7][4 5]
-#BACKWARD_CLOSED_OPEN,9,-1,
-#BACKWARD_GREATER_THAN,6,,[4 5][2 3][0 1]
-#BACKWARD_GREATER_THAN,7,,[6 7][4 5][2 3][0 1]
-#BACKWARD_GREATER_THAN,9,,[8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_GREATER_THAN,-1,,[-2 -1][8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_LESS_THAN,,5,[-2 -1][8 9][6 7]
-#BACKWARD_LESS_THAN,,2,[-2 -1][8 9][6 7][4 5]
-#BACKWARD_LESS_THAN,,-1,
-#BACKWARD_OPEN,7,2,[6 7][4 5]
-#BACKWARD_OPEN,8,1,[6 7][4 5][2 3]
-#BACKWARD_OPEN,9,4,[8 9][6 7]
-#BACKWARD_OPEN,9,-1,
-#BACKWARD_OPEN_CLOSED,7,2,[6 7][4 5][2 3]
-#BACKWARD_OPEN_CLOSED,8,4,[6 7][4 5]
-#BACKWARD_OPEN_CLOSED,9,4,[8 9][6 7][4 5]
-#BACKWARD_OPEN_CLOSED,9,-1,
+FORWARD_ALL,,,[0 1][1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_LEAST,999,,[1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_LEAST,1000,,[1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_LEAST,1001,,[1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_MOST,,999,[0 1]
+FORWARD_AT_MOST,,1000,[0 1][1000 2]
+FORWARD_AT_MOST,,1001,[0 1][1000 2]
+FORWARD_CLOSED,999,1001,[1000 2]
+FORWARD_CLOSED,1000,1000,[1000 2]
+FORWARD_CLOSED_OPEN,999,1001,[1000 2]
+FORWARD_CLOSED_OPEN,1000,1000,
+FORWARD_CLOSED_OPEN,1000,1001,[1000 2]
+FORWARD_GREATER_THAN,999,,[1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_GREATER_THAN,1000,,[1000000 3][-1000000 4][-1000 5]
+FORWARD_GREATER_THAN,1001,,[1000000 3][-1000000 4][-1000 5]
+FORWARD_LESS_THAN,,999,[0 1]
+FORWARD_LESS_THAN,,1000,[0 1]
+FORWARD_LESS_THAN,,1001,[0 1][1000 2]
+FORWARD_OPEN,999,1001,[1000 2]
+FORWARD_OPEN,999,1000,
+FORWARD_OPEN,1000,1000,
+FORWARD_OPEN,1000,1001,
+FORWARD_OPEN_CLOSED,999,1001,[1000 2]
+FORWARD_OPEN_CLOSED,999,1000,[1000 2]
+FORWARD_OPEN_CLOSED,1000,1000,
+FORWARD_OPEN_CLOSED,1000,1001,
+BACKWARD_ALL,,,[-1000 5][-1000000 4][1000000 3][1000 2][0 1]
+BACKWARD_AT_LEAST,999,,[0 1]
+BACKWARD_AT_LEAST,1000,,[1000 2][0 1]
+BACKWARD_AT_LEAST,1001,,[1000 2][0 1]
+BACKWARD_AT_MOST,,999,[-1000 5][-1000000 4][1000000 3][1000 2]
+BACKWARD_AT_MOST,,1000,[-1000 5][-1000000 4][1000000 3][1000 2]
+BACKWARD_AT_MOST,,1001,[-1000 5][-1000000 4][1000000 3]
+BACKWARD_CLOSED,1001,999,[1000 2]
+BACKWARD_CLOSED,1000,1000,[1000 2]
+BACKWARD_CLOSED_OPEN,1001,999,[1000 2]
+BACKWARD_CLOSED_OPEN,1000,999,[1000 2]
+BACKWARD_CLOSED_OPEN,1000,1000,
+BACKWARD_CLOSED_OPEN,1001,1000,
+BACKWARD_GREATER_THAN,999,,[0 1]
+BACKWARD_GREATER_THAN,1000,,[0 1]
+BACKWARD_GREATER_THAN,1001,,[1000 2][0 1]
+BACKWARD_LESS_THAN,,999,[-1000 5][-1000000 4][1000000 3][1000 2]
+BACKWARD_LESS_THAN,,1000,[-1000 5][-1000000 4][1000000 3]
+BACKWARD_LESS_THAN,,1001,[-1000 5][-1000000 4][1000000 3]
+BACKWARD_OPEN,999,1001,[1000 2]
+BACKWARD_OPEN,999,1000,
+BACKWARD_OPEN,999,1001,[1000 2]
+BACKWARD_OPEN,1000,1000,
+BACKWARD_OPEN,1000,1001,
+BACKWARD_OPEN_CLOSED,999,1001,[1000 2]
+BACKWARD_OPEN_CLOSED,999,1000,[1000 2]
+BACKWARD_OPEN_CLOSED,1000,1000,
+BACKWARD_OPEN_CLOSED,1000,1001,
+BACKWARD_OPEN_CLOSED,1000,1001,

From 5a62965505ee651bd5a89dbae8c1173a522dd521 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 18:24:10 +0000
Subject: [PATCH 29/90] Merged new comparator code

---
 .../java/org/lmdbjava/AbstractFlagSet.java    | 359 ++++++++++
 src/main/java/org/lmdbjava/BufferProxy.java   |  37 +-
 .../java/org/lmdbjava/ByteArrayProxy.java     |  34 +-
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  86 ++-
 .../java/org/lmdbjava/ByteBufferProxy.java    |  83 ++-
 src/main/java/org/lmdbjava/CopyFlagSet.java   |  63 ++
 src/main/java/org/lmdbjava/CopyFlags.java     |  33 +-
 src/main/java/org/lmdbjava/Cursor.java        | 167 ++++-
 .../java/org/lmdbjava/CursorIterable.java     | 131 +++-
 src/main/java/org/lmdbjava/Dbi.java           | 133 +++-
 src/main/java/org/lmdbjava/DbiBuilder.java    | 426 +++++++++++
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  67 ++
 src/main/java/org/lmdbjava/DbiFlags.java      |  66 +-
 .../java/org/lmdbjava/DirectBufferProxy.java  |  67 +-
 src/main/java/org/lmdbjava/Env.java           | 344 +++++++--
 src/main/java/org/lmdbjava/EnvFlagSet.java    |  63 ++
 src/main/java/org/lmdbjava/EnvFlags.java      |  30 +-
 src/main/java/org/lmdbjava/FlagSet.java       | 122 ++++
 src/main/java/org/lmdbjava/Key.java           |  72 ++
 src/main/java/org/lmdbjava/KeyRangeType.java  |  50 +-
 src/main/java/org/lmdbjava/Library.java       |   2 +
 src/main/java/org/lmdbjava/MaskedFlag.java    |  86 +--
 src/main/java/org/lmdbjava/PutFlagSet.java    |  63 ++
 src/main/java/org/lmdbjava/PutFlags.java      |  30 +-
 .../java/org/lmdbjava/RangeComparator.java    |  32 +
 src/main/java/org/lmdbjava/Txn.java           |  13 +-
 src/main/java/org/lmdbjava/TxnFlagSet.java    |  68 ++
 src/main/java/org/lmdbjava/TxnFlags.java      |  31 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     | 117 +++-
 .../lmdbjava/ComparatorIntegerKeyTest.java    | 357 ++++++++++
 .../java/org/lmdbjava/ComparatorTest.java     |  12 +-
 .../java/org/lmdbjava/CopyFlagSetTest.java    |  72 ++
 .../CursorIterableIntegerDupTest.java         | 615 ++++++++++++++++
 .../CursorIterableIntegerKeyTest.java         | 662 ++++++++++++++++++
 .../org/lmdbjava/CursorIterablePerfTest.java  | 201 ++++++
 .../org/lmdbjava/CursorIterableRangeTest.java |   8 +-
 .../java/org/lmdbjava/CursorIterableTest.java | 197 +++++-
 .../java/org/lmdbjava/DbiBuilderTest.java     | 204 ++++++
 .../java/org/lmdbjava/DbiFlagSetTest.java     |  90 +++
 src/test/java/org/lmdbjava/DbiTest.java       |  13 +-
 .../java/org/lmdbjava/EnvFlagSetTest.java     |  91 +++
 src/test/java/org/lmdbjava/KeyRangeTest.java  |   5 +-
 .../java/org/lmdbjava/PutFlagSetTest.java     | 131 ++++
 src/test/java/org/lmdbjava/TestUtils.java     |  87 +++
 .../java/org/lmdbjava/TxnFlagSetTest.java     |  85 +++
 45 files changed, 5335 insertions(+), 370 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/AbstractFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/CopyFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/DbiBuilder.java
 create mode 100644 src/main/java/org/lmdbjava/DbiFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/EnvFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/FlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/Key.java
 create mode 100644 src/main/java/org/lmdbjava/PutFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/RangeComparator.java
 create mode 100644 src/main/java/org/lmdbjava/TxnFlagSet.java
 create mode 100644 src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
 create mode 100644 src/test/java/org/lmdbjava/CopyFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
 create mode 100644 src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
 create mode 100644 src/test/java/org/lmdbjava/CursorIterablePerfTest.java
 create mode 100644 src/test/java/org/lmdbjava/DbiBuilderTest.java
 create mode 100644 src/test/java/org/lmdbjava/DbiFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/EnvFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/PutFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/TxnFlagSetTest.java

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
new file mode 100644
index 00000000..65f84f55
--- /dev/null
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -0,0 +1,359 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/** Encapsulates an immutable set of flags and the associated bit mask for the flags in the set. */
+public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
+
+  private final Set<T> flags;
+  private final int mask;
+
+  protected AbstractFlagSet(final EnumSet<T> flags) {
+    Objects.requireNonNull(flags);
+    this.mask = MaskedFlag.mask(flags);
+    this.flags = Collections.unmodifiableSet(Objects.requireNonNull(flags));
+  }
+
+  /**
+   * @return THe combined bit mask for all flags in the set.
+   */
+  @Override
+  public int getMask() {
+    return mask;
+  }
+
+  /**
+   * @return All flags in the set.
+   */
+  @Override
+  public Set<T> getFlags() {
+    return flags;
+  }
+
+  /**
+   * @return True if flag has been set, i.e. is contained in this set.
+   */
+  @Override
+  public boolean isSet(final T flag) {
+    // Probably cheaper to compare the masks than to use EnumSet.contains()
+    return flag != null && MaskedFlag.isSet(mask, flag);
+  }
+
+  /**
+   * @return The number of flags in this set.
+   */
+  @Override
+  public int size() {
+    return flags.size();
+  }
+
+  /**
+   * @return True if this set is empty.
+   */
+  @Override
+  public boolean isEmpty() {
+    return flags.isEmpty();
+  }
+
+  /**
+   * @return The {@link Iterator} for this set.
+   */
+  @Override
+  public Iterator<T> iterator() {
+    return flags.iterator();
+  }
+
+  @Override
+  public boolean equals(Object object) {
+    return FlagSet.equals(this, object);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(flags, mask);
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  abstract static class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag>
+      implements FlagSet<T> {
+
+    private final T flag;
+    // Only holding this for iterator() and getFlags() so make it lazy.
+    private EnumSet<T> enumSet;
+
+    public AbstractSingleFlagSet(final T flag) {
+      this.flag = Objects.requireNonNull(flag);
+    }
+
+    @Override
+    public int getMask() {
+      return flag.getMask();
+    }
+
+    @Override
+    public Set<T> getFlags() {
+      if (enumSet == null) {
+        return initSet();
+      } else {
+        return this.enumSet;
+      }
+    }
+
+    @Override
+    public boolean isSet(final T flag) {
+      return this.flag == flag;
+    }
+
+    @Override
+    public boolean areAnySet(FlagSet<T> flags) {
+      if (flags == null) {
+        return false;
+      } else {
+        return flags.isSet(this.flag);
+      }
+    }
+
+    @Override
+    public int size() {
+      return 1;
+    }
+
+    @Override
+    public boolean isEmpty() {
+      return false;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+      if (enumSet == null) {
+        return initSet().iterator();
+      } else {
+        return this.enumSet.iterator();
+      }
+    }
+
+    @Override
+    public String toString() {
+      return FlagSet.asString(this);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+      return FlagSet.equals(this, object);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(flag, getFlags());
+    }
+
+    private Set<T> initSet() {
+      final EnumSet<T> set = EnumSet.of(this.flag);
+      this.enumSet = set;
+      return set;
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  static class AbstractEmptyFlagSet<T extends MaskedFlag> implements FlagSet<T> {
+
+    @Override
+    public int getMask() {
+      return MaskedFlag.EMPTY_MASK;
+    }
+
+    @Override
+    public Set<T> getFlags() {
+      return Collections.emptySet();
+    }
+
+    @Override
+    public boolean isSet(final T flag) {
+      return false;
+    }
+
+    @Override
+    public boolean areAnySet(final FlagSet<T> flags) {
+      return false;
+    }
+
+    @Override
+    public int size() {
+      return 0;
+    }
+
+    @Override
+    public boolean isEmpty() {
+      return true;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+      return Collections.emptyIterator();
+    }
+
+    @Override
+    public String toString() {
+      return FlagSet.asString(this);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+      return FlagSet.equals(this, object);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(getMask(), getFlags());
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /**
+   * A builder for creating a {@link AbstractFlagSet}.
+   *
+   * @param <E> The type of flag to be held in the {@link AbstractFlagSet}
+   * @param <S> The type of the {@link AbstractFlagSet} implementation.
+   */
+  public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>> {
+
+    final Class<E> type;
+    final EnumSet<E> enumSet;
+    final Function<EnumSet<E>, S> constructor;
+    final Function<E, S> singletonSetConstructor;
+    final Supplier<S> emptySetSupplier;
+
+    protected Builder(
+        final Class<E> type,
+        final Function<EnumSet<E>, S> constructor,
+        final Function<E, S> singletonSetConstructor,
+        final Supplier<S> emptySetSupplier) {
+      this.type = type;
+      this.enumSet = EnumSet.noneOf(type);
+      this.constructor = Objects.requireNonNull(constructor);
+      this.singletonSetConstructor = Objects.requireNonNull(singletonSetConstructor);
+      this.emptySetSupplier = Objects.requireNonNull(emptySetSupplier);
+    }
+
+    /**
+     * Replaces any flags already set in the builder with the contents of the passed flags {@link
+     * Collection}
+     *
+     * @param flags The flags to set in the builder.
+     * @return this builder instance.
+     */
+    public Builder<E, S> withFlags(final Collection<E> flags) {
+      clear();
+      if (flags != null) {
+        for (E flag : flags) {
+          if (flag != null) {
+            enumSet.add(flag);
+          }
+        }
+      }
+      return this;
+    }
+
+    /**
+     * @param flags The flags to set in the builder.
+     * @return this builder instance.
+     */
+    @SafeVarargs
+    public final Builder<E, S> withFlags(final E... flags) {
+      clear();
+      if (flags != null) {
+        for (E flag : flags) {
+          if (flag != null) {
+            if (!type.equals(flag.getClass())) {
+              throw new IllegalArgumentException("Unexpected type " + flag.getClass());
+            }
+            enumSet.add(flag);
+          }
+        }
+      }
+      return this;
+    }
+
+    /**
+     * Sets a single flag in the builder.
+     *
+     * @param flag The flag to set in the builder.
+     * @return this builder instance.
+     */
+    public Builder<E, S> setFlag(final E flag) {
+      if (flag != null) {
+        enumSet.add(flag);
+      }
+      return this;
+    }
+
+    /**
+     * Sets multiple flag in the builder.
+     *
+     * @param flags The flags to set in the builder.
+     * @return this builder instance.
+     */
+    public Builder<E, S> setFlags(final Collection<E> flags) {
+      if (flags != null) {
+        enumSet.addAll(flags);
+      }
+      return this;
+    }
+
+    /**
+     * Clears any flags already set in this {@link Builder}
+     *
+     * @return this builder instance.
+     */
+    public Builder<E, S> clear() {
+      enumSet.clear();
+      return this;
+    }
+
+    /**
+     * Build the {@link DbiFlagSet}
+     *
+     * @return A
+     */
+    public S build() {
+      final int size = enumSet.size();
+      if (size == 0) {
+        return emptySetSupplier.get();
+      } else if (size == 1) {
+        return singletonSetConstructor.apply(enumSet.stream().findFirst().get());
+      } else {
+        return constructor.apply(enumSet);
+      }
+    }
+  }
+}
diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index d4503731..a3c339bf 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -16,10 +16,6 @@
 package org.lmdbjava;
 
 import static java.lang.Long.BYTES;
-import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
-import static org.lmdbjava.DbiFlags.MDB_UNSIGNEDKEY;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -75,30 +71,22 @@ protected BufferProxy() {}
    * <p>The provided comparator must strictly match the lexicographical order of keys in the native
    * LMDB database.
    *
-   * @param flags for the database
+   * @param dbiFlagSet The {@link DbiFlags} set for the database.
    * @return a comparator that can be used (never null)
    */
-  protected Comparator<T> getComparator(DbiFlags... flags) {
-    final int intFlag = mask(flags);
-
-    return isSet(intFlag, MDB_INTEGERKEY) || isSet(intFlag, MDB_UNSIGNEDKEY)
-        ? getUnsignedComparator()
-        : getSignedComparator();
-  }
+  public abstract Comparator<T> getComparator(final DbiFlagSet dbiFlagSet);
 
   /**
-   * Get a suitable default {@link Comparator} to compare numeric key values as signed.
+   * Get a suitable default {@link Comparator}
    *
-   * @return a comparator that can be used (never null)
-   */
-  protected abstract Comparator<T> getSignedComparator();
-
-  /**
-   * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
+   * <p>The provided comparator must strictly match the lexicographical order of keys in the native
+   * LMDB database.
    *
    * @return a comparator that can be used (never null)
    */
-  protected abstract Comparator<T> getUnsignedComparator();
+  public Comparator<T> getComparator() {
+    return getComparator(DbiFlagSet.empty());
+  }
 
   /**
    * Called when the <code>MDB_val</code> should be set to reflect the passed buffer. This buffer
@@ -138,4 +126,13 @@ protected Comparator<T> getComparator(DbiFlags... flags) {
   final KeyVal<T> keyVal() {
     return new KeyVal<>(this);
   }
+
+  /**
+   * Create a new {@link Key} to hold pointers for this buffer proxy.
+   *
+   * @return a non-null key holder
+   */
+  final Key<T> key() {
+    return new Key<>(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 853521e0..82b7721c 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -36,9 +36,6 @@ public final class ByteArrayProxy extends BufferProxy<byte[]> {
 
   private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  private static final Comparator<byte[]> signedComparator = ByteArrayProxy::compareArraysSigned;
-  private static final Comparator<byte[]> unsignedComparator = ByteArrayProxy::compareArrays;
-
   private ByteArrayProxy() {}
 
   /**
@@ -48,7 +45,7 @@ private ByteArrayProxy() {}
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
-  public static int compareArrays(final byte[] o1, final byte[] o2) {
+  public static int compareLexicographically(final byte[] o1, final byte[] o2) {
     requireNonNull(o1);
     requireNonNull(o2);
     if (o1 == o2) {
@@ -68,26 +65,6 @@ public static int compareArrays(final byte[] o1, final byte[] o2) {
     return o1.length - o2.length;
   }
 
-  /**
-   * Compare two byte arrays.
-   *
-   * @param b1 left operand (required)
-   * @param b2 right operand (required)
-   * @return as specified by {@link Comparable} interface
-   */
-  public static int compareArraysSigned(final byte[] b1, final byte[] b2) {
-    requireNonNull(b1);
-    requireNonNull(b2);
-
-    if (b1 == b2) return 0;
-
-    for (int i = 0; i < min(b1.length, b2.length); ++i) {
-      if (b1[i] != b2[i]) return b1[i] - b2[i];
-    }
-
-    return b1.length - b2.length;
-  }
-
   @Override
   protected byte[] allocate() {
     return new byte[0];
@@ -104,13 +81,8 @@ protected byte[] getBytes(final byte[] buffer) {
   }
 
   @Override
-  protected Comparator<byte[]> getSignedComparator() {
-    return signedComparator;
-  }
-
-  @Override
-  protected Comparator<byte[]> getUnsignedComparator() {
-    return unsignedComparator;
+  public Comparator<byte[]> getComparator(final DbiFlagSet dbiFlagSet) {
+    return ByteArrayProxy::compareLexicographically;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 2866e874..bcbb6ebf 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -23,6 +23,7 @@
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.PooledByteBufAllocator;
 import java.lang.reflect.Field;
+import java.nio.ByteOrder;
 import java.util.Comparator;
 import jnr.ffi.Pointer;
 
@@ -44,13 +45,6 @@ public final class ByteBufProxy extends BufferProxy<ByteBuf> {
   private static final String FIELD_NAME_ADDRESS = "memoryAddress";
   private static final String FIELD_NAME_LENGTH = "length";
   private static final String NAME = "io.netty.buffer.PooledUnsafeDirectByteBuf";
-  private static final Comparator<ByteBuf> comparator =
-      (o1, o2) -> {
-        requireNonNull(o1);
-        requireNonNull(o2);
-
-        return o1.compareTo(o2);
-      };
   private final long lengthOffset;
   private final long addressOffset;
 
@@ -81,6 +75,71 @@ public ByteBufProxy(final PooledByteBufAllocator allocator) {
     }
   }
 
+  /**
+   * Lexicographically compare two buffers.
+   *
+   * @param o1 left operand (required)
+   * @param o2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  public static int compareLexicographically(final ByteBuf o1, final ByteBuf o2) {
+    requireNonNull(o1);
+    requireNonNull(o2);
+    return o1.compareTo(o2);
+  }
+
+  /**
+   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs, i.e. when using
+   * MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+   *
+   * @param o1 left operand (required)
+   * @param o2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  public static int compareAsIntegerKeys(final ByteBuf o1, final ByteBuf o2) {
+    requireNonNull(o1);
+    requireNonNull(o2);
+    // Both buffers should be same length according to LMDB API.
+    // From the LMDB docs for MDB_INTEGER_KEY
+    // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the
+    // same size.
+    final int len1 = o1.readableBytes();
+    final int len2 = o2.readableBytes();
+    if (len1 != len2) {
+      throw new RuntimeException(
+          "Length mismatch, len1: "
+              + len1
+              + ", len2: "
+              + len2
+              + ". Lengths must be identical and either 4 or 8 bytes.");
+    }
+    if (len1 == 8) {
+      final long lw;
+      final long rw;
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        lw = o1.readLongLE();
+        rw = o2.readLongLE();
+      } else {
+        lw = o1.readLong();
+        rw = o2.readLong();
+      }
+      return Long.compareUnsigned(lw, rw);
+    } else if (len1 == 4) {
+      final int lw;
+      final int rw;
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        lw = o1.readIntLE();
+        rw = o2.readIntLE();
+      } else {
+        lw = o1.readInt();
+        rw = o2.readInt();
+      }
+      return Integer.compareUnsigned(lw, rw);
+    } else {
+      return compareLexicographically(o1, o2);
+    }
+  }
+
   static Field findField(final String c, final String name) {
     Class<?> clazz;
     try {
@@ -114,13 +173,12 @@ protected ByteBuf allocate() {
   }
 
   @Override
-  protected Comparator<ByteBuf> getSignedComparator() {
-    return comparator;
-  }
-
-  @Override
-  protected Comparator<ByteBuf> getUnsignedComparator() {
-    return comparator;
+  public Comparator<ByteBuf> getComparator(final DbiFlagSet dbiFlagSet) {
+    if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
+      return ByteBufProxy::compareAsIntegerKeys;
+    } else {
+      return ByteBufProxy::compareLexicographically;
+    }
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 3c80b995..52bfc924 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -27,6 +27,7 @@
 import java.lang.reflect.Field;
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.util.ArrayDeque;
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -57,6 +58,8 @@ public final class ByteBufferProxy {
   /** The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null. */
   public static final BufferProxy<ByteBuffer> PROXY_SAFE;
 
+  private static final ByteOrder NATIVE_ORDER = ByteOrder.nativeOrder();
+
   static {
     PROXY_SAFE = new ReflectiveProxy();
     PROXY_OPTIMAL = getProxyOptimal();
@@ -83,6 +86,8 @@ public BufferMustBeDirectException() {
     }
   }
 
+  // --------------------------------------------------------------------------------
+
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -92,16 +97,6 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
     protected static final String FIELD_NAME_ADDRESS = "address";
     protected static final String FIELD_NAME_CAPACITY = "capacity";
 
-    private static final Comparator<ByteBuffer> signedComparator =
-        (o1, o2) -> {
-          requireNonNull(o1);
-          requireNonNull(o2);
-
-          return o1.compareTo(o2);
-        };
-    private static final Comparator<ByteBuffer> unsignedComparator =
-        AbstractByteBufferProxy::compareBuff;
-
     /**
      * A thread-safe pool for a given length. If the buffer found is valid (ie not of a negative
      * length) then that buffer is used. If no valid buffer is found, a new buffer is created.
@@ -116,7 +111,7 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
      * @param o2 right operand (required)
      * @return as specified by {@link Comparable} interface
      */
-    public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
+    public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
       final int minLength = Math.min(o1.limit(), o2.limit());
@@ -145,6 +140,55 @@ public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
       return o1.remaining() - o2.remaining();
     }
 
+    /**
+     * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs, i.e. when
+     * using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+     *
+     * @param o1 left operand (required)
+     * @param o2 right operand (required)
+     * @return as specified by {@link Comparable} interface
+     */
+    public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2) {
+      requireNonNull(o1);
+      requireNonNull(o2);
+      // Both buffers should be same length according to LMDB API.
+      // From the LMDB docs for MDB_INTEGER_KEY
+      // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of
+      // the same size.
+      final int len1 = o1.limit();
+      final int len2 = o2.limit();
+      if (len1 != len2) {
+        throw new RuntimeException(
+            "Length mismatch, len1: "
+                + len1
+                + ", len2: "
+                + len2
+                + ". Lengths must be identical and either 4 or 8 bytes.");
+      }
+      // Keys for MDB_INTEGER_KEY are written in native order so ensure we read them in that order
+      o1.order(NATIVE_ORDER);
+      o2.order(NATIVE_ORDER);
+      // TODO it might be worth the DbiBuilder having a method to capture fixedKeyLength() or -1
+      //  for variable length keys. This can be passed to getComparator(..) so it can return a
+      //  comparator that doesn't need to test the length every time. There may be other benefits
+      //  to the Dbi knowing the key length if it is fixed.
+      if (len1 == 8) {
+        final long lw = o1.getLong(0);
+        final long rw = o2.getLong(0);
+        return Long.compareUnsigned(lw, rw);
+      } else if (len1 == 4) {
+        final int lw = o1.getInt(0);
+        final int rw = o2.getInt(0);
+        return Integer.compareUnsigned(lw, rw);
+      } else {
+        // size_t and int are likely to be 8bytes and 4bytes respectively on 64bit.
+        // If 32bit then would be 4/2 respectively.
+        // Short.compareUnsigned is not available in Java8.
+        // For now just fall back to our standard comparator
+        return compareLexicographically(o1, o2);
+      }
+    }
+
     static Field findField(final Class<?> c, final String name) {
       Class<?> clazz = c;
       do {
@@ -179,13 +223,12 @@ protected final ByteBuffer allocate() {
     }
 
     @Override
-    protected Comparator<ByteBuffer> getSignedComparator() {
-      return signedComparator;
-    }
-
-    @Override
-    protected Comparator<ByteBuffer> getUnsignedComparator() {
-      return unsignedComparator;
+    public Comparator<ByteBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
+      if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
+        return AbstractByteBufferProxy::compareAsIntegerKeys;
+      } else {
+        return AbstractByteBufferProxy::compareLexicographically;
+      }
     }
 
     @Override
@@ -203,6 +246,8 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
+  // --------------------------------------------------------------------------------
+
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -247,6 +292,8 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
+  // --------------------------------------------------------------------------------
+
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
new file mode 100644
index 00000000..b80e5b38
--- /dev/null
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface CopyFlagSet extends FlagSet<CopyFlags> {
+
+  static CopyFlagSet EMPTY = CopyFlagSetImpl.EMPTY;
+
+  static CopyFlagSet empty() {
+    return CopyFlagSetImpl.EMPTY;
+  }
+
+  static CopyFlagSet of(final CopyFlags dbiFlag) {
+    Objects.requireNonNull(dbiFlag);
+    return dbiFlag;
+  }
+
+  static CopyFlagSet of(final CopyFlags... CopyFlags) {
+    return builder().withFlags(CopyFlags).build();
+  }
+
+  static CopyFlagSet of(final Collection<CopyFlags> CopyFlags) {
+    return builder().withFlags(CopyFlags).build();
+  }
+
+  static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        CopyFlags.class, CopyFlagSetImpl::new, copyFlag -> copyFlag, () -> CopyFlagSetImpl.EMPTY);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
+
+    static final CopyFlagSet EMPTY = new EmptyCopyFlagSet();
+
+    private CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
+      super(flags);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
+      implements CopyFlagSet {}
+}
diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index 4365563c..b45dc87c 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -15,8 +15,12 @@
  */
 package org.lmdbjava;
 
-/** Flags for use when performing a {@link Env#copy(java.io.File, org.lmdbjava.CopyFlags...)}. */
-public enum CopyFlags implements MaskedFlag {
+import java.io.File;
+import java.util.EnumSet;
+import java.util.Set;
+
+/** Flags for use when performing a {@link Env#copy(File, CopyFlagSet)}. */
+public enum CopyFlags implements MaskedFlag, CopyFlagSet {
 
   /** Compacting copy: Omit free space from copy, and renumber all pages sequentially. */
   MDB_CP_COMPACT(0x01);
@@ -31,4 +35,29 @@ public enum CopyFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<CopyFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final CopyFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index f7fcbc41..f29c734f 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -20,8 +20,6 @@
 import static org.lmdbjava.Dbi.KeyNotFoundException.MDB_NOTFOUND;
 import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.Library.LIB;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
 import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
@@ -98,22 +96,40 @@ public long count() {
     return longByReference.longValue();
   }
 
+  /**
+   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}. <hr> Delete current key/data pair.
+   *     <p>This function deletes the key/data pair to which the cursor refers.
+   * @param flags flags (either null or {@link PutFlags#MDB_NODUPDATA}
+   */
+  @Deprecated
+  public void delete(final PutFlags... flags) {
+    delete(PutFlagSet.of(flags));
+  }
+
+  /**
+   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}. <hr> Delete current key/data pair.
+   *     <p>This function deletes the key/data pair to which the cursor refers.
+   */
+  public void delete() {
+    delete(PutFlagSet.EMPTY);
+  }
+
   /**
    * Delete current key/data pair.
    *
    * <p>This function deletes the key/data pair to which the cursor refers.
    *
-   * @param f flags (either null or {@link PutFlags#MDB_NODUPDATA}
+   * @param flags flags (either null or {@link PutFlags#MDB_NODUPDATA}
    */
-  public void delete(final PutFlags... f) {
+  public void delete(final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int flags = mask(true, f);
-    checkRc(LIB.mdb_cursor_del(ptrCursor, flags));
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
+    checkRc(LIB.mdb_cursor_del(ptrCursor, putFlagSet.getMask()));
   }
 
   /**
@@ -203,6 +219,10 @@ public T key() {
     return kv.key();
   }
 
+  KeyVal<T> keyVal() {
+    return kv;
+  }
+
   /**
    * Position at last key/data item.
    *
@@ -230,6 +250,20 @@ public boolean prev() {
     return seek(MDB_PREV);
   }
 
+  /**
+   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead. <hr> Store by cursor.
+   *     <p>This function stores key/data pairs into the database.
+   * @param key key to store
+   * @param val data to store
+   * @param flags options for this operation
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   */
+  @Deprecated
+  public boolean put(final T key, final T val, final PutFlags... flags) {
+    return put(key, val, PutFlagSet.of(flags));
+  }
+
   /**
    * Store by cursor.
    *
@@ -237,11 +271,25 @@ public boolean prev() {
    *
    * @param key key to store
    * @param val data to store
-   * @param op options for this operation
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
    *     key/value existed already.
    */
-  public boolean put(final T key, final T val, final PutFlags... op) {
+  public boolean put(final T key, final T val) {
+    return put(key, val, PutFlagSet.EMPTY);
+  }
+
+  /**
+   * Store by cursor.
+   *
+   * <p>This function stores key/data pairs into the database.
+   *
+   * @param key key to store
+   * @param val data to store
+   * @param flags options for this operation
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   */
+  public boolean put(final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       requireNonNull(val);
@@ -252,12 +300,13 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(val);
-    final int mask = mask(true, op);
-    final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), mask);
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
+    final int rc =
+        LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), putFlagSet.getMask());
     if (rc == MDB_KEYEXIST) {
-      if (isSet(mask, MDB_NOOVERWRITE)) {
+      if (putFlagSet.isSet(MDB_NOOVERWRITE)) {
         kv.valOut(); // marked as in,out in LMDB C docs
-      } else if (!isSet(mask, MDB_NODUPDATA)) {
+      } else if (!putFlagSet.isSet(MDB_NODUPDATA)) {
         checkRc(rc);
       }
       return false;
@@ -270,6 +319,39 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     return true;
   }
 
+  /**
+   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead. <hr> Put multiple
+   *     values into the database in one <code>MDB_MULTIPLE</code> operation.
+   *     <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
+   *     contain fixed-sized values to be inserted. The size of each element is calculated from the
+   *     buffer's size divided by the given element count. For example, to populate 10 X 4 byte
+   *     integers at once, present a buffer of 40 bytes and specify the element as 10.
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @param elements number of elements contained in the passed value buffer
+   * @param flags options for operation (must set <code>MDB_MULTIPLE</code>)
+   */
+  @Deprecated
+  public void putMultiple(final T key, final T val, final int elements, final PutFlags... flags) {
+    putMultiple(key, val, elements, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
+   *
+   * <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
+   * contain fixed-sized values to be inserted. The size of each element is calculated from the
+   * buffer's size divided by the given element count. For example, to populate 10 X 4 byte integers
+   * at once, present a buffer of 40 bytes and specify the element as 10.
+   *
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @param elements number of elements contained in the passed value buffer
+   */
+  public void putMultiple(final T key, final T val, final int elements) {
+    putMultiple(key, val, elements, PutFlagSet.EMPTY);
+  }
+
   /**
    * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
    *
@@ -281,9 +363,10 @@ public boolean put(final T key, final T val, final PutFlags... op) {
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
    * @param elements number of elements contained in the passed value buffer
-   * @param op options for operation (must set <code>MDB_MULTIPLE</code>)
+   * @param flags options for operation (must set <code>MDB_MULTIPLE</code>) Either a {@link
+   *     PutFlagSet} or a single {@link PutFlags}.
    */
-  public void putMultiple(final T key, final T val, final int elements, final PutFlags... op) {
+  public void putMultiple(final T key, final T val, final int elements, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
@@ -292,13 +375,14 @@ public void putMultiple(final T key, final T val, final int elements, final PutF
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int mask = mask(true, op);
-    if (SHOULD_CHECK && !isSet(mask, MDB_MULTIPLE)) {
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
+    if (SHOULD_CHECK && !putFlagSet.isSet(MDB_MULTIPLE)) {
       throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
     }
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer dataPtr = txn.kv().valInMulti(val, elements);
-    final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, mask);
+    final int rc =
+        LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, putFlagSet.getMask());
     checkRc(rc);
     ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(dataPtr);
@@ -329,21 +413,56 @@ public void renew(final Txn<T> newTxn) {
     this.txn = newTxn;
   }
 
+  /**
+   * @deprecated Use {@link Cursor#reserve(Object, int, PutFlagSet)} instead. <hr> Reserve space for
+   *     data of the given size, but don't copy the given val. Instead, return a pointer to the
+   *     reserved space, which the caller can fill in later - before the next update operation or
+   *     the transaction ends. This saves an extra memcpy if the data is being generated later. LMDB
+   *     does nothing else with this memory, the caller is expected to modify all of the space
+   *     requested.
+   *     <p>This flag must not be specified if the database was opened with MDB_DUPSORT
+   * @param key key to store in the database (not null)
+   * @param size size of the value to be stored in the database (not null)
+   * @param flags options for this operation
+   * @return a buffer that can be used to modify the value
+   */
+  @Deprecated
+  public T reserve(final T key, final int size, final PutFlags... flags) {
+    return reserve(key, size, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Reserve space for data of the given size, but don't copy the given val. Instead, return a
+   * pointer to the reserved space, which the caller can fill in later - before the next update
+   * operation or the transaction ends. This saves an extra {@code memcpy} if the data is being
+   * generated later. LMDB does nothing else with this memory, the caller is expected to modify all
+   * the space requested.
+   *
+   * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
+   *
+   * @param key key to store in the database (not null)
+   * @param size size of the value to be stored in the database (not null)
+   * @return a buffer that can be used to modify the value
+   */
+  public T reserve(final T key, final int size) {
+    return reserve(key, size, PutFlagSet.EMPTY);
+  }
+
   /**
    * Reserve space for data of the given size, but don't copy the given val. Instead, return a
    * pointer to the reserved space, which the caller can fill in later - before the next update
    * operation or the transaction ends. This saves an extra memcpy if the data is being generated
-   * later. LMDB does nothing else with this memory, the caller is expected to modify all of the
-   * space requested.
+   * later. LMDB does nothing else with this memory, the caller is expected to modify all the space
+   * requested.
    *
    * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    *
    * @param key key to store in the database (not null)
    * @param size size of the value to be stored in the database (not null)
-   * @param op options for this operation
+   * @param flags options for this operation
    * @return a buffer that can be used to modify the value
    */
-  public T reserve(final T key, final int size, final PutFlags... op) {
+  public T reserve(final T key, final int size, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       env.checkNotClosed();
@@ -353,8 +472,10 @@ public T reserve(final T key, final int size, final PutFlags... op) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(size);
-    final int flags = mask(true, op) | MDB_RESERVE.getMask();
-    checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flags));
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
+    // This is inconsistent with putMultiple which require MDB_MULTIPLE to be in the set.
+    final int flagsMask = putFlagSet.getMaskWith(MDB_RESERVE);
+    checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flagsMask));
     kv.valOut();
     ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(transientVal);
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 80fd5ef3..5c7a1b3f 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -21,10 +21,14 @@
 import static org.lmdbjava.CursorIterable.State.REQUIRES_NEXT_OP;
 import static org.lmdbjava.CursorIterable.State.TERMINATED;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
+import static org.lmdbjava.Library.LIB;
 
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.function.Supplier;
+import jnr.ffi.Pointer;
 import org.lmdbjava.KeyRangeType.CursorOp;
 import org.lmdbjava.KeyRangeType.IteratorOp;
 
@@ -38,7 +42,7 @@
  */
 public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T>>, AutoCloseable {
 
-  private final Comparator<T> comparator;
+  private final RangeComparator rangeComparator;
   private final Cursor<T> cursor;
   private final KeyVal<T> entry;
   private boolean iteratorReturned;
@@ -46,16 +50,32 @@ public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T
   private State state = REQUIRES_INITIAL_OP;
 
   CursorIterable(
-      final Txn<T> txn, final Dbi<T> dbi, final KeyRange<T> range, final Comparator<T> comparator) {
+      final Txn<T> txn,
+      final Dbi<T> dbi,
+      final KeyRange<T> range,
+      final Comparator<T> comparator,
+      final BufferProxy<T> proxy) {
     this.cursor = dbi.openCursor(txn);
     this.range = range;
-    this.comparator = comparator;
     this.entry = new KeyVal<>();
+
+    if (comparator != null) {
+      // User supplied Java-side comparator so use that
+      this.rangeComparator = new JavaRangeComparator<>(range, comparator, cursor::key);
+    } else {
+      // No Java-side comparator, so call down to LMDB to do the comparison
+      this.rangeComparator = new LmdbRangeComparator<>(txn, dbi, cursor, range, proxy);
+    }
   }
 
   @Override
   public void close() {
     cursor.close();
+    try {
+      rangeComparator.close();
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
   }
 
   /**
@@ -127,7 +147,7 @@ private void executeCursorOp(final CursorOp op) {
             // We need to ensure we move to the last matching key if using DUPSORT, see issue 267
             boolean loop = true;
             while (loop) {
-              if (comparator.compare(cursor.key(), range.getStart()) <= 0) {
+              if (rangeComparator.compareToStartKey() <= 0) {
                 found = cursor.next();
                 if (!found) {
                   // We got to the end so move last.
@@ -153,8 +173,7 @@ private void executeCursorOp(final CursorOp op) {
   }
 
   private void executeIteratorOp() {
-    final IteratorOp op =
-        range.getType().iteratorOp(range.getStart(), range.getStop(), entry.key(), comparator);
+    final IteratorOp op = range.getType().iteratorOp(entry.key(), rangeComparator);
     switch (op) {
       case CALL_NEXT_OP:
         executeCursorOp(range.getType().nextOp());
@@ -243,4 +262,104 @@ enum State {
     RELEASED,
     TERMINATED
   }
+
+  // --------------------------------------------------------------------------------
+
+  static class JavaRangeComparator<T> implements RangeComparator {
+
+    private final Comparator<T> comparator;
+    private final Supplier<T> currentKeySupplier;
+    private final T start;
+    private final T stop;
+
+    JavaRangeComparator(
+        final KeyRange<T> range,
+        final Comparator<T> comparator,
+        final Supplier<T> currentKeySupplier) {
+      this.comparator = comparator;
+      this.currentKeySupplier = currentKeySupplier;
+      this.start = range.getStart();
+      this.stop = range.getStop();
+    }
+
+    @Override
+    public int compareToStartKey() {
+      return comparator.compare(currentKeySupplier.get(), start);
+    }
+
+    @Override
+    public int compareToStopKey() {
+      return comparator.compare(currentKeySupplier.get(), stop);
+    }
+
+    @Override
+    public void close() throws Exception {
+      // Nothing to close
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /**
+   * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order. Has a
+   * very slight overhead as compared to {@link JavaRangeComparator}.
+   */
+  private static class LmdbRangeComparator<T> implements RangeComparator {
+
+    private final Pointer txnPointer;
+    private final Pointer dbiPointer;
+    private final Pointer cursorKeyPointer;
+    private final Key<T> startKey;
+    private final Key<T> stopKey;
+    private final Pointer startKeyPointer;
+    private final Pointer stopKeyPointer;
+
+    public LmdbRangeComparator(
+        final Txn<T> txn,
+        final Dbi<T> dbi,
+        final Cursor<T> cursor,
+        final KeyRange<T> range,
+        final BufferProxy<T> proxy) {
+      txnPointer = Objects.requireNonNull(txn).pointer();
+      dbiPointer = Objects.requireNonNull(dbi).pointer();
+      cursorKeyPointer = Objects.requireNonNull(cursor).keyVal().pointerKey();
+      // Allocate buffers for use with the start/stop keys if required.
+      // Saves us copying bytes on each comparison
+      Objects.requireNonNull(range);
+      startKey = createKey(range.getStart(), proxy);
+      stopKey = createKey(range.getStop(), proxy);
+      startKeyPointer = startKey != null ? startKey.pointer() : null;
+      stopKeyPointer = stopKey != null ? stopKey.pointer() : null;
+    }
+
+    @Override
+    public int compareToStartKey() {
+      return LIB.mdb_cmp(txnPointer, dbiPointer, cursorKeyPointer, startKeyPointer);
+    }
+
+    @Override
+    public int compareToStopKey() {
+      return LIB.mdb_cmp(txnPointer, dbiPointer, cursorKeyPointer, stopKeyPointer);
+    }
+
+    @Override
+    public void close() {
+      if (startKey != null) {
+        startKey.close();
+      }
+      if (stopKey != null) {
+        stopKey.close();
+      }
+    }
+
+    private Key<T> createKey(final T keyBuffer, final BufferProxy<T> proxy) {
+      if (keyBuffer != null) {
+        final Key<T> key = proxy.key();
+        key.keyIn(keyBuffer);
+        return key;
+      } else {
+        return null;
+      }
+    }
+  }
 }
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 5449c172..43fb335a 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -31,6 +31,7 @@
 import static org.lmdbjava.PutFlags.MDB_RESERVE;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 
+import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
@@ -48,12 +49,15 @@
  */
 public final class Dbi<T> {
 
-  private final ComparatorCallback ccb;
+  private final ComparatorCallback callbackComparator;
   private boolean cleaned;
+  // Used for CursorIterable KeyRange testing and/or native callbacks
   private final Comparator<T> comparator;
   private final Env<T> env;
   private final byte[] name;
   private final Pointer ptr;
+  private final BufferProxy<T> proxy;
+  private final DbiFlagSet dbiFlagSet;
 
   Dbi(
       final Env<T> env,
@@ -62,24 +66,34 @@ public final class Dbi<T> {
       final Comparator<T> comparator,
       final boolean nativeCb,
       final BufferProxy<T> proxy,
-      final DbiFlags... flags) {
+      final DbiFlagSet dbiFlagSet) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       txn.checkReady();
     }
     this.env = env;
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
-    if (comparator == null) {
-      this.comparator = proxy.getComparator(flags);
-    } else {
-      this.comparator = comparator;
-    }
-    final int flagsMask = mask(true, flags);
+    this.proxy = proxy;
+    this.comparator = comparator;
+    this.dbiFlagSet = dbiFlagSet;
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
-    checkRc(LIB.mdb_dbi_open(txn.pointer(), name, flagsMask, dbiPtr));
+    checkRc(LIB.mdb_dbi_open(txn.pointer(), name, dbiFlagSet.getMask(), dbiPtr));
     ptr = dbiPtr.getPointer(0);
     if (nativeCb) {
-      this.ccb =
+      requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
+      // LMDB will call back to this comparator for insertion/iteration order
+      //      if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
+      //        this.callbackComparator =
+      //            (keyA, keyB) -> {
+      //              final T compKeyA  = proxy.out(proxy.allocate(), keyA);
+      //              final T compKeyB = proxy.out(proxy.allocate(), keyB);
+      //              final int result = this.comparator.compare(compKeyA, compKeyB);
+      //              proxy.deallocate(compKeyA);
+      //              proxy.deallocate(compKeyB);
+      //              return result;
+      //            };
+      //      } else {
+      this.callbackComparator =
           (keyA, keyB) -> {
             final T compKeyA = proxy.out(proxy.allocate(), keyA);
             final T compKeyB = proxy.out(proxy.allocate(), keyB);
@@ -88,12 +102,17 @@ public final class Dbi<T> {
             proxy.deallocate(compKeyB);
             return result;
           };
-      LIB.mdb_set_compare(txn.pointer(), ptr, ccb);
+      //      }
+      LIB.mdb_set_compare(txn.pointer(), ptr, callbackComparator);
     } else {
-      ccb = null;
+      callbackComparator = null;
     }
   }
 
+  Pointer pointer() {
+    return ptr;
+  }
+
   /**
    * Close the database handle (normally unnecessary; use with caution).
    *
@@ -254,6 +273,30 @@ public byte[] getName() {
     return name == null ? null : Arrays.copyOf(name, name.length);
   }
 
+  public String getNameAsString() {
+    return getNameAsString(Env.DEFAULT_NAME_CHARSET);
+  }
+
+  /**
+   * Obtains the name of this database, using the supplied {@link Charset}.
+   *
+   * @return The name of the database. If this is the unnamed database an empty string will be
+   *     returned.
+   * @throws RuntimeException if the name can't be decoded.
+   */
+  public String getNameAsString(final Charset charset) {
+    if (name == null) {
+      return "";
+    } else {
+      // Assume a UTF8 encoding as we don't know, thus swallow if it fails
+      try {
+        return new String(name, requireNonNull(charset));
+      } catch (Exception e) {
+        throw new RuntimeException("Unable to decode database name using charset " + charset);
+      }
+    }
+  }
+
   /**
    * Iterate the database from the first item and forwards.
    *
@@ -278,7 +321,7 @@ public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
       env.checkNotClosed();
       txn.checkReady();
     }
-    return new CursorIterable<>(txn, this, range, comparator);
+    return new CursorIterable<>(txn, this, range, comparator, proxy);
   }
 
   /**
@@ -288,6 +331,7 @@ public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
    * @return the list of flags this Dbi was created with
    */
   public List<DbiFlags> listFlags(final Txn<T> txn) {
+    // TODO we could just return what is in dbiFlagSet, rather than hitting LMDB.
     if (SHOULD_CHECK) {
       env.checkNotClosed();
     }
@@ -337,15 +381,48 @@ public Cursor<T> openCursor(final Txn<T> txn) {
    *
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
-   * @see #put(org.lmdbjava.Txn, java.lang.Object, java.lang.Object, org.lmdbjava.PutFlags...)
+   * @see #put(Txn, Object, Object, PutFlagSet)
    */
   public void put(final T key, final T val) {
     try (Txn<T> txn = env.txnWrite()) {
-      put(txn, key, val);
+      put(txn, key, val, PutFlagSet.EMPTY);
       txn.commit();
     }
   }
 
+  /**
+   * @deprecated Use {@link Dbi#put(Txn, Object, Object, PutFlagSet)} instead, with a statically
+   *     held {@link PutFlagSet}. <hr>
+   *     <p>Store a key/value pair in the database.
+   *     <p>This function stores key/data pairs in the database. The default behavior is to enter
+   *     the new key/data pair, replacing any previously existing key if duplicates are disallowed,
+   *     or adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @param flags Special options for this operation
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   */
+  @Deprecated
+  public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags... flags) {
+    return put(txn, key, val, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Store a key/value pair in the database.
+   *
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   * @see #put(Txn, Object, Object, PutFlagSet)
+   */
+  public boolean put(final Txn<T> txn, final T key, final T val) {
+    return put(txn, key, val, PutFlagSet.EMPTY);
+  }
+
   /**
    * Store a key/value pair in the database.
    *
@@ -356,11 +433,11 @@ public void put(final T key, final T val) {
    * @param txn transaction handle (not null; not committed; must be R-W)
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
-   * @param flags Special options for this operation
+   * @param flags Special options for this operation.
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
    *     key/value existed already.
    */
-  public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags... flags) {
+  public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
@@ -369,15 +446,16 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
       txn.checkReady();
       txn.checkWritesAllowed();
     }
+    final PutFlagSet flagSet = flags != null ? flags : PutFlagSet.empty();
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(val);
-    final int mask = mask(true, flags);
     final int rc =
-        LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
+        LIB.mdb_put(
+            txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flagSet.getMask());
     if (rc == MDB_KEYEXIST) {
-      if (isSet(mask, MDB_NOOVERWRITE)) {
+      if (flagSet.isSet(MDB_NOOVERWRITE)) {
         txn.kv().valOut(); // marked as in,out in LMDB C docs
-      } else if (!isSet(mask, MDB_NODUPDATA)) {
+      } else if (!flagSet.isSet(MDB_NODUPDATA)) {
         checkRc(rc);
       }
       return false;
@@ -415,7 +493,7 @@ public T reserve(final Txn<T> txn, final T key, final int size, final PutFlags..
     }
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(size);
-    final int flags = mask(true, op) | MDB_RESERVE.getMask();
+    final int flags = mask(op) | MDB_RESERVE.getMask();
     checkRc(LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flags));
     txn.kv().valOut(); // marked as in,out in LMDB C docs
     ReferenceUtil.reachabilityFence0(transientKey);
@@ -454,6 +532,17 @@ private void clean() {
     cleaned = true;
   }
 
+  @Override
+  public String toString() {
+    String name;
+    try {
+      name = getNameAsString();
+    } catch (Exception e) {
+      name = "?";
+    }
+    return "Dbi{" + "name='" + name + "', dbiFlagSet=" + dbiFlagSet + '}';
+  }
+
   /** The specified DBI was changed unexpectedly. */
   public static final class BadDbiException extends LmdbNativeException {
 
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
new file mode 100644
index 00000000..bf318f75
--- /dev/null
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -0,0 +1,426 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Objects;
+
+/**
+ * Staged builder for building a {@link Dbi}
+ *
+ * @param <T> buffer type
+ */
+public class DbiBuilder<T> {
+
+  private final Env<T> env;
+  private final BufferProxy<T> proxy;
+  private final boolean readOnly;
+  private byte[] name;
+
+  DbiBuilder(final Env<T> env, final BufferProxy<T> proxy, final boolean readOnly) {
+    this.env = Objects.requireNonNull(env);
+    this.proxy = Objects.requireNonNull(proxy);
+    this.readOnly = readOnly;
+  }
+
+  /**
+   * Create the {@link Dbi} with the passed name.
+   *
+   * <p>The name will be converted into bytes using {@link StandardCharsets#UTF_8}.
+   *
+   * @param name The name of the database or null for the unnamed database (see also {@link
+   *     DbiBuilder#withoutDbName()})
+   * @return The next builder stage.
+   */
+  public DbiBuilderStage2<T> setDbName(final String name) {
+    // Null name is allowed so no null check
+    final byte[] nameBytes = name == null ? null : name.getBytes(Env.DEFAULT_NAME_CHARSET);
+    return setDbName(nameBytes);
+  }
+
+  /**
+   * Create the {@link Dbi} with the passed name in byte[] form.
+   *
+   * @param name The name of the database in byte form.
+   * @return The next builder stage.
+   */
+  public DbiBuilderStage2<T> setDbName(final byte[] name) {
+    // Null name is allowed so no null check
+    this.name = name;
+    return new DbiBuilderStage2<>(this);
+  }
+
+  /**
+   * Create the {@link Dbi} without a name.
+   *
+   * <p>Equivalent to passing null to {@link DbiBuilder#setDbName(String)} or {@link
+   * DbiBuilder#setDbName(byte[])}.
+   *
+   * <p>Note: The 'unnamed database' is used by LMDB to store the names of named databases, with the
+   * database name being the key. Use of the unnamed database is intended for simple applications
+   * with only one database.
+   *
+   * @return The next builder stage.
+   */
+  public DbiBuilderStage2<T> withoutDbName() {
+    return setDbName((byte[]) null);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /**
+   * Intermediate builder stage for constructing a {@link Dbi}.
+   *
+   * @param <T> buffer type
+   */
+  public static class DbiBuilderStage2<T> {
+
+    private final DbiBuilder<T> dbiBuilder;
+
+    private ComparatorFactory<T> comparatorFactory;
+    private ComparatorType comparatorType;
+
+    private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
+      this.dbiBuilder = dbiBuilder;
+    }
+
+    /**
+     * This is the <strong>default</strong> choice when it comes to choosing a comparator. If you
+     * are not sure of the implications of the other methods then use this one as it is likely what
+     * you want and also probably the most performant.
+     *
+     * <p>With this option, {@link CursorIterable} will make use of the LmdbJava's default Java-side
+     * comparators when comparing iteration keys to the start/stop keys. LMDB will use its own
+     * comparator for controlling insertion order in the database. The two comparators are
+     * functionally identical.
+     *
+     * <p>This option may be slightly more performant than when using {@link
+     * DbiBuilderStage2#withNativeComparator()} which calls down to LMDB for ALL comparison
+     * operations.
+     *
+     * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
+     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
+     * DbiBuilderStage2#withDefaultComparator()} or {@link
+     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * be used.
+     *
+     * @return The next builder stage.
+     */
+    public DbiBuilderStage3<T> withDefaultComparator() {
+      this.comparatorType = ComparatorType.DEFAULT;
+      return new DbiBuilderStage3<>(this);
+    }
+
+    /**
+     * With this option, {@link CursorIterable} will call down to LMDB's {@code mdb_cmp} method when
+     * comparing iteration keys to start/stop keys. This ensures LmdbJava is comparing start/stop
+     * keys using the same comparator that is used for insertion order into the db.
+     *
+     * <p>This option may be slightly less performant than when using {@link
+     * DbiBuilderStage2#withDefaultComparator()} as it needs to call down to LMDB to perform the
+     * comparisons, however it guarantees that {@link CursorIterable} key comparison matches LMDB
+     * key comparison.
+     *
+     * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
+     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
+     * DbiBuilderStage2#withDefaultComparator()} or {@link
+     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * be used.
+     *
+     * @return The next builder stage.
+     */
+    public DbiBuilderStage3<T> withNativeComparator() {
+      this.comparatorType = ComparatorType.NATIVE;
+      return new DbiBuilderStage3<>(this);
+    }
+
+    /**
+     * Provide a java-side {@link Comparator} that LMDB will call back to for <strong>all</strong>
+     * comparison operations. Therefore, it will be called by LMDB to manage database
+     * insertion/iteration order. It will also be used for {@link CursorIterable} start/stop key
+     * comparisons.
+     *
+     * <p>It can be useful if you need to sort your database using some other method, e.g. signed
+     * keys or case-insensitive order. Note, if you need keys stored in reverse order, see {@link
+     * DbiFlags#MDB_REVERSEKEY} and {@link DbiFlags#MDB_REVERSEDUP}.
+     *
+     * <p>As this requires LMDB to call back to java, this will be less performant than using LMDB's
+     * default comparators, but allows for total control over the order in which entries are stored
+     * in the database.
+     *
+     * @param comparatorFactory A factory to create a comparator. {@link
+     *     ComparatorFactory#create(DbiFlagSet)} will be called once during the initialisation of
+     *     the {@link Dbi}. It must not return null.
+     * @return The next builder stage.
+     */
+    public DbiBuilderStage3<T> withCallbackComparator(
+        final ComparatorFactory<T> comparatorFactory) {
+      this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
+      this.comparatorType = ComparatorType.CALLBACK;
+      return new DbiBuilderStage3<>(this);
+    }
+
+    /**
+     * <hr>
+     *
+     * <p><strong>WARNING</strong>: Only use this if you fully understand the risks and
+     * implications. <hr>
+     *
+     * <p>With this option, {@link CursorIterable} will make use of the passed comparator for
+     * comparing iteration keys to start/stop keys. It has <strong>NO</strong> bearing on the
+     * insert/iteration order of the database (which is controlled by LMDB's own comparators).
+     *
+     * <p>It is <strong>vital</strong> that this comparator is functionally identical to the one
+     * used internally in LMDB for insertion/iteration order, else you will see unexpected behaviour
+     * when using {@link CursorIterable}.
+     *
+     * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
+     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
+     * DbiBuilderStage2#withDefaultComparator()} or {@link
+     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * be used.
+     *
+     * @param comparatorFactory The comparator to use with {@link CursorIterable}. {@link
+     *     ComparatorFactory#create(DbiFlagSet)} will be called once during the initialisation of
+     *     the {@link Dbi}. It must not return null.
+     * @return The next builder stage.
+     */
+    public DbiBuilderStage3<T> withIteratorComparator(
+        final ComparatorFactory<T> comparatorFactory) {
+      this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
+      this.comparatorType = ComparatorType.ITERATOR;
+      return new DbiBuilderStage3<>(this);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /**
+   * Final stage builder for constructing a {@link Dbi}.
+   *
+   * @param <T> buffer type
+   */
+  public static class DbiBuilderStage3<T> {
+
+    private final DbiBuilderStage2<T> dbiBuilderStage2;
+    private final AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder =
+        DbiFlagSet.builder();
+    private Txn<T> txn = null;
+
+    private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
+      this.dbiBuilderStage2 = dbiBuilderStage2;
+    }
+
+    /**
+     * Apply all the dbi flags supplied in dbiFlags.
+     *
+     * <p>Clears all flags currently set by previous calls to {@link
+     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     *
+     * @param dbiFlags to open the database with. A null {@link Collection} will just clear all set
+     *     flags. Null items are ignored.
+     */
+    public DbiBuilderStage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
+      flagSetBuilder.clear();
+      if (dbiFlags != null) {
+        dbiFlags.stream().filter(Objects::nonNull).forEach(dbiFlags::add);
+      }
+      return this;
+    }
+
+    /**
+     * Apply all the dbi flags supplied in dbiFlags.
+     *
+     * <p>Clears all flags currently set by previous calls to {@link
+     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     *
+     * @param dbiFlags to open the database with. A null array will just clear all set flags. Null
+     *     items are ignored.
+     */
+    public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
+      flagSetBuilder.clear();
+      if (dbiFlags != null) {
+        Arrays.stream(dbiFlags).filter(Objects::nonNull).forEach(this.flagSetBuilder::setFlag);
+      }
+      return this;
+    }
+
+    /**
+     * Apply all the dbi flags supplied in dbiFlags.
+     *
+     * <p>Clears all flags currently set by previous calls to {@link
+     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     *
+     * @param dbiFlagSet to open the database with. A null value will just clear all set flags.
+     */
+    public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
+      flagSetBuilder.clear();
+      if (dbiFlagSet != null) {
+        this.flagSetBuilder.withFlags(dbiFlagSet.getFlags());
+      }
+      return this;
+    }
+
+    /**
+     * Adds a dbiFlag to those flags already added to this builder by {@link
+     * DbiBuilderStage3#setDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#setDbiFlags(Collection)}
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     *
+     * @param dbiFlag to add to any existing flags. A null value is a no-op.
+     * @return this builder instance.
+     */
+    public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
+      this.flagSetBuilder.setFlag(dbiFlag);
+      return this;
+    }
+
+    /**
+     * Adds a dbiFlag to those flags already added to this builder by {@link
+     * DbiBuilderStage3#setDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#setDbiFlags(Collection)}
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     *
+     * @param dbiFlagSet to add to any existing flags. A null value is a no-op.
+     * @return this builder instance.
+     */
+    public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
+      if (dbiFlagSet != null) {
+        flagSetBuilder.setFlags(dbiFlagSet.getFlags());
+      }
+      return this;
+    }
+
+    /**
+     * Use the supplied transaction to open the {@link Dbi}.
+     *
+     * <p>The caller MUST commit the transaction after calling {@link DbiBuilderStage3#open()}, in
+     * order to retain the <code>Dbi</code> in the <code>Env</code>.
+     *
+     * <p>If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for
+     * the purpose of creating and opening the {@link Dbi}, then closed. Therefore, if you already
+     * have a transaction open, you should supply that to avoid one blocking the other.
+     *
+     * @param txn transaction to use (required; not closed). If the {@link Env} was opened with the
+     *     {@link EnvFlags#MDB_RDONLY_ENV} flag, the {@link Txn} can be read-only, else it needs to
+     *     be a read/write {@link Txn}.
+     * @return this builder instance.
+     */
+    public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
+      this.txn = Objects.requireNonNull(txn);
+      return this;
+    }
+
+    /**
+     * Construct and open the {@link Dbi}.
+     *
+     * <p>If a {@link Txn} was supplied to the builder, it is the callers responsibility to commit
+     * and close the txn upon return from this method, else the created DB won't be retained.
+     *
+     * @return A newly constructed and opened {@link Dbi}.
+     */
+    public Dbi<T> open() {
+      final DbiBuilder<T> dbiBuilder = dbiBuilderStage2.dbiBuilder;
+      if (txn != null) {
+        return open(txn, dbiBuilder);
+      } else {
+        try (final Txn<T> txn = getTxn(dbiBuilder)) {
+          final Dbi<T> dbi = open(txn, dbiBuilder);
+          // even RO Txns require a commit to retain Dbi in Env
+          txn.commit();
+          return dbi;
+        }
+      }
+    }
+
+    private Txn<T> getTxn(final DbiBuilder<T> dbiBuilder) {
+      return dbiBuilder.readOnly ? dbiBuilder.env.txnRead() : dbiBuilder.env.txnWrite();
+    }
+
+    private Comparator<T> getComparator(
+        final DbiBuilder<T> dbiBuilder,
+        final ComparatorType comparatorType,
+        final DbiFlagSet dbiFlagSet) {
+      Comparator<T> comparator = null;
+      switch (comparatorType) {
+        case DEFAULT:
+          // Get the appropriate default CursorIterable comparator based on the DbiFlags,
+          // e.g. MDB_INTEGERKEY may benefit from an optimised comparator.
+          comparator = dbiBuilder.proxy.getComparator(dbiFlagSet);
+          break;
+        case CALLBACK:
+        case ITERATOR:
+          comparator =
+              Objects.requireNonNull(
+                  dbiBuilderStage2.comparatorFactory.create(dbiFlagSet),
+                  () -> "comparatorFactory returned null");
+          break;
+        case NATIVE:
+          break;
+        default:
+          throw new IllegalStateException("Unexpected comparatorType " + comparatorType);
+      }
+      return comparator;
+    }
+
+    private Dbi<T> open(final Txn<T> txn, final DbiBuilder<T> dbiBuilder) {
+      final DbiFlagSet dbiFlagSet = flagSetBuilder.build();
+      final ComparatorType comparatorType = dbiBuilderStage2.comparatorType;
+      final Comparator<T> comparator = getComparator(dbiBuilder, comparatorType, dbiFlagSet);
+      final boolean useNativeCallback = comparatorType == ComparatorType.CALLBACK;
+      return new Dbi<>(
+          dbiBuilder.env,
+          txn,
+          dbiBuilder.name,
+          comparator,
+          useNativeCallback,
+          dbiBuilder.proxy,
+          dbiFlagSet);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  private enum ComparatorType {
+    /**
+     * Default Java comparator for {@link CursorIterable} KeyRange testing, LMDB comparator for
+     * insertion/iteration order.
+     */
+    DEFAULT,
+    /** Use LMDB native comparator for everything. */
+    NATIVE,
+    /** Use the supplied custom Java-side comparator for everything. */
+    CALLBACK,
+    /**
+     * Use the supplied custom Java-side comparator for {@link CursorIterable} KeyRange testing,
+     * LMDB comparator for insertion/iteration order.
+     */
+    ITERATOR,
+    ;
+  }
+
+  // --------------------------------------------------------------------------------
+
+  @FunctionalInterface
+  public interface ComparatorFactory<T> {
+
+    Comparator<T> create(final DbiFlagSet dbiFlagSet);
+  }
+}
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
new file mode 100644
index 00000000..6fcdfd37
--- /dev/null
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface DbiFlagSet extends FlagSet<DbiFlags> {
+
+  /** An immutable empty {@link DbiFlagSet}. */
+  DbiFlagSet EMPTY = DbiFlagSetImpl.EMPTY;
+
+  /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
+  DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_INTEGERDUP);
+
+  static DbiFlagSet empty() {
+    return DbiFlagSetImpl.EMPTY;
+  }
+
+  static DbiFlagSet of(final DbiFlags dbiFlag) {
+    Objects.requireNonNull(dbiFlag);
+    return dbiFlag;
+  }
+
+  static DbiFlagSet of(final DbiFlags... DbiFlags) {
+    return builder().withFlags(DbiFlags).build();
+  }
+
+  static DbiFlagSet of(final Collection<DbiFlags> DbiFlags) {
+    return builder().withFlags(DbiFlags).build();
+  }
+
+  static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        DbiFlags.class, DbiFlagSetImpl::new, dbiFlag -> dbiFlag, () -> DbiFlagSetImpl.EMPTY);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
+
+    static final DbiFlagSet EMPTY = new EmptyDbiFlagSet();
+
+    private DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
+      super(flags);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
+      implements DbiFlagSet {}
+}
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 123ec9fd..f8ccbe20 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when opening a {@link Dbi}. */
-public enum DbiFlags implements MaskedFlag {
+public enum DbiFlags implements MaskedFlag, DbiFlagSet {
 
   /**
    * Use reverse string keys.
@@ -29,13 +32,26 @@ public enum DbiFlags implements MaskedFlag {
    * Use sorted duplicates.
    *
    * <p>Duplicate keys may be used in the database. Or, from another perspective, keys may have
-   * multiple data items, stored in sorted order. By default keys must be unique and may have only a
-   * single data item.
+   * multiple data items, stored in sorted order. By default, keys must be unique and may have only
+   * a single data item.
+   *
+   * <p>
    */
   MDB_DUPSORT(0x04),
   /**
-   * Numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the
-   * same size.
+   * Numeric keys in native byte order: either unsigned int or size_t. <strong>The keys must all be
+   * of the same size.</strong>
+   *
+   * <p>This is an optimisation that is available when your keys are 4 or 8 byte unsigned numeric
+   * values. There are performance benefits for both ordered and un-ordered puts as compared to not
+   * using this flag.
+   *
+   * <p>When writing the key to the buffer you must write it in native order and subsequently read
+   * any keys retrieved from LMDB (via cursor or get method) also using native order.
+   *
+   * <p>For more information, see <a
+   * href="https://github.com/lmdbjava/lmdbjava/wiki/Keys#numeric-keys">Numeric Keys</a> in the
+   * LmdbJava wiki.
    */
   MDB_INTEGERKEY(0x08),
   /**
@@ -55,14 +71,6 @@ public enum DbiFlags implements MaskedFlag {
    * #MDB_INTEGERKEY} keys.
    */
   MDB_INTEGERDUP(0x20),
-  /**
-   * Compare the <b>numeric</b> keys in native byte order and as unsigned.
-   *
-   * <p>This option is applied only to {@link java.nio.ByteBuffer}, {@link org.agrona.DirectBuffer}
-   * and byte array keys. {@link io.netty.buffer.ByteBuf} keys are always compared in native byte
-   * order and as unsigned.
-   */
-  MDB_UNSIGNEDKEY(0x30, false),
   /**
    * With {@link #MDB_DUPSORT}, use reverse string dups.
    *
@@ -78,15 +86,9 @@ public enum DbiFlags implements MaskedFlag {
   MDB_CREATE(0x4_0000);
 
   private final int mask;
-  private final boolean propagatedToLmdb;
-
-  DbiFlags(final int mask, final boolean propagatedToLmdb) {
-    this.mask = mask;
-    this.propagatedToLmdb = propagatedToLmdb;
-  }
 
   DbiFlags(final int mask) {
-    this(mask, true);
+    this.mask = mask;
   }
 
   @Override
@@ -95,7 +97,27 @@ public int getMask() {
   }
 
   @Override
-  public boolean isPropagatedToLmdb() {
-    return propagatedToLmdb;
+  public Set<DbiFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final DbiFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
   }
 }
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 524b81b8..af918943 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -22,6 +22,7 @@
 import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.util.ArrayDeque;
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -35,14 +36,6 @@
  * <p>This class requires {@link UnsafeAccess} and Agrona must be in the classpath.
  */
 public final class DirectBufferProxy extends BufferProxy<DirectBuffer> {
-  private static final Comparator<DirectBuffer> signedComparator =
-      (o1, o2) -> {
-        requireNonNull(o1);
-        requireNonNull(o2);
-
-        return o1.compareTo(o2);
-      };
-  private static final Comparator<DirectBuffer> unsignedComparator = DirectBufferProxy::compareBuff;
 
   /**
    * The {@link MutableDirectBuffer} proxy. Guaranteed to never be null, although a class
@@ -58,6 +51,8 @@ public final class DirectBufferProxy extends BufferProxy<DirectBuffer> {
   private static final ThreadLocal<ArrayDeque<DirectBuffer>> BUFFERS =
       withInitial(() -> new ArrayDeque<>(16));
 
+  private static final ByteOrder NATIVE_ORDER = ByteOrder.nativeOrder();
+
   private DirectBufferProxy() {}
 
   /**
@@ -67,7 +62,7 @@ private DirectBufferProxy() {}
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
-  public static int compareBuff(final DirectBuffer o1, final DirectBuffer o2) {
+  public static int compareLexicographically(final DirectBuffer o1, final DirectBuffer o2) {
     requireNonNull(o1);
     requireNonNull(o2);
 
@@ -95,6 +90,47 @@ public static int compareBuff(final DirectBuffer o1, final DirectBuffer o2) {
     return o1.capacity() - o2.capacity();
   }
 
+  /**
+   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs, i.e. when using
+   * MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+   *
+   * <p>Both buffer must have 4 or 8 bytes remaining
+   *
+   * @param o1 left operand (required)
+   * @param o2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  public static int compareAsIntegerKeys(final DirectBuffer o1, final DirectBuffer o2) {
+    requireNonNull(o1);
+    requireNonNull(o2);
+    // Both buffers should be same len
+    final int len1 = o1.capacity();
+    final int len2 = o2.capacity();
+    if (len1 != len2) {
+      throw new RuntimeException(
+          "Length mismatch, len1: "
+              + len1
+              + ", len2: "
+              + len2
+              + ". Lengths must be identical and either 4 or 8 bytes.");
+    }
+    if (len1 == 8) {
+      final long lw = o1.getLong(0, NATIVE_ORDER);
+      final long rw = o2.getLong(0, NATIVE_ORDER);
+      return Long.compareUnsigned(lw, rw);
+    } else if (len1 == 4) {
+      final int lw = o1.getInt(0, NATIVE_ORDER);
+      final int rw = o2.getInt(0, NATIVE_ORDER);
+      return Integer.compareUnsigned(lw, rw);
+    } else {
+      // size_t and int are likely to be 8bytes and 4bytes respectively on 64bit.
+      // If 32bit then would be 4/2 respectively.
+      // Short.compareUnsigned is not available in Java8.
+      // For now just fall back to our standard comparator
+      return compareLexicographically(o1, o2);
+    }
+  }
+
   @Override
   protected DirectBuffer allocate() {
     final ArrayDeque<DirectBuffer> q = BUFFERS.get();
@@ -109,13 +145,12 @@ protected DirectBuffer allocate() {
   }
 
   @Override
-  protected Comparator<DirectBuffer> getSignedComparator() {
-    return signedComparator;
-  }
-
-  @Override
-  protected Comparator<DirectBuffer> getUnsignedComparator() {
-    return unsignedComparator;
+  public Comparator<DirectBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
+    if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
+      return DirectBufferProxy::compareAsIntegerKeys;
+    } else {
+      return DirectBufferProxy::compareLexicographically;
+    }
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 3db16119..480ee8b7 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -23,17 +23,20 @@
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.Library.LIB;
 import static org.lmdbjava.Library.RUNTIME;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
-import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
 import java.io.File;
 import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Objects;
 import jnr.ffi.Pointer;
 import jnr.ffi.byref.IntByReference;
 import jnr.ffi.byref.PointerByReference;
@@ -50,6 +53,8 @@ public final class Env<T> implements AutoCloseable {
   /** Java system property name that can be set to disable optional checks. */
   public static final String DISABLE_CHECKS_PROP = "lmdbjava.disable.checks";
 
+  public static final Charset DEFAULT_NAME_CHARSET = StandardCharsets.UTF_8;
+
   /**
    * Indicates whether optional checks should be applied in LmdbJava. Optional checks are only
    * disabled in critical paths (see package-level JavaDocs). Non-critical paths have optional
@@ -98,14 +103,15 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
   }
 
   /**
-   * Opens an environment with a single default database in 0664 mode using the {@link
-   * ByteBufferProxy#PROXY_OPTIMAL}.
-   *
+   * @deprecated Instead use {@link Env#create()} or {@link Env#create(BufferProxy)}
+   *     <p>Opens an environment with a single default database in 0664 mode using the {@link
+   *     ByteBufferProxy#PROXY_OPTIMAL}.
    * @param path file system destination
    * @param size size in megabytes
    * @param flags the flags for this new environment
    * @return env the environment (never null)
    */
+  @Deprecated
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
     return new Builder<>(PROXY_OPTIMAL).setMapSize(size * 1_024L * 1_024L).open(path, flags);
   }
@@ -124,6 +130,27 @@ public void close() {
     LIB.mdb_env_close(ptr);
   }
 
+  /**
+   * Copies an LMDB environment to the specified destination path.
+   *
+   * <p>This function may be used to make a backup of an existing environment. No lockfile is
+   * created, since it gets recreated at need.
+   *
+   * <p>If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the destination path
+   * must be a directory that exists but contains no files. If {@link EnvFlags#MDB_NOSUBDIR} was
+   * used, the destination path must not exist, but it must be possible to create a file at the
+   * provided path.
+   *
+   * <p>Note: This call can trigger significant file size growth if run in parallel with write
+   * transactions, because it employs a read-only transaction. See long-lived transactions under
+   * "Caveats" in the LMDB native documentation.
+   *
+   * @param path writable destination path as described above
+   */
+  public void copy(final File path) {
+    copy(path, CopyFlagSet.EMPTY);
+  }
+
   /**
    * Copies an LMDB environment to the specified destination path.
    *
@@ -142,11 +169,10 @@ public void close() {
    * @param path writable destination path as described above
    * @param flags special options for this copy
    */
-  public void copy(final File path, final CopyFlags... flags) {
+  public void copy(final File path, final CopyFlagSet flags) {
     requireNonNull(path);
     validatePath(path);
-    final int flagsMask = mask(true, flags);
-    checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flagsMask));
+    checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flags.getMask()));
   }
 
   /**
@@ -242,27 +268,44 @@ public boolean isReadOnly() {
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
-   * Comparator} that is not invoked from native code.
+   * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set) a {@link Dbi} using a
+   * builder.
    *
+   * @return A new builder instance for creating/opening a {@link Dbi}.
+   */
+  public DbiBuilder<T> buildDbi() {
+    return new DbiBuilder<>(this, proxy, readOnly);
+  }
+
+  /**
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} Convenience method that opens a {@link Dbi} with
+   *     a UTF-8 database name and default {@link Comparator} that is not invoked from native code.
    */
+  @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
     return openDbi(nameBytes, null, false, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator} that is not invoked from native code.
-   *
    * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use default)
+   * @param comparator custom comparator for cursor start/stop key comparisons. If null, LMDB's
+   *     comparator will be used.
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} Convenience method that opens a {@link Dbi} with
+   *     a UTF-8 database name and associated {@link Comparator} for use by {@link CursorIterable}
+   *     when comparing start/stop keys.
+   *     <p>It is very important that the passed comparator behaves in the same way as the
+   *     comparator LMDB uses for its insertion order (for the type of data that will be stored in
+   *     the database), or you fully understand the implications of them behaving differently.
+   *     LMDB's comparator is unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is
+   *     used.
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final String name, final Comparator<T> comparator, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
@@ -270,15 +313,19 @@ public Dbi<T> openDbi(
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator} that may be invoked from native code if specified.
-   *
    * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use default)
-   * @param nativeCb whether native code calls back to the Java comparator
+   * @param comparator custom comparator for cursor start/stop key comparisons and optionally for
+   *     LMDB to call back to. If null, LMDB's comparator will be used.
+   * @param nativeCb whether LMDB native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} Convenience method that opens a {@link Dbi} with
+   *     a UTF-8 database name and associated {@link Comparator}. The comparator will be used by
+   *     {@link CursorIterable} when comparing start/stop keys as a minimum. If nativeCb is {@code
+   *     true}, this comparator will also be called by LMDB to determine insertion/iteration order.
+   *     Calling back to a java comparator may significantly impact performance.
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final String name,
       final Comparator<T> comparator,
@@ -289,44 +336,43 @@ public Dbi<T> openDbi(
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
-   * invoked from native code.
-   *
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} <hr> Convenience method that opens a {@link Dbi}
+   *     with a default {@link Comparator} that is not invoked from native code.
    */
+  @Deprecated()
   public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
     return openDbi(name, null, false, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that is not
-   * invoked from native code.
-   *
    * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} <hr> Convenience method that opens a {@link Dbi}
+   *     with an associated {@link Comparator} that is not invoked from native code.
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final byte[] name, final Comparator<T> comparator, final DbiFlags... flags) {
     return openDbi(name, comparator, false, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that may be
-   * invoked from native code if specified.
-   *
-   * <p>This method will automatically commit the private transaction before returning. This ensures
-   * the <code>Dbi</code> is available in the <code>Env</code>.
-   *
    * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
    * @param nativeCb whether native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} <hr> Convenience method that opens a {@link Dbi}
+   *     with an associated {@link Comparator} that may be invoked from native code if specified.
+   *     <p>This method will automatically commit the private transaction before returning. This
+   *     ensures the <code>Dbi</code> is available in the <code>Env</code>.
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final byte[] name,
       final Comparator<T> comparator,
@@ -340,39 +386,40 @@ public Dbi<T> openDbi(
   }
 
   /**
-   * Open the {@link Dbi} using the passed {@link Txn}.
-   *
-   * <p>The caller must commit the transaction after this method returns in order to retain the
-   * <code>Dbi</code> in the <code>Env</code>.
-   *
-   * <p>A {@link Comparator} may be provided when calling this method. Such comparator is primarily
-   * used by {@link CursorIterable} instances. A secondary (but uncommon) use of the comparator is
-   * to act as a callback from the native library if <code>nativeCb</code> is <code>true</code>.
-   * This is usually avoided due to the overhead of native code calling back into Java. It is
-   * instead highly recommended to set the correct {@link DbiFlags} to allow the native library to
-   * correctly order the intended keys.
-   *
-   * <p>A default comparator will be provided if <code>null</code> is passed as the comparator. If a
-   * custom comparator is provided, it must strictly match the lexicographical order of keys in the
-   * native LMDB database.
-   *
-   * <p>This method (and its overloaded convenience variants) must not be called from concurrent
-   * threads.
-   *
    * @param txn transaction to use (required; not closed)
    * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb whether native code should call back to the comparator
+   * @param nativeCb whether native LMDB code should call back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} Open the {@link Dbi} using the passed {@link
+   *     Txn}.
+   *     <p>The caller must commit the transaction after this method returns in order to retain the
+   *     <code>Dbi</code> in the <code>Env</code>.
+   *     <p>A {@link Comparator} may be provided when calling this method. Such comparator is
+   *     primarily used by {@link CursorIterable} instances. A secondary (but uncommon) use of the
+   *     comparator is to act as a callback from the native library if <code>nativeCb</code> is
+   *     <code>true</code>. This is usually avoided due to the overhead of native code calling back
+   *     into Java. It is instead highly recommended to set the correct {@link DbiFlags} to allow
+   *     the native library to correctly order the intended keys.
+   *     <p>A default comparator will be provided if <code>null</code> is passed as the comparator.
+   *     If a custom comparator is provided, it must strictly match the lexicographical order of
+   *     keys in the native LMDB database.
+   *     <p>This method (and its overloaded convenience variants) must not be called from concurrent
+   *     threads.
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final Txn<T> txn,
       final byte[] name,
       final Comparator<T> comparator,
       final boolean nativeCb,
       final DbiFlags... flags) {
-    return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, flags);
+
+    if (nativeCb && comparator == null) {
+      throw new IllegalArgumentException("Is nativeCb is true, you must supply a comparator");
+    }
+    return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
   }
 
   /**
@@ -410,16 +457,40 @@ public void sync(final boolean force) {
   }
 
   /**
-   * Obtain a transaction with the requested parent and flags.
-   *
    * @param parent parent transaction (may be null if no parent)
    * @param flags applicable flags (eg for a reusable, read-only transaction)
    * @return a transaction (never null)
+   * @deprecated Instead use {@link Env#txn(Txn, TxnFlagSet)}
+   *     <p>Obtain a transaction with the requested parent and flags.
    */
+  @Deprecated
   public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
-    if (closed) {
-      throw new AlreadyClosedException();
-    }
+    checkNotClosed();
+    return new Txn<>(this, parent, proxy, TxnFlagSet.of(flags));
+  }
+
+  /**
+   * Obtain a transaction with the requested parent and flags.
+   *
+   * @param parent parent transaction (may be null if no parent)
+   * @return a transaction (never null)
+   */
+  public Txn<T> txn(final Txn<T> parent) {
+    checkNotClosed();
+    return new Txn<>(this, parent, proxy, TxnFlagSet.EMPTY);
+  }
+
+  /**
+   * Obtain a transaction with the requested parent and flags.
+   *
+   * @param parent parent transaction (may be null if no parent)
+   * @param flags applicable flags (e.g. for a reusable, read-only transaction). If the set of flags
+   *     is used frequently it is recommended to hold a static instance of the {@link TxnFlagSet}
+   *     for re-use.
+   * @return a transaction (never null)
+   */
+  public Txn<T> txn(final Txn<T> parent, final TxnFlagSet flags) {
+    checkNotClosed();
     return new Txn<>(this, parent, proxy, flags);
   }
 
@@ -429,7 +500,8 @@ public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
    * @return a read-only transaction
    */
   public Txn<T> txnRead() {
-    return txn(null, MDB_RDONLY_TXN);
+    checkNotClosed();
+    return new Txn<>(this, null, proxy, TxnFlags.MDB_RDONLY_TXN);
   }
 
   /**
@@ -438,7 +510,8 @@ public Txn<T> txnRead() {
    * @return a read-write transaction
    */
   public Txn<T> txnWrite() {
-    return txn(null);
+    checkNotClosed();
+    return new Txn<>(this, null, proxy, TxnFlagSet.EMPTY);
   }
 
   Pointer pointer() {
@@ -507,6 +580,8 @@ public AlreadyOpenException() {
     }
   }
 
+  // --------------------------------------------------------------------------------
+
   /**
    * Builder for configuring and opening Env.
    *
@@ -520,6 +595,8 @@ public static final class Builder<T> {
     private int maxReaders = MAX_READERS_DEFAULT;
     private boolean opened;
     private final BufferProxy<T> proxy;
+    private int mode = 0664;
+    private AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> flagSetBuilder = EnvFlagSet.builder();
 
     Builder(final BufferProxy<T> proxy) {
       requireNonNull(proxy);
@@ -533,8 +610,50 @@ public static final class Builder<T> {
      * @param mode Unix permissions to set on created files and semaphores
      * @param flags the flags for this new environment
      * @return an environment ready for use
+     * @deprecated Instead use {@link Builder#open(Path)}, {@link Builder#setFilePermissions(int)}
+     *     and {@link Builder#setEnvFlags(EnvFlags...)}.
      */
+    @Deprecated
     public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
+      setFilePermissions(mode);
+      setEnvFlags(flags);
+      return open(requireNonNull(path).toPath());
+    }
+
+    /**
+     * Opens the environment.
+     *
+     * @param path file system destination
+     * @return an environment ready for use
+     * @deprecated Instead use {@link Builder#open(Path)}
+     */
+    @Deprecated
+    public Env<T> open(final File path) {
+      return open(requireNonNull(path).toPath());
+    }
+
+    /**
+     * Opens the environment with 0664 mode.
+     *
+     * @param path file system destination
+     * @param flags the flags for this new environment
+     * @return an environment ready for use
+     * @deprecated Instead use {@link Builder#open(Path)} and {@link
+     *     Builder#setEnvFlags(EnvFlags...)}.
+     */
+    @Deprecated
+    public Env<T> open(final File path, final EnvFlags... flags) {
+      setEnvFlags(flags);
+      return open(requireNonNull(path).toPath());
+    }
+
+    /**
+     * Opens the environment.
+     *
+     * @param path file system destination
+     * @return an environment ready for use
+     */
+    public Env<T> open(final Path path) {
       requireNonNull(path);
       if (opened) {
         throw new AlreadyOpenException();
@@ -547,10 +666,10 @@ public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
         checkRc(LIB.mdb_env_set_mapsize(ptr, mapSize));
         checkRc(LIB.mdb_env_set_maxdbs(ptr, maxDbs));
         checkRc(LIB.mdb_env_set_maxreaders(ptr, maxReaders));
-        final int flagsMask = mask(true, flags);
-        final boolean readOnly = isSet(flagsMask, MDB_RDONLY_ENV);
-        final boolean noSubDir = isSet(flagsMask, MDB_NOSUBDIR);
-        checkRc(LIB.mdb_env_open(ptr, path.getAbsolutePath(), flagsMask, mode));
+        final EnvFlagSet flags = flagSetBuilder.build();
+        final boolean readOnly = flags.isSet(MDB_RDONLY_ENV);
+        final boolean noSubDir = flags.isSet(MDB_NOSUBDIR);
+        checkRc(LIB.mdb_env_open(ptr, path.toAbsolutePath().toString(), flags.getMask(), mode));
         return new Env<>(proxy, ptr, readOnly, noSubDir);
       } catch (final LmdbNativeException e) {
         LIB.mdb_env_close(ptr);
@@ -559,18 +678,7 @@ public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
     }
 
     /**
-     * Opens the environment with 0664 mode.
-     *
-     * @param path file system destination
-     * @param flags the flags for this new environment
-     * @return an environment ready for use
-     */
-    public Env<T> open(final File path, final EnvFlags... flags) {
-      return open(path, 0664, flags);
-    }
-
-    /**
-     * Sets the map size.
+     * Sets the map size in bytes.
      *
      * @param mapSize new limit in bytes
      * @return the builder
@@ -613,6 +721,90 @@ public Builder<T> setMaxReaders(final int readers) {
       this.maxReaders = readers;
       return this;
     }
+
+    /**
+     * Sets the Unix file permissions to use on created files and semaphores, e.g. {@code 0664}. If
+     * this method is not called, the default of {@code 0664} will be used.
+     *
+     * @param mode Unix permissions to set on created files and semaphores
+     * @return the builder
+     */
+    public Builder<T> setFilePermissions(final int mode) {
+      if (opened) {
+        throw new AlreadyOpenException();
+      }
+      this.mode = mode;
+      return this;
+    }
+
+    /**
+     * Sets all the flags used to open this {@link Env}.
+     *
+     * @param envFlags The flags to use. Clears any existing flags. A null value results in no flags
+     *     being set.
+     * @return this builder instance.
+     */
+    public Builder<T> setEnvFlags(final Collection<EnvFlags> envFlags) {
+      flagSetBuilder.clear();
+      if (envFlags != null) {
+        envFlags.stream().filter(Objects::nonNull).forEach(envFlags::add);
+      }
+      return this;
+    }
+
+    /**
+     * Sets all the flags used to open this {@link Env}.
+     *
+     * @param envFlags The flags to use. Clears any existing flags. A null value results in no flags
+     *     being set.
+     * @return this builder instance.
+     */
+    public Builder<T> setEnvFlags(final EnvFlags... envFlags) {
+      flagSetBuilder.clear();
+      if (envFlags != null) {
+        Arrays.stream(envFlags).filter(Objects::nonNull).forEach(this.flagSetBuilder::setFlag);
+      }
+      return this;
+    }
+
+    /**
+     * Sets all the flags used to open this {@link Env}.
+     *
+     * @param envFlagSet The flags to use. Clears any existing flags. A null value results in no
+     *     flags being set.
+     * @return this builder instance.
+     */
+    public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
+      flagSetBuilder.clear();
+      if (envFlagSet != null) {
+        this.flagSetBuilder.withFlags(envFlagSet.getFlags());
+      }
+      return this;
+    }
+
+    /**
+     * Adds a single {@link EnvFlags} to any existing flags.
+     *
+     * @param dbiFlag The flag to add to any existing flags. A null value is a no-op.
+     * @return this builder instance.
+     */
+    public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
+      this.flagSetBuilder.setFlag(dbiFlag);
+      return this;
+    }
+
+    /**
+     * Adds a set of {@link EnvFlags} to any existing flags.
+     *
+     * @param dbiFlagSet The set of flags to add to any existing flags. A null value is a no-op.
+     * @return this builder instance.
+     */
+    public Builder<T> addEnvFlags(final EnvFlagSet dbiFlagSet) {
+      if (dbiFlagSet != null) {
+        flagSetBuilder.setFlags(dbiFlagSet.getFlags());
+      }
+      return this;
+    }
   }
 
   /** File is not a valid LMDB file. */
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
new file mode 100644
index 00000000..2ee90e11
--- /dev/null
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface EnvFlagSet extends FlagSet<EnvFlags> {
+
+  EnvFlagSet EMPTY = EnvFlagSetImpl.EMPTY;
+
+  static EnvFlagSet empty() {
+    return EnvFlagSetImpl.EMPTY;
+  }
+
+  static EnvFlagSet of(final EnvFlags envFlag) {
+    Objects.requireNonNull(envFlag);
+    return envFlag;
+  }
+
+  static EnvFlagSet of(final EnvFlags... EnvFlags) {
+    return builder().withFlags(EnvFlags).build();
+  }
+
+  static EnvFlagSet of(final Collection<EnvFlags> EnvFlags) {
+    return builder().withFlags(EnvFlags).build();
+  }
+
+  static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        EnvFlags.class, EnvFlagSetImpl::new, envFlag -> envFlag, () -> EnvFlagSetImpl.EMPTY);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
+
+    static final EnvFlagSet EMPTY = new EmptyEnvFlagSet();
+
+    private EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
+      super(flags);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
+      implements EnvFlagSet {}
+}
diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index 4ce555a8..7fb4a29b 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when opening the {@link Env}. */
-public enum EnvFlags implements MaskedFlag {
+public enum EnvFlags implements MaskedFlag, EnvFlagSet {
 
   /**
    * Mmap at a fixed address (experimental).
@@ -144,4 +147,29 @@ public enum EnvFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<EnvFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final EnvFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
new file mode 100644
index 00000000..184694e2
--- /dev/null
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * A set of flags, each with a bit mask value. Flags can be combined in a set such that the set has
+ * a combined bit mask value.
+ *
+ * @param <T>
+ */
+public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
+
+  /**
+   * @return The combined mask for this flagSet.
+   */
+  int getMask();
+
+  /**
+   * @return The result of combining the mask of this {@link FlagSet} with the mask of the other
+   *     {@link FlagSet}.
+   */
+  default int getMaskWith(final FlagSet<T> other) {
+    if (other != null) {
+      return MaskedFlag.mask(getMask(), other.getMask());
+    } else {
+      return getMask();
+    }
+  }
+
+  /**
+   * @return The set of flags in this {@link FlagSet}.
+   */
+  Set<T> getFlags();
+
+  /**
+   * @return True if flag is non-null and included in this {@link FlagSet}.
+   */
+  boolean isSet(T flag);
+
+  /**
+   * @return True if at least one of flags are included in thie {@link FlagSet}
+   */
+  default boolean areAnySet(final FlagSet<T> flags) {
+    if (flags == null) {
+      return false;
+    } else {
+      for (final T flag : flags) {
+        if (isSet(flag)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * @return The size of this {@link FlagSet}
+   */
+  default int size() {
+    return getFlags().size();
+  }
+
+  /**
+   * @return True if this {@link FlagSet} is empty.
+   */
+  default boolean isEmpty() {
+    return getFlags().isEmpty();
+  }
+
+  /**
+   * @return The {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
+   */
+  default Iterator<T> iterator() {
+    return getFlags().iterator();
+  }
+
+  /** Convert this {@link FlagSet} to a string for use in toString methods. */
+  static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
+    Objects.requireNonNull(flagSet);
+    final String flagsStr =
+        flagSet.getFlags().stream()
+            .sorted(Comparator.comparing(MaskedFlag::getMask))
+            .map(MaskedFlag::name)
+            .collect(Collectors.joining(", "));
+    return "FlagSet{" + "flags=[" + flagsStr + "], mask=" + flagSet.getMask() + '}';
+  }
+
+  static boolean equals(final FlagSet<?> flagSet, final Object other) {
+    if (other instanceof FlagSet) {
+      final FlagSet<?> flagSet2 = (FlagSet<?>) other;
+      if (flagSet == flagSet2) {
+        return true;
+      } else if (flagSet == null) {
+        return false;
+      } else {
+        return flagSet.getMask() == flagSet2.getMask()
+            && Objects.equals(flagSet.getFlags(), flagSet2.getFlags());
+      }
+    } else {
+      return false;
+    }
+  }
+}
diff --git a/src/main/java/org/lmdbjava/Key.java b/src/main/java/org/lmdbjava/Key.java
new file mode 100644
index 00000000..ac25f65d
--- /dev/null
+++ b/src/main/java/org/lmdbjava/Key.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static java.util.Objects.requireNonNull;
+import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
+import static org.lmdbjava.Library.RUNTIME;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.provider.MemoryManager;
+
+/**
+ * Represents off-heap memory holding a key only.
+ *
+ * @param <T> buffer type
+ */
+final class Key<T> implements AutoCloseable {
+
+  private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
+  private boolean closed;
+  private T k;
+  private final BufferProxy<T> proxy;
+  private final Pointer ptrKey;
+  private final long ptrKeyAddr;
+
+  Key(final BufferProxy<T> proxy) {
+    requireNonNull(proxy);
+    this.proxy = proxy;
+    this.k = proxy.allocate();
+    ptrKey = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE, false);
+    ptrKeyAddr = ptrKey.address();
+  }
+
+  @Override
+  public void close() {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    proxy.deallocate(k);
+  }
+
+  T key() {
+    return k;
+  }
+
+  void keyIn(final T key) {
+    proxy.in(key, ptrKey);
+  }
+
+  T keyOut() {
+    k = proxy.out(k, ptrKey);
+    return k;
+  }
+
+  Pointer pointer() {
+    return ptrKey;
+  }
+}
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index 0514cbf2..4cb1cc9b 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -345,15 +345,13 @@ CursorOp initialOp() {
    *
    * @param <T> buffer type
    * @param <C> comparator for the buffers
-   * @param start start buffer
-   * @param stop stop buffer
    * @param buffer current key returned by LMDB (may be null)
-   * @param c comparator (required)
+   * @param rangeComparator comparator (required)
    * @return response to this key
    */
   <T, C extends Comparator<T>> IteratorOp iteratorOp(
-      final T start, final T stop, final T buffer, final C c) {
-    requireNonNull(c, "Comparator required");
+      final T buffer, final RangeComparator rangeComparator) {
+    requireNonNull(rangeComparator, "Comparator required");
     if (buffer == null) {
       return TERMINATE;
     }
@@ -363,55 +361,55 @@ <T, C extends Comparator<T>> IteratorOp iteratorOp(
       case FORWARD_AT_LEAST:
         return RELEASE;
       case FORWARD_AT_MOST:
-        return c.compare(buffer, stop) > 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() > 0 ? TERMINATE : RELEASE;
       case FORWARD_CLOSED:
-        return c.compare(buffer, stop) > 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() > 0 ? TERMINATE : RELEASE;
       case FORWARD_CLOSED_OPEN:
-        return c.compare(buffer, stop) >= 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() >= 0 ? TERMINATE : RELEASE;
       case FORWARD_GREATER_THAN:
-        return c.compare(buffer, start) == 0 ? CALL_NEXT_OP : RELEASE;
+        return rangeComparator.compareToStartKey() == 0 ? CALL_NEXT_OP : RELEASE;
       case FORWARD_LESS_THAN:
-        return c.compare(buffer, stop) >= 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() >= 0 ? TERMINATE : RELEASE;
       case FORWARD_OPEN:
-        if (c.compare(buffer, start) == 0) {
+        if (rangeComparator.compareToStartKey() == 0) {
           return CALL_NEXT_OP;
         }
-        return c.compare(buffer, stop) >= 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() >= 0 ? TERMINATE : RELEASE;
       case FORWARD_OPEN_CLOSED:
-        if (c.compare(buffer, start) == 0) {
+        if (rangeComparator.compareToStartKey() == 0) {
           return CALL_NEXT_OP;
         }
-        return c.compare(buffer, stop) > 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() > 0 ? TERMINATE : RELEASE;
       case BACKWARD_ALL:
         return RELEASE;
       case BACKWARD_AT_LEAST:
-        return c.compare(buffer, start) > 0 ? CALL_NEXT_OP : RELEASE; // rewind
+        return rangeComparator.compareToStartKey() > 0 ? CALL_NEXT_OP : RELEASE; // rewind
       case BACKWARD_AT_MOST:
-        return c.compare(buffer, stop) >= 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() >= 0 ? RELEASE : TERMINATE;
       case BACKWARD_CLOSED:
-        if (c.compare(buffer, start) > 0) {
+        if (rangeComparator.compareToStartKey() > 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) >= 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() >= 0 ? RELEASE : TERMINATE;
       case BACKWARD_CLOSED_OPEN:
-        if (c.compare(buffer, start) > 0) {
+        if (rangeComparator.compareToStartKey() > 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) > 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() > 0 ? RELEASE : TERMINATE;
       case BACKWARD_GREATER_THAN:
-        return c.compare(buffer, start) >= 0 ? CALL_NEXT_OP : RELEASE;
+        return rangeComparator.compareToStartKey() >= 0 ? CALL_NEXT_OP : RELEASE;
       case BACKWARD_LESS_THAN:
-        return c.compare(buffer, stop) > 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() > 0 ? RELEASE : TERMINATE;
       case BACKWARD_OPEN:
-        if (c.compare(buffer, start) >= 0) {
+        if (rangeComparator.compareToStartKey() >= 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) > 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() > 0 ? RELEASE : TERMINATE;
       case BACKWARD_OPEN_CLOSED:
-        if (c.compare(buffer, start) >= 0) {
+        if (rangeComparator.compareToStartKey() >= 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) >= 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() >= 0 ? RELEASE : TERMINATE;
       default:
         throw new IllegalStateException("Invalid type");
     }
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index ef9b9b35..6d8122d2 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -235,6 +235,8 @@ public interface Lmdb {
 
     void mdb_txn_reset(@In Pointer txn);
 
+    int mdb_cmp(@In Pointer txn, @In Pointer dbi, @In Pointer key1, @In Pointer key2);
+
     Pointer mdb_version(IntByReference major, IntByReference minor, IntByReference patch);
   }
 }
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 87deb3c9..400f2f30 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -17,13 +17,13 @@
 
 import static java.util.Objects.requireNonNull;
 
-import java.util.Objects;
-import java.util.function.Predicate;
-import java.util.stream.Stream;
+import java.util.Collection;
 
 /** Indicates an enum that can provide integers for each of its values. */
 public interface MaskedFlag {
 
+  int EMPTY_MASK = 0;
+
   /**
    * Obtains the integer value for this enum which can be included in a mask.
    *
@@ -32,13 +32,9 @@ public interface MaskedFlag {
   int getMask();
 
   /**
-   * Indicates if the flag must be propagated to the underlying C code of LMDB or not.
-   *
-   * @return the boolean value indicating the propagation
+   * @return The name of the flag.
    */
-  default boolean isPropagatedToLmdb() {
-    return true;
-  }
+  String name();
 
   /**
    * Fetch the integer mask for all presented flags.
@@ -49,67 +45,45 @@ default boolean isPropagatedToLmdb() {
    */
   @SafeVarargs
   static <M extends MaskedFlag> int mask(final M... flags) {
-    return mask(false, flags);
+    if (flags == null || flags.length == 0) {
+      return EMPTY_MASK;
+    } else {
+      int result = EMPTY_MASK;
+      for (MaskedFlag flag : flags) {
+        if (flag == null) {
+          continue;
+        }
+        result |= flag.getMask();
+      }
+      return result;
+    }
   }
 
-  /**
-   * Fetch the integer mask for all presented flags.
-   *
-   * @param <M> flag type
-   * @param flags to mask (null or empty returns zero)
-   * @return the integer mask for use in C
-   */
-  static <M extends MaskedFlag> int mask(final Stream<M> flags) {
-    return mask(false, flags);
+  /** Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s. */
+  static <M extends MaskedFlag> int mask(final int mask1, final int mask2) {
+    return mask1 | mask2;
   }
 
   /**
    * Fetch the integer mask for the presented flags.
    *
    * @param <M> flag type
-   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code
-   *     or all of them
    * @param flags to mask (null or empty returns zero)
    * @return the integer mask for use in C
    */
-  @SafeVarargs
-  static <M extends MaskedFlag> int mask(final boolean onlyPropagatedToLmdb, final M... flags) {
-    if (flags == null || flags.length == 0) {
-      return 0;
-    }
-
-    int result = 0;
-    for (final M flag : flags) {
-      if (flag == null) {
-        continue;
-      }
-      if (!onlyPropagatedToLmdb || flag.isPropagatedToLmdb()) {
+  static <M extends MaskedFlag> int mask(final Collection<M> flags) {
+    if (flags == null || flags.isEmpty()) {
+      return EMPTY_MASK;
+    } else {
+      int result = EMPTY_MASK;
+      for (MaskedFlag flag : flags) {
+        if (flag == null) {
+          continue;
+        }
         result |= flag.getMask();
       }
+      return result;
     }
-    return result;
-  }
-
-  /**
-   * Fetch the integer mask for all presented flags.
-   *
-   * @param <M> flag type
-   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code
-   *     or all of them
-   * @param flags to mask
-   * @return the integer mask for use in C
-   */
-  static <M extends MaskedFlag> int mask(
-      final boolean onlyPropagatedToLmdb, final Stream<M> flags) {
-    final Predicate<M> filter = onlyPropagatedToLmdb ? MaskedFlag::isPropagatedToLmdb : f -> true;
-
-    return flags == null
-        ? 0
-        : flags
-            .filter(Objects::nonNull)
-            .filter(filter)
-            .map(M::getMask)
-            .reduce(0, (f1, f2) -> f1 | f2);
   }
 
   /**
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
new file mode 100644
index 00000000..be34f654
--- /dev/null
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface PutFlagSet extends FlagSet<PutFlags> {
+
+  PutFlagSet EMPTY = PutFlagSetImpl.EMPTY;
+
+  static PutFlagSet empty() {
+    return PutFlagSetImpl.EMPTY;
+  }
+
+  static PutFlagSet of(final PutFlags putFlag) {
+    Objects.requireNonNull(putFlag);
+    return putFlag;
+  }
+
+  static PutFlagSet of(final PutFlags... putFlags) {
+    return builder().withFlags(putFlags).build();
+  }
+
+  static PutFlagSet of(final Collection<PutFlags> putFlags) {
+    return builder().withFlags(putFlags).build();
+  }
+
+  static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, EmptyPutFlagSet::new);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
+
+    public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
+
+    private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
+      super(flags);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
+      implements PutFlagSet {}
+}
diff --git a/src/main/java/org/lmdbjava/PutFlags.java b/src/main/java/org/lmdbjava/PutFlags.java
index 809103de..03fa916a 100644
--- a/src/main/java/org/lmdbjava/PutFlags.java
+++ b/src/main/java/org/lmdbjava/PutFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when performing a "put". */
-public enum PutFlags implements MaskedFlag {
+public enum PutFlags implements MaskedFlag, PutFlagSet {
 
   /** For put: Don't write if the key already exists. */
   MDB_NOOVERWRITE(0x10),
@@ -49,4 +52,29 @@ public enum PutFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<PutFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(PutFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/RangeComparator.java b/src/main/java/org/lmdbjava/RangeComparator.java
new file mode 100644
index 00000000..f2626a59
--- /dev/null
+++ b/src/main/java/org/lmdbjava/RangeComparator.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+/** For comparing a cursor's current key against a {@link KeyRange}'s start/stop key. */
+interface RangeComparator extends AutoCloseable {
+
+  /**
+   * Compare the cursor's current key to the range start key. Equivalent to compareTo(currentKey,
+   * startKey)
+   */
+  int compareToStartKey();
+
+  /**
+   * Compare the cursor's current key to the range stop key. Equivalent to compareTo(currentKey,
+   * stopKey)
+   */
+  int compareToStopKey();
+}
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 05e8ce06..432b47a8 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -20,8 +20,6 @@
 import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.Library.LIB;
 import static org.lmdbjava.Library.RUNTIME;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 import static org.lmdbjava.Txn.State.DONE;
 import static org.lmdbjava.Txn.State.READY;
@@ -44,13 +42,14 @@ public final class Txn<T> implements AutoCloseable {
   private final Pointer ptr;
   private final boolean readOnly;
   private final Env<T> env;
+  private final TxnFlagSet flags;
   private State state;
 
-  Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlags... flags) {
+  Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlagSet flags) {
+    this.flags = flags != null ? flags : TxnFlagSet.EMPTY;
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
-    final int flagsMask = mask(true, flags);
-    this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
+    this.readOnly = this.flags.isSet(MDB_RDONLY_TXN);
     if (env.isReadOnly() && !this.readOnly) {
       throw new EnvIsReadOnly();
     }
@@ -61,7 +60,7 @@ public final class Txn<T> implements AutoCloseable {
     }
     final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
     final Pointer txnParentPtr = parent == null ? null : parent.ptr;
-    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, flagsMask, txnPtr));
+    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, this.flags.getMask(), txnPtr));
     ptr = txnPtr.getPointer(0);
 
     state = READY;
@@ -164,7 +163,7 @@ public void renew() {
   }
 
   /**
-   * Aborts this read-only transaction and resets the transaction handle so it can be reused upon
+   * Aborts this read-only transaction and resets the transaction handle, so it can be reused upon
    * calling {@link #renew()}.
    */
   public void reset() {
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
new file mode 100644
index 00000000..8cfe61f9
--- /dev/null
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface TxnFlagSet extends FlagSet<TxnFlags> {
+
+  TxnFlagSet EMPTY = TxnFlagSetImpl.EMPTY;
+
+  static TxnFlagSet empty() {
+    return TxnFlagSetImpl.EMPTY;
+  }
+
+  static TxnFlagSet of(final TxnFlags putFlag) {
+    Objects.requireNonNull(putFlag);
+    return new SingleTxnFlagSet(putFlag);
+  }
+
+  static TxnFlagSet of(final TxnFlags... TxnFlags) {
+    return builder().withFlags(TxnFlags).build();
+  }
+
+  static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        TxnFlags.class, TxnFlagSetImpl::new, SingleTxnFlagSet::new, () -> TxnFlagSetImpl.EMPTY);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
+
+    static final TxnFlagSet EMPTY = new EmptyTxnFlagSet();
+
+    private TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
+      super(flags);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
+      implements TxnFlagSet {
+
+    SingleTxnFlagSet(final TxnFlags flag) {
+      super(flag);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
+      implements TxnFlagSet {}
+}
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index 26caf6f1..94112957 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -15,8 +15,12 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when creating a {@link Txn}. */
-public enum TxnFlags implements MaskedFlag {
+public enum TxnFlags implements MaskedFlag, TxnFlagSet {
+
   /** Read only. */
   MDB_RDONLY_TXN(0x2_0000);
 
@@ -30,4 +34,29 @@ public enum TxnFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<TxnFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final TxnFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index d5638fe2..332598fe 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -36,9 +36,18 @@
 
 import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.nio.file.Path;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Random;
+import java.util.Set;
 import jnr.ffi.Pointer;
 import jnr.ffi.provider.MemoryManager;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
 import org.lmdbjava.Env.ReadersFullException;
@@ -54,8 +63,13 @@ void buffersMustBeDirect() {
             () -> {
               try (final TempDir tempDir = new TempDir()) {
                 final Path dir = tempDir.createTempDir();
-                try (final Env<ByteBuffer> env = create().setMaxReaders(1).open(dir.toFile())) {
-                  final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(dir)) {
+                  final Dbi<ByteBuffer> db =
+                      env.buildDbi()
+                          .setDbName(DB_1)
+                          .withDefaultComparator()
+                          .setDbiFlags(MDB_CREATE)
+                          .open();
                   final ByteBuffer key = allocate(100);
                   key.putInt(1).flip();
                   final ByteBuffer val = allocate(100);
@@ -132,6 +146,105 @@ void unsafeIsDefault() {
     assertThat(v.getClass().getSimpleName()).startsWith("Unsafe");
   }
 
+  /**
+   * For 100 rounds of 5,000,000 comparisons compareAsIntegerKeys: PT1.600525631S
+   * compareLexicographically: PT3.381935001S
+   */
+  @Test
+  public void comparatorPerformance() {
+    final Random random = new Random();
+    final ByteBuffer buffer1 = ByteBuffer.allocateDirect(Long.BYTES);
+    final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
+    buffer1.limit(Long.BYTES);
+    buffer2.limit(Long.BYTES);
+    final long[] values = random.longs(5_000_000).toArray();
+
+    Instant time = Instant.now();
+    int x = 0;
+    for (int rounds = 0; rounds < 100; rounds++) {
+      for (int i = 1; i < values.length; i++) {
+        buffer1.order(ByteOrder.nativeOrder()).putLong(0, values[i - 1]);
+        buffer2.order(ByteOrder.nativeOrder()).putLong(0, values[i]);
+        final int result =
+            ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
+        x += result;
+      }
+    }
+    System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()));
+
+    time = Instant.now();
+    x = 0;
+    for (int rounds = 0; rounds < 100; rounds++) {
+      for (int i = 1; i < values.length; i++) {
+        buffer1.order(BIG_ENDIAN).putLong(0, values[i - 1]);
+        buffer2.order(BIG_ENDIAN).putLong(0, values[i]);
+        final int result =
+            ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
+        x += result;
+      }
+    }
+    System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()));
+  }
+
+  @Test
+  public void verifyComparators() {
+    final Random random = new Random(203948);
+    final ByteBuffer buffer1native =
+        ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer2native =
+        ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer1be = ByteBuffer.allocateDirect(Long.BYTES).order(BIG_ENDIAN);
+    final ByteBuffer buffer2be = ByteBuffer.allocateDirect(Long.BYTES).order(BIG_ENDIAN);
+    buffer1native.limit(Long.BYTES);
+    buffer2native.limit(Long.BYTES);
+    buffer1be.limit(Long.BYTES);
+    buffer2be.limit(Long.BYTES);
+    final long[] values = random.longs().filter(i -> i >= 0).limit(5_000_000).toArray();
+    //    System.out.println("stats: " + Arrays.stream(values)
+    //        .summaryStatistics()
+    //        .toString());
+
+    final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
+    comparators.put(
+        "compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
+    comparators.put(
+        "compareLexicographically",
+        ByteBufferProxy.AbstractByteBufferProxy::compareLexicographically);
+
+    final LinkedHashMap<String, Integer> results = new LinkedHashMap<>(comparators.size());
+    final Set<Integer> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      final long val1 = values[i - 1];
+      final long val2 = values[i];
+      buffer1native.putLong(0, val1);
+      buffer2native.putLong(0, val2);
+      buffer1be.putLong(0, val1);
+      buffer2be.putLong(0, val2);
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach(
+          (name, comparator) -> {
+            final int result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (name.equals("compareAsIntegerKeys")) {
+              result = comparator.compare(buffer1native, buffer2native);
+            } else {
+              result = comparator.compare(buffer1be, buffer2be);
+            }
+            results.put(name, result);
+            uniqueResults.add(result);
+          });
+
+      if (uniqueResults.size() != 1) {
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+
   private void checkInOut(final BufferProxy<ByteBuffer> v) {
     // allocate a buffer larger than max key size
     final ByteBuffer b = allocateDirect(1_000);
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
new file mode 100644
index 00000000..00c0ce28
--- /dev/null
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -0,0 +1,357 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.lmdbjava;
+
+import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
+import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
+import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
+
+import io.netty.buffer.ByteBuf;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Comparator;
+import java.util.Random;
+import java.util.stream.Stream;
+import org.agrona.DirectBuffer;
+import org.agrona.concurrent.UnsafeBuffer;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/** Tests comparator functions are consistent across buffers. */
+public final class ComparatorIntegerKeyTest {
+
+  static Stream<Arguments> comparatorProvider() {
+    return Stream.of(
+        Arguments.argumentSet("LongRunner", new DirectBufferRunner()),
+        Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
+        Arguments.argumentSet("ByteBufferRunner", new ByteBufferRunner()),
+        Arguments.argumentSet("NettyRunner", new NettyRunner()));
+  }
+
+  private static byte[] buffer(final int... bytes) {
+    final byte[] array = new byte[bytes.length];
+    for (int i = 0; i < bytes.length; i++) {
+      array[i] = (byte) bytes[i];
+    }
+    return array;
+  }
+
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testLong(final ComparatorRunner comparator) {
+
+    assertThat(get(comparator.compare(0L, 0L))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(Long.MAX_VALUE, Long.MAX_VALUE))).isEqualTo(EQUAL_TO);
+
+    assertThat(get(comparator.compare(0L, 1L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0L, Long.MAX_VALUE))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0L, 10L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10L, 100L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10L, 100L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10L, 1000L))).isEqualTo(LESS_THAN);
+
+    assertThat(get(comparator.compare(1L, 0L))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(Long.MAX_VALUE, 0L))).isEqualTo(GREATER_THAN);
+  }
+
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testInt(final ComparatorRunner comparator) {
+
+    assertThat(get(comparator.compare(0, 0))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(Integer.MAX_VALUE, Integer.MAX_VALUE))).isEqualTo(EQUAL_TO);
+
+    assertThat(get(comparator.compare(0, 1))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0, Integer.MAX_VALUE))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0, 10))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10, 100))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10, 100))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10, 1000))).isEqualTo(LESS_THAN);
+
+    assertThat(get(comparator.compare(1, 0))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(Integer.MAX_VALUE, 0))).isEqualTo(GREATER_THAN);
+  }
+
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testRandomLong(final ComparatorRunner runner) {
+    final Random random = new Random(3239480);
+
+    // 5mil random longs to compare
+    final long[] values = random.longs().filter(i -> i >= 0).limit(5_000_000).toArray();
+
+    for (int i = 1; i < values.length; i++) {
+      final long long1 = values[i - 1];
+      final long long2 = values[i];
+      // Make sure the comparator under test gives the same outcome as just comparing two longs
+      final ComparatorTest.ComparatorResult result = get(runner.compare(long1, long2));
+      final ComparatorTest.ComparatorResult expectedResult = get(Long.compare(long1, long2));
+
+      assertThat(result)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch - long1: "
+                      + long1
+                      + ", long2: "
+                      + long2
+                      + ", expected: "
+                      + expectedResult
+                      + ", actual: "
+                      + result)
+          .isEqualTo(expectedResult);
+
+      final ComparatorTest.ComparatorResult result2 = get(runner.compare(long2, long1));
+      final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+
+      assertThat(result)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch for - long2: "
+                      + long2
+                      + ", long1: "
+                      + long1
+                      + ", expected2: "
+                      + expectedResult2
+                      + ", actual2: "
+                      + result2)
+          .isEqualTo(expectedResult);
+    }
+  }
+
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testRandomInt(final ComparatorRunner runner) {
+    final Random random = new Random(3239480);
+
+    // 5mil random ints to compare
+    final int[] values = random.ints().filter(i -> i >= 0).limit(5_000_000).toArray();
+
+    for (int i = 1; i < values.length; i++) {
+      final int int1 = values[i - 1];
+      final int int2 = values[i];
+      // Make sure the comparator under test gives the same outcome as just comparing two ints
+      final ComparatorTest.ComparatorResult result = get(runner.compare(int1, int2));
+      final ComparatorTest.ComparatorResult expectedResult = get(Integer.compare(int1, int2));
+
+      assertThat(result)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch for - int1: "
+                      + int1
+                      + ", int2: "
+                      + int2
+                      + ", expected: "
+                      + expectedResult
+                      + ", actual: "
+                      + result)
+          .isEqualTo(expectedResult);
+
+      final ComparatorTest.ComparatorResult result2 = get(runner.compare(int2, int1));
+      final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+
+      assertThat(result)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch for - int2: "
+                      + int2
+                      + ", int1: "
+                      + int1
+                      + ", expected2: "
+                      + expectedResult2
+                      + ", actual2: "
+                      + result2)
+          .isEqualTo(expectedResult);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /** Tests {@link ByteBufferProxy}. */
+  private static final class ByteBufferRunner implements ComparatorRunner {
+
+    private static final Comparator<ByteBuffer> COMPARATOR =
+        PROXY_OPTIMAL.getComparator(DbiFlags.MDB_INTEGERKEY);
+
+    @Override
+    public int compare(long long1, long long2) {
+      // Convert arrays to buffers that are larger than the array, with
+      // limit set at the array length. One buffer bigger than the other.
+      ByteBuffer o1b = longToBuffer(long1, Long.BYTES * 3);
+      ByteBuffer o2b = longToBuffer(long2, Long.BYTES * 2);
+      final int result = COMPARATOR.compare(o1b, o2b);
+
+      // Now swap which buffer is bigger
+      o1b = longToBuffer(long1, Long.BYTES * 2);
+      o2b = longToBuffer(long2, Long.BYTES * 3);
+      final int result2 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result2).isEqualTo(result);
+
+      // Now try with buffers sized to the array.
+      o1b = longToBuffer(long1, Long.BYTES);
+      o2b = longToBuffer(long2, Long.BYTES);
+      final int result3 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result3).isEqualTo(result);
+      return result;
+    }
+
+    @Override
+    public int compare(int int1, int int2) {
+      // Convert arrays to buffers that are larger than the array, with
+      // limit set at the array length. One buffer bigger than the other.
+      ByteBuffer o1b = intToBuffer(int1, Integer.BYTES * 3);
+      ByteBuffer o2b = intToBuffer(int2, Integer.BYTES * 2);
+      final int result = COMPARATOR.compare(o1b, o2b);
+
+      // Now swap which buffer is bigger
+      o1b = intToBuffer(int1, Integer.BYTES * 2);
+      o2b = intToBuffer(int2, Integer.BYTES * 3);
+      final int result2 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result2).isEqualTo(result);
+
+      // Now try with buffers sized to the array.
+      o1b = intToBuffer(int1, Integer.BYTES);
+      o2b = intToBuffer(int2, Integer.BYTES);
+      final int result3 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result3).isEqualTo(result);
+      return result;
+    }
+
+    private ByteBuffer longToBuffer(final long val, final int bufferCapacity) {
+      final ByteBuffer byteBuffer = ByteBuffer.allocate(bufferCapacity);
+      byteBuffer.order(ByteOrder.nativeOrder());
+      byteBuffer.putLong(0, val);
+      byteBuffer.limit(Long.BYTES);
+      byteBuffer.position(0);
+      return byteBuffer;
+    }
+
+    private ByteBuffer intToBuffer(final int val, final int bufferCapacity) {
+      final ByteBuffer byteBuffer = ByteBuffer.allocate(bufferCapacity);
+      byteBuffer.order(ByteOrder.nativeOrder());
+      byteBuffer.putInt(0, val);
+      byteBuffer.limit(Integer.BYTES);
+      byteBuffer.position(0);
+      return byteBuffer;
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /** Tests {@link DirectBufferProxy}. */
+  private static final class DirectBufferRunner implements ComparatorRunner {
+    private static final Comparator<DirectBuffer> COMPARATOR =
+        PROXY_DB.getComparator(DbiFlags.MDB_INTEGERKEY);
+
+    @Override
+    public int compare(long long1, long long2) {
+      final UnsafeBuffer o1b = new UnsafeBuffer(new byte[Long.BYTES]);
+      final UnsafeBuffer o2b = new UnsafeBuffer(new byte[Long.BYTES]);
+      o1b.putLong(0, long1, ByteOrder.nativeOrder());
+      o2b.putLong(0, long2, ByteOrder.nativeOrder());
+      return COMPARATOR.compare(o1b, o2b);
+    }
+
+    @Override
+    public int compare(int int1, int int2) {
+      final UnsafeBuffer o1b = new UnsafeBuffer(new byte[Integer.BYTES]);
+      final UnsafeBuffer o2b = new UnsafeBuffer(new byte[Integer.BYTES]);
+      o1b.putInt(0, int1, ByteOrder.nativeOrder());
+      o2b.putInt(0, int2, ByteOrder.nativeOrder());
+      return COMPARATOR.compare(o1b, o2b);
+    }
+  }
+
+  /** Tests {@link ByteBufProxy}. */
+  private static final class NettyRunner implements ComparatorRunner {
+
+    private static final Comparator<ByteBuf> COMPARATOR =
+        PROXY_NETTY.getComparator(DbiFlags.MDB_INTEGERKEY);
+
+    @Override
+    public int compare(long long1, long long2) {
+      final ByteBuf o1b = DEFAULT.directBuffer(Long.BYTES);
+      final ByteBuf o2b = DEFAULT.directBuffer(Long.BYTES);
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        o1b.writeLongLE(long1);
+        o2b.writeLongLE(long2);
+      } else {
+        o1b.writeLong(long1);
+        o2b.writeLong(long2);
+      }
+      o1b.resetReaderIndex();
+      o2b.resetReaderIndex();
+      final int res = COMPARATOR.compare(o1b, o2b);
+      o1b.release();
+      o2b.release();
+      return res;
+    }
+
+    @Override
+    public int compare(int int1, int int2) {
+      final ByteBuf o1b = DEFAULT.directBuffer(Integer.BYTES);
+      final ByteBuf o2b = DEFAULT.directBuffer(Integer.BYTES);
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        o1b.writeIntLE(int1);
+        o2b.writeIntLE(int2);
+      } else {
+        o1b.writeInt(int1);
+        o2b.writeInt(int2);
+      }
+      o1b.resetReaderIndex();
+      o2b.resetReaderIndex();
+      final int res = COMPARATOR.compare(o1b, o2b);
+      o1b.release();
+      o2b.release();
+      return res;
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
+  private interface ComparatorRunner {
+
+    /**
+     * Write the two longs to a buffer using native order and compare the resulting buffers.
+     *
+     * @param long1 lhs value
+     * @param long2 rhs value
+     * @return as per {@link Comparable}
+     */
+    int compare(final long long1, final long long2);
+
+    /**
+     * Write the two int to a buffer using native order and compare the resulting buffers.
+     *
+     * @param int1 lhs value
+     * @param int2 rhs value
+     * @return as per {@link Comparable}
+     */
+    int compare(final int int1, final int int2);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 2fabb3da..f255ec2a 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -150,7 +150,7 @@ private static final class UnsignedByteArrayRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final Comparator<byte[]> c = PROXY_BA.getUnsignedComparator();
+      final Comparator<byte[]> c = PROXY_BA.getComparator();
       return c.compare(o1, o2);
     }
   }
@@ -269,6 +269,16 @@ static ComparatorResult get(final int comparatorResult) {
       }
       return comparatorResult < 0 ? LESS_THAN : GREATER_THAN;
     }
+
+    ComparatorResult opposite() {
+      if (this == LESS_THAN) {
+        return GREATER_THAN;
+      } else if (this == GREATER_THAN) {
+        return LESS_THAN;
+      } else {
+        return EQUAL_TO;
+      }
+    }
   }
 
   /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
new file mode 100644
index 00000000..922554d7
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Collections;
+import java.util.HashSet;
+import org.junit.jupiter.api.Test;
+
+public class CopyFlagSetTest {
+
+  @Test
+  public void testEmpty() {
+    final CopyFlagSet copyFlagSet = CopyFlagSet.empty();
+    assertThat(copyFlagSet.getMask()).isEqualTo(0);
+    assertThat(copyFlagSet.size()).isEqualTo(0);
+    assertThat(copyFlagSet.isEmpty()).isEqualTo(true);
+    assertThat(copyFlagSet.isSet(CopyFlags.MDB_CP_COMPACT)).isEqualTo(false);
+    final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder().build();
+    assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
+    assertThat(copyFlagSet).isNotEqualTo(CopyFlagSet.of(CopyFlags.MDB_CP_COMPACT));
+    assertThat(copyFlagSet)
+        .isNotEqualTo(CopyFlagSet.builder().setFlag(CopyFlags.MDB_CP_COMPACT).build());
+  }
+
+  @Test
+  public void testOf() {
+    final CopyFlags copyFlag = CopyFlags.MDB_CP_COMPACT;
+    final CopyFlagSet copyFlagSet = CopyFlagSet.of(copyFlag);
+    assertThat(copyFlagSet.getMask()).isEqualTo(MaskedFlag.mask(copyFlag));
+    assertThat(copyFlagSet.size()).isEqualTo(1);
+    for (CopyFlags flag : copyFlagSet) {
+      assertThat(copyFlagSet.isSet(flag)).isEqualTo(true);
+    }
+
+    final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder().setFlag(copyFlag).build();
+    assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
+  }
+
+  @Test
+  public void testBuilder() {
+    final CopyFlags copyFlag1 = CopyFlags.MDB_CP_COMPACT;
+    final CopyFlagSet copyFlagSet = CopyFlagSet.builder().setFlag(copyFlag1).build();
+    assertThat(copyFlagSet.getMask()).isEqualTo(MaskedFlag.mask(copyFlag1));
+    assertThat(copyFlagSet.size()).isEqualTo(1);
+    assertThat(copyFlagSet.isSet(CopyFlags.MDB_CP_COMPACT)).isEqualTo(true);
+    for (CopyFlags flag : copyFlagSet) {
+      assertThat(copyFlagSet.isSet(flag)).isEqualTo(true);
+    }
+    final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder().withFlags(copyFlag1).build();
+    final CopyFlagSet copyFlagSet3 =
+        CopyFlagSet.builder()
+            .withFlags(new HashSet<>(Collections.singletonList(copyFlag1)))
+            .build();
+    assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
+    assertThat(copyFlagSet).isEqualTo(copyFlagSet3);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
new file mode 100644
index 00000000..5765ac52
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -0,0 +1,615 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERDUP;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.KeyRange.all;
+import static org.lmdbjava.KeyRange.allBackward;
+import static org.lmdbjava.KeyRange.atLeast;
+import static org.lmdbjava.KeyRange.atLeastBackward;
+import static org.lmdbjava.KeyRange.atMost;
+import static org.lmdbjava.KeyRange.atMostBackward;
+import static org.lmdbjava.KeyRange.closed;
+import static org.lmdbjava.KeyRange.closedBackward;
+import static org.lmdbjava.KeyRange.closedOpen;
+import static org.lmdbjava.KeyRange.closedOpenBackward;
+import static org.lmdbjava.KeyRange.greaterThan;
+import static org.lmdbjava.KeyRange.greaterThanBackward;
+import static org.lmdbjava.KeyRange.lessThan;
+import static org.lmdbjava.KeyRange.lessThanBackward;
+import static org.lmdbjava.KeyRange.open;
+import static org.lmdbjava.KeyRange.openBackward;
+import static org.lmdbjava.KeyRange.openClosed;
+import static org.lmdbjava.KeyRange.openClosedBackward;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.DB_2;
+import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.DB_4;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.bbNative;
+import static org.lmdbjava.TestUtils.getNativeInt;
+import static org.lmdbjava.TestUtils.getNativeIntOrLong;
+
+import com.google.common.primitives.UnsignedBytes;
+import java.nio.ByteBuffer;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.Parameter;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import org.junit.jupiter.params.support.ParameterDeclarations;
+import org.lmdbjava.CursorIterable.KeyVal;
+
+/**
+ * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that comparators work
+ * with native order integer keys.
+ */
+@Disabled // Waiting for the merge of stroomdev66's cursor tests
+@ParameterizedClass(name = "{index}: dbi: {0}")
+@ArgumentsSource(CursorIterableTest.MyArgumentProvider.class)
+public final class CursorIterableIntegerDupTest {
+
+  private static final DbiFlagSet DBI_FLAGS =
+      DbiFlagSet.of(MDB_CREATE, MDB_INTEGERDUP, MDB_DUPSORT);
+  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
+  private static final List<Map.Entry<Integer, Integer>> INPUT_DATA;
+
+  static {
+    // 2 => 21
+    // 2 => 22
+    // 3 => 31
+    // ...
+    // 9 => 92
+    INPUT_DATA = new ArrayList<>();
+    for (int i = 2; i <= 9; i++) {
+      final int val1 = (i * 10) + 1;
+      final int val2 = (i * 10) + 2;
+      INPUT_DATA.add(new AbstractMap.SimpleEntry<>(i, val1));
+      INPUT_DATA.add(new AbstractMap.SimpleEntry<>(i, val2));
+    }
+  }
+
+  private TempDir tempDir;
+  private Env<ByteBuffer> env;
+  private Deque<Map.Entry<Integer, Integer>> expectedEntriesDeque;
+
+  @Parameter public DbiFactory dbiFactory;
+
+  @BeforeEach
+  public void before() {
+    tempDir = new TempDir();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .setFilePermissions(POSIX_MODE)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(tempDir.createTempFile());
+
+    populateExpectedEntriesDeque();
+  }
+
+  @AfterEach
+  public void after() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  @Test
+  public void allBackwardTest() {
+    verify(allBackward(), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void allTest() {
+    verify(all(), 2, 4, 6, 8);
+  }
+
+  @Test
+  public void atLeastBackwardTest() {
+    verify(atLeastBackward(bbNative(5)), 4, 2);
+    verify(atLeastBackward(bbNative(6)), 6, 4, 2);
+    verify(atLeastBackward(bbNative(9)), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void atLeastTest() {
+    verify(atLeast(bbNative(5)), 6, 8);
+    verify(atLeast(bbNative(6)), 6, 8);
+  }
+
+  @Test
+  public void atMostBackwardTest() {
+    verify(atMostBackward(bbNative(5)), 8, 6);
+    verify(atMostBackward(bbNative(6)), 8, 6);
+  }
+
+  @Test
+  public void atMostTest() {
+    verify(atMost(bbNative(5)), 2, 4);
+    verify(atMost(bbNative(6)), 2, 4, 6);
+  }
+
+  private void populateExpectedEntriesDeque() {
+    expectedEntriesDeque = new LinkedList<>();
+    expectedEntriesDeque.addAll(INPUT_DATA);
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      for (Map.Entry<Integer, Integer> entry : INPUT_DATA) {
+        c.put(bbNative(entry.getKey()), bb(entry.getValue()));
+      }
+      txn.commit();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnRead();
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
+
+      //      for (final KeyVal<ByteBuffer> kv : c) {
+      //        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
+      //        System.out.print(", ");
+      //      }
+      //      System.out.println();
+    }
+  }
+
+  private int[] rangeInc(final int fromInc, final int toInc) {
+    int idx = 0;
+    if (fromInc <= toInc) {
+      // Forwards
+      final int[] arr = new int[toInc - fromInc + 1];
+      for (int i = fromInc; i <= toInc; i++) {
+        arr[idx++] = i;
+      }
+      return arr;
+    } else {
+      // Backwards
+      final int[] arr = new int[fromInc - toInc + 1];
+      for (int i = fromInc; i >= toInc; i--) {
+        arr[idx++] = i;
+      }
+      return arr;
+    }
+  }
+
+  @Test
+  public void closedBackwardTest() {
+    verify(closedBackward(bbNative(7), bbNative(3)), rangeInc(7, 3));
+    verify(closedBackward(bbNative(6), bbNative(2)), rangeInc(6, 2));
+    verify(closedBackward(bbNative(9), bbNative(3)), rangeInc(9, 3));
+  }
+
+  @Test
+  public void closedOpenBackwardTest() {
+    verify(closedOpenBackward(bbNative(8), bbNative(3)), rangeInc(8, 4));
+    verify(closedOpenBackward(bbNative(7), bbNative(2)), rangeInc(7, 3));
+    verify(closedOpenBackward(bbNative(9), bbNative(3)), rangeInc(9, 4));
+  }
+
+  @Test
+  public void closedOpenTest() {
+    verify(closedOpen(bbNative(3), bbNative(8)), rangeInc(3, 7));
+    verify(closedOpen(bbNative(2), bbNative(6)), rangeInc(2, 5));
+  }
+
+  @Test
+  public void closedTest() {
+    verify(closed(bbNative(3), bbNative(7)), rangeInc(3, 7));
+    verify(closed(bbNative(2), bbNative(6)), rangeInc(2, 6));
+    verify(closed(bbNative(1), bbNative(7)), rangeInc(2, 7));
+  }
+
+  @Test
+  public void greaterThanBackwardTest() {
+    verify(greaterThanBackward(bbNative(6)), rangeInc(5, 2));
+    verify(greaterThanBackward(bbNative(7)), rangeInc(6, 2));
+    verify(greaterThanBackward(bbNative(9)), rangeInc(8, 2));
+  }
+
+  @Test
+  public void greaterThanTest() {
+    verify(greaterThan(bbNative(4)), rangeInc(5, 9));
+    verify(greaterThan(bbNative(3)), rangeInc(4, 9));
+  }
+
+  public void iterableOnlyReturnedOnce() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
+  }
+
+  @Test
+  public void iterate() {
+    populateExpectedEntriesDeque();
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+
+      for (final KeyVal<ByteBuffer> kv : c) {
+        final Map.Entry<Integer, Integer> entry = expectedEntriesDeque.pollFirst();
+        //        System.out.println(entry.getKey() + " => " + entry.getValue());
+        assertThat(getNativeInt(kv.key())).isEqualTo(entry.getKey());
+        assertThat(kv.val().getInt()).isEqualTo(entry.getValue());
+      }
+    }
+  }
+
+  public void iteratorOnlyReturnedOnce() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
+  }
+
+  @Test
+  public void lessThanBackwardTest() {
+    verify(lessThanBackward(bbNative(5)), 8, 6);
+    verify(lessThanBackward(bbNative(2)), 8, 6, 4);
+  }
+
+  @Test
+  public void lessThanTest() {
+    verify(lessThan(bbNative(5)), 2, 4);
+    verify(lessThan(bbNative(8)), 2, 4, 6);
+  }
+
+  public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              populateExpectedEntriesDeque();
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+                while (i.hasNext()) {
+                  final KeyVal<ByteBuffer> kv = i.next();
+                  assertThat(getNativeInt(kv.key()))
+                      .isEqualTo(expectedEntriesDeque.pollFirst().getKey());
+                  assertThat(kv.val().getInt())
+                      .isEqualTo(expectedEntriesDeque.pollFirst().getValue());
+                }
+                assertThat(i.hasNext()).isEqualTo(false);
+                i.next();
+              }
+            })
+        .isInstanceOf(NoSuchElementException.class);
+  }
+
+  @Test
+  public void openBackwardTest() {
+    verify(openBackward(bbNative(7), bbNative(2)), 6, 4);
+    verify(openBackward(bbNative(8), bbNative(1)), 6, 4, 2);
+    verify(openBackward(bbNative(9), bbNative(4)), 8, 6);
+  }
+
+  @Test
+  public void openClosedBackwardTest() {
+    verify(openClosedBackward(bbNative(7), bbNative(2)), 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), 6, 4);
+    verify(openClosedBackward(bbNative(9), bbNative(4)), 8, 6, 4);
+  }
+
+  @Test
+  public void openClosedBackwardTestWithGuava() {
+    final Comparator<byte[]> guava = UnsignedBytes.lexicographicalComparator();
+    final Comparator<ByteBuffer> comparator =
+        (bb1, bb2) -> {
+          final byte[] array1 = new byte[bb1.remaining()];
+          final byte[] array2 = new byte[bb2.remaining()];
+          bb1.mark();
+          bb2.mark();
+          bb1.get(array1);
+          bb2.get(array2);
+          bb1.reset();
+          bb2.reset();
+          return guava.compare(array1, array2);
+        };
+    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    populateDatabase(guavaDbi);
+    verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
+  }
+
+  @Test
+  public void openClosedTest() {
+    verify(openClosed(bbNative(3), bbNative(8)), 4, 6, 8);
+    verify(openClosed(bbNative(2), bbNative(6)), 4, 6);
+  }
+
+  @Test
+  public void openTest() {
+    verify(open(bbNative(3), bbNative(7)), 4, 6);
+    verify(open(bbNative(2), bbNative(8)), 4, 6);
+  }
+
+  @Test
+  public void removeOddElements() {
+    final Dbi<ByteBuffer> db = getDb();
+    verify(db, all(), 2, 4, 6, 8);
+    int idx = -1;
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+        while (c.hasNext()) {
+          c.next();
+          idx++;
+          if (idx % 2 == 0) {
+            c.remove();
+          }
+        }
+      }
+      txn.commit();
+    }
+    verify(db, all(), 4, 8);
+  }
+
+  public void nextWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.next();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  public void removeWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+                  final KeyVal<ByteBuffer> keyVal = c.next();
+                  assertThat(keyVal).isNotNull();
+                  env.close();
+                  c.remove();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  public void hasNextWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.hasNext();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  public void forEachRemainingWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.forEachRemaining(keyVal -> {});
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  private void verify(final KeyRange<ByteBuffer> range, final int... expectedKeys) {
+    // Verify using all comparator types
+    final Dbi<ByteBuffer> db = getDb();
+    verify(range, db, expectedKeys);
+  }
+
+  private void verify(
+      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expectedKeys) {
+    verify(range, dbi, expectedKeys);
+  }
+
+  private void verify(
+      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expectedKeys) {
+    final boolean isForward = range.getType().isDirectionForward();
+
+    final List<Integer> expectedValues =
+        Arrays.stream(expectedKeys)
+            .boxed()
+            .flatMap(
+                key -> {
+                  final int base = key * 10;
+                  return isForward ? Stream.of(base + 1, base + 2) : Stream.of(base + 2, base + 1);
+                })
+            .collect(Collectors.toList());
+
+    final List<Integer> results = new ArrayList<>();
+    //    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
+
+    try (Txn<ByteBuffer> txn = env.txnRead();
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
+        final int key = getNativeInt(kv.key());
+        final int val = kv.val().getInt();
+        //        System.out.println(key + " => " + val);
+        results.add(val);
+        assertThat(val)
+            .satisfiesAnyOf(
+                v -> assertThat(v).isEqualTo((key * 10) + 1),
+                v -> assertThat(v).isEqualTo((key * 10) + 2));
+      }
+    }
+
+    assertThat(results).hasSize(expectedValues.size());
+    for (int idx = 0; idx < results.size(); idx++) {
+      assertThat(results.get(idx)).isEqualTo(expectedValues.get(idx));
+    }
+  }
+
+  private String rangeToString(final KeyRange<ByteBuffer> range) {
+    final ByteBuffer start = range.getStart();
+    final ByteBuffer stop = range.getStop();
+    return range.getType()
+        + " start: "
+        + (start != null ? getNativeInt(start) : "")
+        + " stop: "
+        + (stop != null ? getNativeInt(stop) : "");
+  }
+
+  private Dbi<ByteBuffer> getDb() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+    populateDatabase(dbi);
+    return dbi;
+  }
+
+  // --------------------------------------------------------------------------------
+
+  private static class DbiFactory {
+    private final String name;
+    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
+
+    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
+      this.name = name;
+      this.factory = factory;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  static class MyArgumentProvider implements ArgumentsProvider {
+
+    @Override
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
+      final DbiFactory defaultComparatorDb =
+          new DbiFactory(
+              "defaultComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory nativeComparatorDb =
+          new DbiFactory(
+              "nativeComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_2)
+                      .withNativeComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory callbackComparatorDb =
+          new DbiFactory(
+              "callbackComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_3)
+                      .withCallbackComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory iteratorComparatorDb =
+          new DbiFactory(
+              "iteratorComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_4)
+                      .withIteratorComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      return Stream.of(
+              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
+          .map(Arguments::of);
+    }
+
+    private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSet) {
+      final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
+      return (o1, o2) -> {
+        if (o1.remaining() != o2.remaining()) {
+          // Make sure LMDB is always giving us consistent key lengths.
+          Assertions.fail(
+              "o1: "
+                  + o1
+                  + " "
+                  + getNativeIntOrLong(o1)
+                  + ", o2: "
+                  + o2
+                  + " "
+                  + getNativeIntOrLong(o2));
+        }
+        return baseComparator.compare(o1, o2);
+      };
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
new file mode 100644
index 00000000..e8f039cf
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -0,0 +1,662 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.KeyRange.all;
+import static org.lmdbjava.KeyRange.allBackward;
+import static org.lmdbjava.KeyRange.atLeast;
+import static org.lmdbjava.KeyRange.atLeastBackward;
+import static org.lmdbjava.KeyRange.atMost;
+import static org.lmdbjava.KeyRange.atMostBackward;
+import static org.lmdbjava.KeyRange.closed;
+import static org.lmdbjava.KeyRange.closedBackward;
+import static org.lmdbjava.KeyRange.closedOpen;
+import static org.lmdbjava.KeyRange.closedOpenBackward;
+import static org.lmdbjava.KeyRange.greaterThan;
+import static org.lmdbjava.KeyRange.greaterThanBackward;
+import static org.lmdbjava.KeyRange.lessThan;
+import static org.lmdbjava.KeyRange.lessThanBackward;
+import static org.lmdbjava.KeyRange.open;
+import static org.lmdbjava.KeyRange.openBackward;
+import static org.lmdbjava.KeyRange.openClosed;
+import static org.lmdbjava.KeyRange.openClosedBackward;
+import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.DB_2;
+import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.DB_4;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.bbNative;
+import static org.lmdbjava.TestUtils.getNativeInt;
+import static org.lmdbjava.TestUtils.getNativeIntOrLong;
+import static org.lmdbjava.TestUtils.getNativeLong;
+import static org.lmdbjava.TestUtils.getString;
+
+import com.google.common.primitives.UnsignedBytes;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.Parameter;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import org.junit.jupiter.params.support.ParameterDeclarations;
+import org.lmdbjava.CursorIterable.KeyVal;
+
+/**
+ * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that comparators work
+ * with native order integer keys.
+ */
+@ParameterizedClass(name = "{index}: dbi: {0}")
+@ArgumentsSource(CursorIterableIntegerKeyTest.MyArgumentProvider.class)
+public final class CursorIterableIntegerKeyTest {
+
+  private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
+  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
+
+  private TempDir tempDir;
+  private Env<ByteBuffer> env;
+  private Deque<Integer> list;
+
+  @Parameter public DbiFactory dbiFactory;
+
+  @BeforeEach
+  public void before() {
+    tempDir = new TempDir();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        Env.create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(tempDir.createTempFile());
+
+    populateTestDataList();
+  }
+
+  @AfterEach
+  public void after() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  @Test
+  public void testNumericOrderLong() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      long i = 1;
+      while (true) {
+        //        System.out.println("putting " + i);
+        c.put(bbNative(i), bb(i + "-long"));
+        final long i2 = i * 10;
+        if (i2 < i) {
+          // Overflowed
+          break;
+        }
+        i = i2;
+      }
+      txn.commit();
+    }
+
+    final List<Map.Entry<Long, String>> entries = new ArrayList<>();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> iterable = dbi.iterate(txn)) {
+        for (KeyVal<ByteBuffer> keyVal : iterable) {
+          assertThat(keyVal.key().remaining()).isEqualTo(Long.BYTES);
+          final String val = getString(keyVal.val());
+          final long key = getNativeLong(keyVal.key());
+          entries.add(new AbstractMap.SimpleEntry<>(key, val));
+          //          System.out.println(val);
+        }
+      }
+    }
+
+    final List<Long> dbKeys = entries.stream().map(Map.Entry::getKey).collect(Collectors.toList());
+    final List<Long> dbKeysSorted =
+        entries.stream().map(Map.Entry::getKey).sorted().collect(Collectors.toList());
+    for (int i = 0; i < dbKeys.size(); i++) {
+      final long dbKey1 = dbKeys.get(i);
+      final long dbKey2 = dbKeysSorted.get(i);
+      assertThat(dbKey1).isEqualTo(dbKey2);
+    }
+  }
+
+  @Test
+  public void testNumericOrderInt() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      int i = 1;
+      while (true) {
+        //        System.out.println("putting " + i);
+        c.put(bbNative(i), bb(i + "-int"));
+        final int i2 = i * 10;
+        if (i2 < i) {
+          // Overflowed
+          break;
+        }
+        i = i2;
+      }
+      txn.commit();
+    }
+
+    final List<Map.Entry<Integer, String>> entries = new ArrayList<>();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> iterable = dbi.iterate(txn)) {
+        for (KeyVal<ByteBuffer> keyVal : iterable) {
+          assertThat(keyVal.key().remaining()).isEqualTo(Integer.BYTES);
+          final String val = getString(keyVal.val());
+          final int key = TestUtils.getNativeInt(keyVal.key());
+          entries.add(new AbstractMap.SimpleEntry<>(key, val));
+          //          System.out.println(val);
+        }
+      }
+    }
+
+    final List<Integer> dbKeys =
+        entries.stream().map(Map.Entry::getKey).collect(Collectors.toList());
+    final List<Integer> dbKeysSorted =
+        entries.stream().map(Map.Entry::getKey).sorted().collect(Collectors.toList());
+    for (int i = 0; i < dbKeys.size(); i++) {
+      final long dbKey1 = dbKeys.get(i);
+      final long dbKey2 = dbKeysSorted.get(i);
+      assertThat(dbKey1).isEqualTo(dbKey2);
+    }
+  }
+
+  @Test
+  public void testIntegerKeyKeySize() {
+    final Dbi<ByteBuffer> db = dbiFactory.factory.apply(env);
+    long maxIntAsLong = Integer.MAX_VALUE;
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      //      System.out.println("Flags: " + db.listFlags(txn));
+      int val = 0;
+      db.put(txn, bbNative(0L), bb("val_" + ++val));
+      db.put(txn, bbNative(10L), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 1_111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 1_111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(Long.MAX_VALUE), bb("val_" + ++val));
+      txn.commit();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> iterable = db.iterate(txn)) {
+        for (KeyVal<ByteBuffer> keyVal : iterable) {
+          final String val = getString(keyVal.val());
+          final long key = getNativeLong(keyVal.key());
+          final int remaining = keyVal.key().remaining();
+          //          System.out.println("key: " + key + ", val: " + val + ", remaining: " +
+          // remaining);
+        }
+      }
+    }
+  }
+
+  @Test
+  public void allBackwardTest() {
+    verify(allBackward(), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void allTest() {
+    verify(all(), 2, 4, 6, 8);
+  }
+
+  @Test
+  public void atLeastBackwardTest() {
+    verify(atLeastBackward(bbNative(5)), 4, 2);
+    verify(atLeastBackward(bbNative(6)), 6, 4, 2);
+    verify(atLeastBackward(bbNative(9)), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void atLeastTest() {
+    verify(atLeast(bbNative(5)), 6, 8);
+    verify(atLeast(bbNative(6)), 6, 8);
+  }
+
+  @Test
+  public void atMostBackwardTest() {
+    verify(atMostBackward(bbNative(5)), 8, 6);
+    verify(atMostBackward(bbNative(6)), 8, 6);
+  }
+
+  @Test
+  public void atMostTest() {
+    verify(atMost(bbNative(5)), 2, 4);
+    verify(atMost(bbNative(6)), 2, 4, 6);
+  }
+
+  private void populateTestDataList() {
+    list = new LinkedList<>();
+    list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      c.put(bbNative(2), bb(3), MDB_NOOVERWRITE);
+      c.put(bbNative(4), bb(5));
+      c.put(bbNative(6), bb(7));
+      c.put(bbNative(8), bb(9));
+      txn.commit();
+    }
+  }
+
+  @Test
+  public void closedBackwardTest() {
+    verify(closedBackward(bbNative(7), bbNative(3)), 6, 4);
+    verify(closedBackward(bbNative(6), bbNative(2)), 6, 4, 2);
+    verify(closedBackward(bbNative(9), bbNative(3)), 8, 6, 4);
+  }
+
+  @Test
+  public void closedOpenBackwardTest() {
+    verify(closedOpenBackward(bbNative(8), bbNative(3)), 8, 6, 4);
+    verify(closedOpenBackward(bbNative(7), bbNative(2)), 6, 4);
+    verify(closedOpenBackward(bbNative(9), bbNative(3)), 8, 6, 4);
+  }
+
+  @Test
+  public void closedOpenTest() {
+    verify(closedOpen(bbNative(3), bbNative(8)), 4, 6);
+    verify(closedOpen(bbNative(2), bbNative(6)), 2, 4);
+  }
+
+  @Test
+  public void closedTest() {
+    verify(closed(bbNative(3), bbNative(7)), 4, 6);
+    verify(closed(bbNative(2), bbNative(6)), 2, 4, 6);
+    verify(closed(bbNative(1), bbNative(7)), 2, 4, 6);
+  }
+
+  @Test
+  public void greaterThanBackwardTest() {
+    verify(greaterThanBackward(bbNative(6)), 4, 2);
+    verify(greaterThanBackward(bbNative(7)), 6, 4, 2);
+    verify(greaterThanBackward(bbNative(9)), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void greaterThanTest() {
+    verify(greaterThan(bbNative(4)), 6, 8);
+    verify(greaterThan(bbNative(3)), 4, 6, 8);
+  }
+
+  public void iterableOnlyReturnedOnce() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
+  }
+
+  @Test
+  public void iterate() {
+    populateTestDataList();
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+
+      for (final KeyVal<ByteBuffer> kv : c) {
+        assertThat(getNativeInt(kv.key())).isEqualTo(list.pollFirst());
+        assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
+      }
+    }
+  }
+
+  public void iteratorOnlyReturnedOnce() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
+  }
+
+  @Test
+  public void lessThanBackwardTest() {
+    verify(lessThanBackward(bbNative(5)), 8, 6);
+    verify(lessThanBackward(bbNative(2)), 8, 6, 4);
+  }
+
+  @Test
+  public void lessThanTest() {
+    verify(lessThan(bbNative(5)), 2, 4);
+    verify(lessThan(bbNative(8)), 2, 4, 6);
+  }
+
+  public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              populateTestDataList();
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+                while (i.hasNext()) {
+                  final KeyVal<ByteBuffer> kv = i.next();
+                  assertThat(getNativeInt(kv.key())).isEqualTo(list.pollFirst());
+                  assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
+                }
+                assertThat(i.hasNext()).isEqualTo(false);
+                i.next();
+              }
+            })
+        .isInstanceOf(NoSuchElementException.class);
+  }
+
+  @Test
+  public void openBackwardTest() {
+    verify(openBackward(bbNative(7), bbNative(2)), 6, 4);
+    verify(openBackward(bbNative(8), bbNative(1)), 6, 4, 2);
+    verify(openBackward(bbNative(9), bbNative(4)), 8, 6);
+  }
+
+  @Test
+  public void openClosedBackwardTest() {
+    verify(openClosedBackward(bbNative(7), bbNative(2)), 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), 6, 4);
+    verify(openClosedBackward(bbNative(9), bbNative(4)), 8, 6, 4);
+  }
+
+  @Test
+  public void openClosedBackwardTestWithGuava() {
+    final Comparator<byte[]> guava = UnsignedBytes.lexicographicalComparator();
+    final Comparator<ByteBuffer> comparator =
+        (bb1, bb2) -> {
+          final byte[] array1 = new byte[bb1.remaining()];
+          final byte[] array2 = new byte[bb2.remaining()];
+          bb1.mark();
+          bb2.mark();
+          bb1.get(array1);
+          bb2.get(array2);
+          bb1.reset();
+          bb2.reset();
+          return guava.compare(array1, array2);
+        };
+    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    populateDatabase(guavaDbi);
+    verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
+  }
+
+  @Test
+  public void openClosedTest() {
+    verify(openClosed(bbNative(3), bbNative(8)), 4, 6, 8);
+    verify(openClosed(bbNative(2), bbNative(6)), 4, 6);
+  }
+
+  @Test
+  public void openTest() {
+    verify(open(bbNative(3), bbNative(7)), 4, 6);
+    verify(open(bbNative(2), bbNative(8)), 4, 6);
+  }
+
+  @Test
+  public void removeOddElements() {
+    final Dbi<ByteBuffer> db = getDb();
+    verify(db, all(), 2, 4, 6, 8);
+    int idx = -1;
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+        while (c.hasNext()) {
+          c.next();
+          idx++;
+          if (idx % 2 == 0) {
+            c.remove();
+          }
+        }
+      }
+      txn.commit();
+    }
+    verify(db, all(), 4, 8);
+  }
+
+  public void nextWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.next();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  public void removeWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  final KeyVal<ByteBuffer> keyVal = c.next();
+                  assertThat(keyVal).isNotNull();
+
+                  env.close();
+                  c.remove();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  public void hasNextWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.hasNext();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  public void forEachRemainingWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.forEachRemaining(keyVal -> {});
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
+    // Verify using all comparator types
+    final Dbi<ByteBuffer> db = getDb();
+    verify(range, db, expected);
+  }
+
+  private void verify(
+      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expected) {
+    verify(range, dbi, expected);
+  }
+
+  private void verify(
+      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
+
+    final List<Integer> results = new ArrayList<>();
+
+    try (Txn<ByteBuffer> txn = env.txnRead();
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
+        final int key = kv.key().order(ByteOrder.nativeOrder()).getInt();
+        final int val = kv.val().getInt();
+        results.add(key);
+        assertThat(val).isEqualTo(key + 1);
+      }
+    }
+
+    assertThat(results).hasSize(expected.length);
+    for (int idx = 0; idx < results.size(); idx++) {
+      assertThat(results.get(idx)).isEqualTo(expected[idx]);
+    }
+  }
+
+  private Dbi<ByteBuffer> getDb() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+    populateDatabase(dbi);
+    return dbi;
+  }
+
+  // --------------------------------------------------------------------------------
+
+  private static class DbiFactory {
+    private final String name;
+    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
+
+    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
+      this.name = name;
+      this.factory = factory;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  static class MyArgumentProvider implements ArgumentsProvider {
+
+    @Override
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
+      final DbiFactory defaultComparatorDb =
+          new DbiFactory(
+              "defaultComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory nativeComparatorDb =
+          new DbiFactory(
+              "nativeComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_2)
+                      .withNativeComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory callbackComparatorDb =
+          new DbiFactory(
+              "callbackComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_3)
+                      .withCallbackComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory iteratorComparatorDb =
+          new DbiFactory(
+              "iteratorComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_4)
+                      .withIteratorComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      return Stream.of(
+              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
+          .map(Arguments::of);
+    }
+
+    private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSet) {
+      final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
+      return (o1, o2) -> {
+        if (o1.remaining() != o2.remaining()) {
+          // Make sure LMDB is always giving us consistent key lengths.
+          Assertions.fail(
+              "o1: "
+                  + o1
+                  + " "
+                  + getNativeIntOrLong(o1)
+                  + ", o2: "
+                  + o2
+                  + " "
+                  + getNativeIntOrLong(o2));
+        }
+        return baseComparator.compare(o1, o2);
+      };
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
new file mode 100644
index 00000000..f5210f3c
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -0,0 +1,201 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.GIBIBYTES;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.PutFlags.MDB_APPEND;
+import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class CursorIterablePerfTest {
+
+  //    private static final int ITERATIONS = 5_000_000;
+  private static final int ITERATIONS = 100_000;
+  //    private static final int ITERATIONS = 10;
+
+  private TempDir tempDir;
+  private Dbi<ByteBuffer> dbJavaComparator;
+  private Dbi<ByteBuffer> dbLmdbComparator;
+  private Dbi<ByteBuffer> dbCallbackComparator;
+  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private Env<ByteBuffer> env;
+  private List<Integer> data = new ArrayList<>(ITERATIONS);
+
+  @BeforeEach
+  public void before() {
+    tempDir = new TempDir();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(GIBIBYTES.toBytes(1))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .setFilePermissions(POSIX_MODE)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(tempDir.createTempFile());
+
+    final DbiFlagSet dbiFlagSet = MDB_CREATE;
+    // Use a java comparator for start/stop keys only
+    dbJavaComparator =
+        env.buildDbi()
+            .setDbName("JavaComparator")
+            .withDefaultComparator()
+            .setDbiFlags(dbiFlagSet)
+            .open();
+    // Use LMDB comparator for start/stop keys
+    dbLmdbComparator =
+        env.buildDbi()
+            .setDbName("LmdbComparator")
+            .withNativeComparator()
+            .setDbiFlags(dbiFlagSet)
+            .open();
+
+    // Use a java comparator for start/stop keys and as a callback comparator
+    dbCallbackComparator =
+        env.buildDbi()
+            .setDbName("CallBackComparator")
+            .withCallbackComparator(bufferProxy::getComparator)
+            .setDbiFlags(dbiFlagSet)
+            .open();
+
+    dbs.add(dbJavaComparator);
+    dbs.add(dbLmdbComparator);
+    dbs.add(dbCallbackComparator);
+
+    populateList();
+  }
+
+  @AfterEach
+  public void after() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  private void populateList() {
+    for (int i = 0; i < ITERATIONS * 2; i += 2) {
+      data.add(i);
+    }
+  }
+
+  private void populateDatabases(final boolean randomOrder) {
+    System.out.println("Clear then populate databases (randomOrder=" + randomOrder + ")");
+
+    final List<Integer> data;
+    if (randomOrder) {
+      data = new ArrayList<>(this.data);
+      Collections.shuffle(data);
+    } else {
+      data = this.data;
+    }
+
+    final PutFlagSet noOverwriteAndAppendFlagSet = PutFlagSet.of(MDB_NOOVERWRITE, MDB_APPEND);
+
+    for (int round = 0; round < 3; round++) {
+      System.out.println("round: " + round + " -----------------------------------------");
+
+      for (final Dbi<ByteBuffer> db : dbs) {
+        // Clean out the db first
+        try (Txn<ByteBuffer> txn = env.txnWrite();
+            final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
+          while (cursor.next()) {
+            cursor.delete();
+          }
+        }
+
+        final String dbName = db.getNameAsString(StandardCharsets.UTF_8);
+        final Instant start = Instant.now();
+        try (Txn<ByteBuffer> txn = env.txnWrite()) {
+          for (final Integer i : data) {
+            if (randomOrder) {
+              db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE);
+            } else {
+              db.put(txn, bb(i), bb(i + 1), noOverwriteAndAppendFlagSet);
+            }
+          }
+          txn.commit();
+        }
+        final Duration duration = Duration.between(start, Instant.now());
+        System.out.println(
+            "DB: "
+                + dbName
+                + " - Loaded in duration: "
+                + duration
+                + ", millis: "
+                + duration.toMillis());
+      }
+    }
+  }
+
+  @Test
+  public void comparePerf_sequential() {
+    comparePerf(false);
+  }
+
+  @Test
+  public void comparePerf_random() {
+    comparePerf(true);
+  }
+
+  public void comparePerf(final boolean randomOrder) {
+    populateDatabases(randomOrder);
+    final ByteBuffer startKeyBuf = bb(data.get(0));
+    final ByteBuffer stopKeyBuf = bb(data.get(data.size() - 1));
+    final KeyRange<ByteBuffer> keyRange = KeyRange.closed(startKeyBuf, stopKeyBuf);
+
+    System.out.println("\nIterating over all entries");
+    for (int round = 0; round < 3; round++) {
+      System.out.println("round: " + round + " -----------------------------------------");
+      for (final Dbi<ByteBuffer> db : dbs) {
+        final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+
+        final Instant start = Instant.now();
+        int cnt = 0;
+        // Exercise the stop key comparator on every entry
+        try (Txn<ByteBuffer> txn = env.txnRead();
+            CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+          for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+            cnt++;
+          }
+        }
+        final Duration duration = Duration.between(start, Instant.now());
+        System.out.println(
+            "DB: "
+                + dbName
+                + " - Iterated in duration: "
+                + duration
+                + ", millis: "
+                + duration.toMillis()
+                + ", cnt: "
+                + cnt);
+      }
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index f0471bab..4fa036f5 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -69,7 +69,7 @@ void testSignedComparator(
   void testUnsignedComparator(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        AbstractByteBufferProxy::compareBuff,
+        AbstractByteBufferProxy::compareLexicographically,
         false,
         createBasicDBPopulator(),
         EnumSet.of(MDB_CREATE),
@@ -99,7 +99,7 @@ void testSignedComparatorDupsort(
   void testUnsignedComparatorDupsort(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        AbstractByteBufferProxy::compareBuff,
+        AbstractByteBufferProxy::compareLexicographically,
         false,
         createMultiDBPopulator(2),
         EnumSet.of(MDB_CREATE, MDB_DUPSORT),
@@ -114,7 +114,7 @@ void testUnsignedComparatorDupsort(
   void testIntegerKey(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        AbstractByteBufferProxy::compareBuff,
+        AbstractByteBufferProxy::compareLexicographically,
         false,
         createIntegerDBPopulator(),
         EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
@@ -131,7 +131,7 @@ void testIntegerKey(
   void testLongKey(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        AbstractByteBufferProxy::compareBuff,
+        AbstractByteBufferProxy::compareLexicographically,
         false,
         createLongDBPopulator(),
         EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 5e515fee..4a8214e4 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -43,7 +43,9 @@
 import static org.lmdbjava.KeyRange.openClosedBackward;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
 import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.DB_2;
+import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.DB_4;
 import static org.lmdbjava.TestUtils.bb;
 
 import com.google.common.primitives.UnsignedBytes;
@@ -55,35 +57,65 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.function.Function;
+import java.util.stream.Stream;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.Parameter;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import org.junit.jupiter.params.support.ParameterDeclarations;
 import org.lmdbjava.CursorIterable.KeyVal;
 
 /** Test {@link CursorIterable}. */
+@ParameterizedClass(name = "{index}: dbi: {0}")
+@ArgumentsSource(CursorIterableTest.MyArgumentProvider.class)
 public final class CursorIterableTest {
 
+  private static final DbiFlagSet DBI_FLAGS = MDB_CREATE;
+  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
+
   private TempDir tempDir;
-  private Dbi<ByteBuffer> db;
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
+  //  /**
+  //   * Injected by {@link #data()} with appropriate runner.
+  //   */
+  //  @SuppressWarnings("ClassEscapesDefinedScope")
+  @Parameter public DbiFactory dbiFactory;
+
   @BeforeEach
   void beforeEach() {
     tempDir = new TempDir();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env =
-        create()
+        create(bufferProxy)
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
-            .setMaxDbs(1)
-            .open(tempDir.createTempFile().toFile(), POSIX_MODE, MDB_NOSUBDIR);
-    db = env.openDbi(DB_1, MDB_CREATE);
-    populateDatabase(db);
+            .setMaxDbs(3)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(tempDir.createTempFile());
+
+    populateTestDataList();
   }
 
-  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+  @AfterEach
+  void afterEach() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  private void populateTestDataList() {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       c.put(bb(2), bb(3), MDB_NOOVERWRITE);
@@ -94,12 +126,6 @@ private void populateDatabase(final Dbi<ByteBuffer> dbi) {
     }
   }
 
-  @AfterEach
-  void afterEach() {
-    env.close();
-    tempDir.cleanup();
-  }
-
   @Test
   void allBackwardTest() {
     verify(allBackward(), 8, 6, 4, 2);
@@ -179,6 +205,7 @@ void greaterThanTest() {
   void iterableOnlyReturnedOnce() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
               try (Txn<ByteBuffer> txn = env.txnRead();
                   CursorIterable<ByteBuffer> c = db.iterate(txn)) {
                 c.iterator(); // ok
@@ -190,8 +217,10 @@ void iterableOnlyReturnedOnce() {
 
   @Test
   void iterate() {
+    final Dbi<ByteBuffer> db = getDb();
     try (Txn<ByteBuffer> txn = env.txnRead();
         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+
       for (final KeyVal<ByteBuffer> kv : c) {
         assertThat(kv.key().getInt()).isEqualTo(list.pollFirst());
         assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
@@ -203,6 +232,7 @@ void iterate() {
   void iteratorOnlyReturnedOnce() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
               try (Txn<ByteBuffer> txn = env.txnRead();
                   CursorIterable<ByteBuffer> c = db.iterate(txn)) {
                 c.iterator(); // ok
@@ -228,6 +258,8 @@ void lessThanTest() {
   void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              populateTestDataList();
               try (Txn<ByteBuffer> txn = env.txnRead();
                   CursorIterable<ByteBuffer> c = db.iterate(txn)) {
                 final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
@@ -272,7 +304,8 @@ void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    final Dbi<ByteBuffer> guavaDbi =
+        env.buildDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bb(7), bb(2)), guavaDbi, 6, 4, 2);
     verify(openClosedBackward(bb(8), bb(4)), guavaDbi, 6, 4);
@@ -292,6 +325,7 @@ void openTest() {
 
   @Test
   void removeOddElements() {
+    final Dbi<ByteBuffer> db = getDb();
     verify(all(), 2, 4, 6, 8);
     int idx = -1;
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -307,13 +341,14 @@ void removeOddElements() {
       }
       txn.commit();
     }
-    verify(all(), 4, 8);
+    verify(db, all(), 4, 8);
   }
 
   @Test
   void nextWithClosedEnvTest() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
               try (Txn<ByteBuffer> txn = env.txnRead()) {
                 try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
                   final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -330,6 +365,7 @@ void nextWithClosedEnvTest() {
   void removeWithClosedEnvTest() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
               try (Txn<ByteBuffer> txn = env.txnWrite()) {
                 try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
                   final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -349,6 +385,7 @@ void removeWithClosedEnvTest() {
   void hasNextWithClosedEnvTest() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
               try (Txn<ByteBuffer> txn = env.txnRead()) {
                 try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
                   final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -365,6 +402,7 @@ void hasNextWithClosedEnvTest() {
   void forEachRemainingWithClosedEnvTest() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
               try (Txn<ByteBuffer> txn = env.txnRead()) {
                 try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
                   final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -377,12 +415,67 @@ void forEachRemainingWithClosedEnvTest() {
         .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
+  //  @Test
+  //  public void testSignedVsUnsigned() {
+  //    final ByteBuffer val1 = bb(1);
+  //    final ByteBuffer val2 = bb(2);
+  //    final ByteBuffer val110 = bb(110);
+  //    final ByteBuffer val111 = bb(111);
+  //    final ByteBuffer val150 = bb(150);
+  //
+  //    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+  //    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
+  //    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
+  //
+  //    // Compare the same
+  //    assertThat(
+  //        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1,
+  // val2)));
+  //
+  //    // Compare differently
+  //    assertThat(
+  //        unsignedComparator.compare(val110, val150),
+  //        Matchers.not(signedComparator.compare(val110, val150)));
+  //
+  //    // Compare differently
+  //    assertThat(
+  //        unsignedComparator.compare(val111, val150),
+  //        Matchers.not(signedComparator.compare(val111, val150)));
+  //
+  //    // This will fail if the db is using a signed comparator for the start/stop keys
+  //    for (final Dbi<ByteBuffer> db : dbs) {
+  //      db.put(val110, val110);
+  //      db.put(val150, val150);
+  //
+  //      final ByteBuffer startKeyBuf = val111;
+  //      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
+  //
+  //      try (Txn<ByteBuffer> txn = env.txnRead();
+  //          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+  //        for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+  //          final int key = kv.key().getInt();
+  //          final int val = kv.val().getInt();
+  //          //          System.out.println("key: " + key + " val: " + val);
+  //          assertThat(key, is(110));
+  //          break;
+  //        }
+  //      }
+  //    }
+  //  }
+
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
+    final Dbi<ByteBuffer> db = getDb();
     verify(range, db, expected);
   }
 
+  private void verify(
+      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expected) {
+    verify(range, dbi, expected);
+  }
+
   private void verify(
       final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
+
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
@@ -400,4 +493,76 @@ private void verify(
       assertThat(results.get(idx)).isEqualTo(expected[idx]);
     }
   }
+
+  private Dbi<ByteBuffer> getDb() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+    populateDatabase(dbi);
+    return dbi;
+  }
+
+  // --------------------------------------------------------------------------------
+
+  private static class DbiFactory {
+    private final String name;
+    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
+
+    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
+      this.name = name;
+      this.factory = factory;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  static class MyArgumentProvider implements ArgumentsProvider {
+
+    @Override
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
+      final DbiFactory defaultComparatorDb =
+          new DbiFactory(
+              "defaultComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory nativeComparatorDb =
+          new DbiFactory(
+              "nativeComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_2)
+                      .withNativeComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory callbackComparatorDb =
+          new DbiFactory(
+              "callbackComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_3)
+                      .withCallbackComparator(BUFFER_PROXY::getComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory iteratorComparatorDb =
+          new DbiFactory(
+              "iteratorComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_4)
+                      .withIteratorComparator(BUFFER_PROXY::getComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      return Stream.of(
+              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
+          .map(Arguments::of);
+    }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
new file mode 100644
index 00000000..4ef11f2a
--- /dev/null
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.getString;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class DbiBuilderTest {
+
+  private TempDir tempDir;
+  private Env<ByteBuffer> env;
+
+  @BeforeEach
+  public void before() {
+    tempDir = new TempDir();
+    env =
+        create()
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(tempDir.createTempFile());
+  }
+
+  @AfterEach
+  public void after() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  @Test
+  public void unnamed() {
+    final Dbi<ByteBuffer> dbi =
+        env.buildDbi()
+            .withoutDbName()
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+    assertThat(dbi.getName()).isNull();
+    assertThat(dbi.getNameAsString()).isEmpty();
+    assertThat(env.getDbiNames()).isEmpty();
+    assertPutAndGet(dbi);
+  }
+
+  @Test
+  public void named() {
+    final Dbi<ByteBuffer> dbi =
+        env.buildDbi()
+            .setDbName("foo")
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+
+    assertPutAndGet(dbi);
+
+    assertThat(env.getDbiNames()).hasSize(1);
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8)).isEqualTo("foo");
+    assertThat(dbi.getNameAsString()).isEqualTo("foo");
+    assertThat(dbi.getNameAsString(StandardCharsets.UTF_8)).isEqualTo("foo");
+  }
+
+  @Test
+  public void named2() {
+    final Dbi<ByteBuffer> dbi =
+        env.buildDbi()
+            .setDbName("foo".getBytes(StandardCharsets.US_ASCII))
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+
+    assertPutAndGet(dbi);
+
+    assertThat(env.getDbiNames()).hasSize(1);
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.US_ASCII)).isEqualTo("foo");
+    assertThat(dbi.getNameAsString()).isEqualTo("foo");
+    assertThat(dbi.getNameAsString(StandardCharsets.US_ASCII)).isEqualTo("foo");
+  }
+
+  @Test
+  public void nativeComparator() {
+    final Dbi<ByteBuffer> dbi =
+        env.buildDbi()
+            .setDbName("foo")
+            .withNativeComparator()
+            .addDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+
+    assertPutAndGet(dbi);
+    assertThat(env.getDbiNames()).hasSize(1);
+  }
+
+  @Test
+  public void callback() {
+    final Comparator<ByteBuffer> proxyOptimal = ByteBufferProxy.PROXY_OPTIMAL.getComparator();
+    // Compare on key length, falling back to default
+    final Comparator<ByteBuffer> comparator =
+        (o1, o2) -> {
+          final int res = Integer.compare(o1.remaining(), o2.remaining());
+          if (res == 0) {
+            return proxyOptimal.compare(o1, o2);
+          } else {
+            return res;
+          }
+        };
+
+    final Dbi<ByteBuffer> dbi =
+        env.buildDbi()
+            .setDbName("foo")
+            .withCallbackComparator(ignored -> comparator)
+            .addDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+
+    TestUtils.doWithWriteTxn(
+        env,
+        txn -> {
+          dbi.put(txn, bb("fox"), bb("val_1"));
+          dbi.put(txn, bb("rabbit"), bb("val_2"));
+          dbi.put(txn, bb("deer"), bb("val_3"));
+          dbi.put(txn, bb("badger"), bb("val_4"));
+          txn.commit();
+        });
+
+    final List<String> keys = new ArrayList<>();
+    TestUtils.doWithReadTxn(
+        env,
+        txn -> {
+          try (CursorIterable<ByteBuffer> cursorIterable = dbi.iterate(txn)) {
+            final Iterator<CursorIterable.KeyVal<ByteBuffer>> iterator = cursorIterable.iterator();
+            iterator.forEachRemaining(
+                keyVal -> {
+                  keys.add(getString(keyVal.key()));
+                });
+          }
+        });
+    assertThat(keys).containsExactly("fox", "deer", "badger", "rabbit");
+  }
+
+  @Test
+  public void flags() {
+    final Dbi<ByteBuffer> dbi =
+        env.buildDbi()
+            .setDbName("foo")
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_DUPSORT, DbiFlags.MDB_DUPFIXED) // Will get overwritten
+            .setDbiFlags() // clear them
+            .addDbiFlags(DbiFlags.MDB_CREATE) // Not a dbi flag as far as lmdb is concerned.
+            .addDbiFlags(DbiFlags.MDB_INTEGERKEY)
+            .addDbiFlags(DbiFlags.MDB_REVERSEKEY)
+            .open();
+
+    assertPutAndGet(dbi);
+
+    assertThat(env.getDbiNames()).hasSize(1);
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8)).isEqualTo("foo");
+
+    TestUtils.doWithReadTxn(
+        env,
+        readTxn -> {
+          assertThat(dbi.listFlags(readTxn))
+              .containsExactlyInAnyOrder(DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_REVERSEKEY);
+        });
+  }
+
+  private void assertPutAndGet(Dbi<ByteBuffer> dbi) {
+    try (Txn<ByteBuffer> writeTxn = env.txnWrite()) {
+      dbi.put(writeTxn, bb(123), bb(123_000));
+      writeTxn.commit();
+    }
+
+    try (Txn<ByteBuffer> readTxn = env.txnRead()) {
+      final ByteBuffer byteBuffer = dbi.get(readTxn, bb(123));
+      assertThat(byteBuffer).isNotNull();
+      final int val = byteBuffer.getInt();
+      assertThat(val).isEqualTo(123_000);
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
new file mode 100644
index 00000000..12536957
--- /dev/null
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import org.junit.jupiter.api.Test;
+
+public class DbiFlagSetTest {
+
+  @Test
+  public void testEmpty() {
+    final DbiFlagSet dbiFlagSet = DbiFlagSet.empty();
+    assertThat(dbiFlagSet.getMask()).isEqualTo(0);
+    assertThat(dbiFlagSet.size()).isEqualTo(0);
+    assertThat(dbiFlagSet.isEmpty()).isEqualTo(true);
+    assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
+    final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder().build();
+    assertThat(dbiFlagSet).isEqualTo(dbiFlagSet2);
+    assertThat(dbiFlagSet).isNotEqualTo(DbiFlagSet.of(DbiFlags.MDB_CREATE));
+    assertThat(dbiFlagSet).isNotEqualTo(DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_DUPSORT));
+    assertThat(dbiFlagSet)
+        .isNotEqualTo(
+            DbiFlagSet.builder()
+                .setFlag(DbiFlags.MDB_CREATE)
+                .setFlag(DbiFlags.MDB_DUPFIXED)
+                .build());
+  }
+
+  @Test
+  public void testOf() {
+    final DbiFlags dbiFlag = DbiFlags.MDB_CREATE;
+    final DbiFlagSet dbiFlagSet = DbiFlagSet.of(dbiFlag);
+    assertThat(dbiFlagSet.getMask()).isEqualTo(MaskedFlag.mask(dbiFlag));
+    assertThat(dbiFlagSet.size()).isEqualTo(1);
+    assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
+    for (DbiFlags flag : dbiFlagSet) {
+      assertThat(dbiFlagSet.isSet(flag)).isEqualTo(true);
+    }
+
+    final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder().setFlag(dbiFlag).build();
+    assertThat(dbiFlagSet).isEqualTo(dbiFlagSet2);
+  }
+
+  @Test
+  public void testOf2() {
+    final DbiFlags dbiFlag1 = DbiFlags.MDB_CREATE;
+    final DbiFlags dbiFlag2 = DbiFlags.MDB_INTEGERKEY;
+    final DbiFlagSet dbiFlagSet = DbiFlagSet.of(dbiFlag1, dbiFlag2);
+    assertThat(dbiFlagSet.getMask()).isEqualTo(MaskedFlag.mask(dbiFlag1, dbiFlag2));
+    assertThat(dbiFlagSet.size()).isEqualTo(2);
+    assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
+    for (DbiFlags flag : dbiFlagSet) {
+      assertThat(dbiFlagSet.isSet(flag)).isEqualTo(true);
+    }
+  }
+
+  @Test
+  public void testBuilder() {
+    final DbiFlags dbiFlag1 = DbiFlags.MDB_CREATE;
+    final DbiFlags dbiFlag2 = DbiFlags.MDB_INTEGERKEY;
+    final DbiFlagSet dbiFlagSet = DbiFlagSet.builder().setFlag(dbiFlag1).setFlag(dbiFlag2).build();
+    assertThat(dbiFlagSet.getMask()).isEqualTo(MaskedFlag.mask(dbiFlag1, dbiFlag2));
+    assertThat(dbiFlagSet.size()).isEqualTo(2);
+    assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
+    for (DbiFlags flag : dbiFlagSet) {
+      assertThat(dbiFlagSet.isSet(flag)).isEqualTo(true);
+    }
+    final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder().withFlags(dbiFlag1, dbiFlag2).build();
+    final DbiFlagSet dbiFlagSet3 =
+        DbiFlagSet.builder().withFlags(new HashSet<>(Arrays.asList(dbiFlag1, dbiFlag2))).build();
+    assertThat(dbiFlagSet).isEqualTo(dbiFlagSet2);
+    assertThat(dbiFlagSet).isEqualTo(dbiFlagSet3);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 563215c4..632d51b5 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -57,8 +57,8 @@
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
-import java.util.function.Function;
 import java.util.function.IntFunction;
+import java.util.function.Supplier;
 import java.util.function.ToIntFunction;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
@@ -106,7 +106,12 @@ void afterEach() {
   void close() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              final Dbi<ByteBuffer> db =
+                  env.buildDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .addDbiFlag(MDB_CREATE)
+                      .open();
               db.put(bb(1), bb(42));
               db.close();
               db.put(bb(2), bb(42)); // error
@@ -187,11 +192,11 @@ void dbiWithComparatorThreadSafetyByteArray() {
 
   private <T> void doDbiWithComparatorThreadSafety(
       Env<T> env,
-      Function<DbiFlags[], Comparator<T>> comparator,
+      Supplier<Comparator<T>> comparatorSupplier,
       IntFunction<T> serializer,
       ToIntFunction<T> deserializer) {
     final DbiFlags[] flags = new DbiFlags[] {MDB_CREATE, MDB_INTEGERKEY};
-    final Comparator<T> c = comparator.apply(flags);
+    final Comparator<T> c = comparatorSupplier.get();
     final Dbi<T> db = env.openDbi(DB_1, c, true, flags);
 
     final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
new file mode 100644
index 00000000..f270507b
--- /dev/null
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import org.junit.jupiter.api.Test;
+
+public class EnvFlagSetTest {
+
+  @Test
+  public void testEmpty() {
+    final EnvFlagSet envFlagSet = EnvFlagSet.empty();
+    assertThat(envFlagSet.getMask()).isEqualTo(0);
+    assertThat(envFlagSet.size()).isEqualTo(0);
+    assertThat(envFlagSet.isEmpty()).isEqualTo(true);
+    assertThat(envFlagSet.isSet(EnvFlags.MDB_NOSUBDIR)).isEqualTo(false);
+    final EnvFlagSet envFlagSet2 = EnvFlagSet.builder().build();
+    assertThat(envFlagSet).isEqualTo(envFlagSet2);
+    assertThat(envFlagSet).isNotEqualTo(EnvFlagSet.of(EnvFlags.MDB_FIXEDMAP));
+    assertThat(envFlagSet)
+        .isNotEqualTo(EnvFlagSet.of(EnvFlags.MDB_FIXEDMAP, EnvFlags.MDB_NORDAHEAD));
+    assertThat(envFlagSet)
+        .isNotEqualTo(
+            EnvFlagSet.builder()
+                .setFlag(EnvFlags.MDB_FIXEDMAP)
+                .setFlag(EnvFlags.MDB_NORDAHEAD)
+                .build());
+  }
+
+  @Test
+  public void testOf() {
+    final EnvFlags envFlag = EnvFlags.MDB_FIXEDMAP;
+    final EnvFlagSet envFlagSet = EnvFlagSet.of(envFlag);
+    assertThat(envFlagSet.getMask()).isEqualTo(MaskedFlag.mask(envFlag));
+    assertThat(envFlagSet.size()).isEqualTo(1);
+    assertThat(envFlagSet.isSet(EnvFlags.MDB_NOSUBDIR)).isEqualTo(false);
+    for (EnvFlags flag : envFlagSet) {
+      assertThat(envFlagSet.isSet(flag)).isEqualTo(true);
+    }
+
+    final EnvFlagSet envFlagSet2 = EnvFlagSet.builder().setFlag(envFlag).build();
+    assertThat(envFlagSet).isEqualTo(envFlagSet2);
+  }
+
+  @Test
+  public void testOf2() {
+    final EnvFlags envFlag1 = EnvFlags.MDB_FIXEDMAP;
+    final EnvFlags envFlag2 = EnvFlags.MDB_NORDAHEAD;
+    final EnvFlagSet envFlagSet = EnvFlagSet.of(envFlag1, envFlag2);
+    assertThat(envFlagSet.getMask()).isEqualTo(MaskedFlag.mask(envFlag1, envFlag2));
+    assertThat(envFlagSet.size()).isEqualTo(2);
+    assertThat(envFlagSet.isSet(EnvFlags.MDB_WRITEMAP)).isEqualTo(false);
+    for (EnvFlags flag : envFlagSet) {
+      assertThat(envFlagSet.isSet(flag)).isEqualTo(true);
+    }
+  }
+
+  @Test
+  public void testBuilder() {
+    final EnvFlags envFlag1 = EnvFlags.MDB_FIXEDMAP;
+    final EnvFlags envFlag2 = EnvFlags.MDB_NORDAHEAD;
+    final EnvFlagSet envFlagSet = EnvFlagSet.builder().setFlag(envFlag1).setFlag(envFlag2).build();
+    assertThat(envFlagSet.getMask()).isEqualTo(MaskedFlag.mask(envFlag1, envFlag2));
+    assertThat(envFlagSet.size()).isEqualTo(2);
+    assertThat(envFlagSet.isSet(EnvFlags.MDB_NOTLS)).isEqualTo(false);
+    for (EnvFlags flag : envFlagSet) {
+      assertThat(envFlagSet.isSet(flag)).isEqualTo(true);
+    }
+    final EnvFlagSet envFlagSet2 = EnvFlagSet.builder().withFlags(envFlag1, envFlag2).build();
+    final EnvFlagSet envFlagSet3 =
+        EnvFlagSet.builder().withFlags(new HashSet<>(Arrays.asList(envFlag1, envFlag2))).build();
+    assertThat(envFlagSet).isEqualTo(envFlagSet2);
+    assertThat(envFlagSet).isEqualTo(envFlagSet3);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index 0f77b92f..2e8854b9 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -194,7 +194,10 @@ private void verify(final KeyRange<Integer> range, final int... expected) {
 
     IteratorOp op;
     do {
-      op = range.getType().iteratorOp(range.getStart(), range.getStop(), buff, Integer::compare);
+      final Integer finalBuff = buff;
+      final RangeComparator rangeComparator =
+          new CursorIterable.JavaRangeComparator<>(range, Integer::compareTo, () -> finalBuff);
+      op = range.getType().iteratorOp(buff, rangeComparator);
       switch (op) {
         case CALL_NEXT_OP:
           buff = cursor.apply(range.getType().nextOp(), range.getStart());
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
new file mode 100644
index 00000000..c7634769
--- /dev/null
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import org.junit.jupiter.api.Test;
+
+public class PutFlagSetTest {
+
+  @Test
+  public void testEmpty() {
+    final PutFlagSet putFlagSet = PutFlagSet.empty();
+    assertThat(putFlagSet.getMask()).isEqualTo(0);
+    assertThat(putFlagSet.size()).isEqualTo(0);
+    assertThat(putFlagSet.isEmpty()).isEqualTo(true);
+    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
+    final PutFlagSet putFlagSet2 = PutFlagSet.builder().build();
+    assertThat(putFlagSet).isEqualTo(putFlagSet2);
+    assertThat(putFlagSet).isNotEqualTo(PutFlagSet.of(PutFlags.MDB_APPEND));
+    assertThat(putFlagSet).isNotEqualTo(PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_RESERVE));
+    assertThat(putFlagSet)
+        .isNotEqualTo(
+            PutFlagSet.builder()
+                .setFlag(PutFlags.MDB_CURRENT)
+                .setFlag(PutFlags.MDB_MULTIPLE)
+                .build());
+  }
+
+  @Test
+  public void testOf() {
+    final PutFlags putFlag = PutFlags.MDB_APPEND;
+    final PutFlagSet putFlagSet = PutFlagSet.of(putFlag);
+    assertThat(putFlagSet.getMask()).isEqualTo(MaskedFlag.mask(putFlag));
+    assertThat(putFlagSet.size()).isEqualTo(1);
+    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
+    for (PutFlags flag : putFlagSet) {
+      assertThat(putFlagSet.isSet(flag)).isEqualTo(true);
+    }
+
+    final PutFlagSet putFlagSet2 = PutFlagSet.builder().setFlag(putFlag).build();
+    assertThat(putFlagSet).isEqualTo(putFlagSet2);
+  }
+
+  @Test
+  public void testOf2() {
+    final PutFlags putFlag1 = PutFlags.MDB_APPEND;
+    final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
+    final PutFlagSet putFlagSet = PutFlagSet.of(putFlag1, putFlag2);
+    assertThat(putFlagSet.getMask()).isEqualTo(MaskedFlag.mask(putFlag1, putFlag2));
+    assertThat(putFlagSet.size()).isEqualTo(2);
+    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
+    for (PutFlags flag : putFlagSet) {
+      assertThat(putFlagSet.isSet(flag)).isEqualTo(true);
+    }
+  }
+
+  @Test
+  public void testBuilder() {
+    final PutFlags putFlag1 = PutFlags.MDB_APPEND;
+    final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
+    final PutFlagSet putFlagSet = PutFlagSet.builder().setFlag(putFlag1).setFlag(putFlag2).build();
+    assertThat(putFlagSet.getMask()).isEqualTo(MaskedFlag.mask(putFlag1, putFlag2));
+    assertThat(putFlagSet.size()).isEqualTo(2);
+    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
+    for (PutFlags flag : putFlagSet) {
+      assertThat(putFlagSet.isSet(flag)).isEqualTo(true);
+    }
+    final PutFlagSet putFlagSet2 = PutFlagSet.builder().withFlags(putFlag1, putFlag2).build();
+    final PutFlagSet putFlagSet3 =
+        PutFlagSet.builder().withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2))).build();
+    assertThat(putFlagSet).isEqualTo(putFlagSet2);
+    assertThat(putFlagSet).isEqualTo(putFlagSet3);
+  }
+
+  @Test
+  public void testAddFlagVsCheckPresence() {
+
+    final int cnt = 10_000_000;
+    final int[] arr = new int[cnt];
+    final List<PutFlagSet> flagSets =
+        IntStream.range(0, cnt)
+            .boxed()
+            .map(
+                i ->
+                    PutFlagSet.of(
+                        PutFlags.MDB_APPEND, PutFlags.MDB_NOOVERWRITE, PutFlags.MDB_RESERVE))
+            .collect(Collectors.toList());
+
+    Instant time;
+    for (int i = 0; i < 5; i++) {
+      time = Instant.now();
+      for (int j = 0; j < flagSets.size(); j++) {
+        PutFlagSet flagSet = flagSets.get(j);
+        if (!flagSet.isSet(PutFlags.MDB_RESERVE)) {
+          throw new RuntimeException("Not set");
+        }
+        arr[j] = flagSet.getMask();
+      }
+      System.out.println("Check: " + Duration.between(time, Instant.now()));
+
+      time = Instant.now();
+      for (int j = 0; j < flagSets.size(); j++) {
+        PutFlagSet flagSet = flagSets.get(j);
+        final int mask = flagSet.getMaskWith(PutFlags.MDB_RESERVE);
+        arr[j] = mask;
+      }
+      System.out.println("Append:" + Duration.between(time, Instant.now()));
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 23606862..abaf63bb 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -22,6 +22,11 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
 
@@ -29,6 +34,9 @@
 final class TestUtils {
 
   public static final String DB_1 = "test-db-1";
+  public static final String DB_2 = "test-db-2";
+  public static final String DB_3 = "test-db-3";
+  public static final String DB_4 = "test-db-2";
 
   public static final int POSIX_MODE = 0664;
 
@@ -56,6 +64,53 @@ static ByteBuffer bb(final long value) {
     return bb;
   }
 
+  static ByteBuffer bb(final String value) {
+    final ByteBuffer bb = allocateDirect(100);
+    if (value != null) {
+      bb.put(value.getBytes(StandardCharsets.UTF_8));
+      bb.flip();
+    }
+    return bb;
+  }
+
+  static ByteBuffer bbNative(final int value) {
+    final ByteBuffer bb = allocateDirect(Integer.BYTES).order(ByteOrder.nativeOrder());
+    bb.putInt(value).flip();
+    return bb;
+  }
+
+  static ByteBuffer bbNative(final long value) {
+    final ByteBuffer bb = allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    bb.putLong(value).flip();
+    return bb;
+  }
+
+  static int getNativeInt(final ByteBuffer bb) {
+    final int val = bb.order(ByteOrder.nativeOrder()).getInt();
+    bb.rewind();
+    return val;
+  }
+
+  static long getNativeLong(final ByteBuffer bb) {
+    final long val = bb.order(ByteOrder.nativeOrder()).getLong();
+    bb.rewind();
+    return val;
+  }
+
+  static long getNativeIntOrLong(final ByteBuffer bb) {
+    if (bb.remaining() == Integer.BYTES) {
+      return getNativeInt(bb);
+    } else {
+      return getNativeLong(bb);
+    }
+  }
+
+  static String getString(final ByteBuffer bb) {
+    final String str = StandardCharsets.UTF_8.decode(bb).toString();
+    bb.rewind();
+    return str;
+  }
+
   static byte[] getBytes(final ByteBuffer byteBuffer) {
     if (byteBuffer == null) {
       return null;
@@ -90,4 +145,36 @@ static ByteBuf nb(final int value) {
     b.writeInt(value);
     return b;
   }
+
+  static <T> void doWithReadTxn(final Env<T> env, final Consumer<Txn<T>> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnRead()) {
+      work.accept(readTxn);
+    }
+  }
+
+  static <T, R> R getWithReadTxn(final Env<T> env, final Function<Txn<T>, R> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnRead()) {
+      return work.apply(readTxn);
+    }
+  }
+
+  static <T> void doWithWriteTxn(final Env<T> env, final Consumer<Txn<T>> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnWrite()) {
+      work.accept(readTxn);
+    }
+  }
+
+  static <T, R> R getWithWriteTxn(final Env<T> env, final Function<Txn<T>, R> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnWrite()) {
+      return work.apply(readTxn);
+    }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
new file mode 100644
index 00000000..08788c63
--- /dev/null
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Collections;
+import java.util.HashSet;
+import org.junit.jupiter.api.Test;
+
+public class TxnFlagSetTest {
+
+  @Test
+  void testSingleEnum() {
+    final TxnFlagSet txnFlagSet = TxnFlags.MDB_RDONLY_TXN;
+    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(TxnFlags.MDB_RDONLY_TXN));
+    assertThat(txnFlagSet.size()).isEqualTo(1);
+    for (TxnFlags flag : txnFlagSet) {
+      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
+    }
+
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder().setFlag(TxnFlags.MDB_RDONLY_TXN).build();
+    assertThat(txnFlagSet2.getFlags()).containsExactlyElementsOf(txnFlagSet.getFlags());
+    assertThat(txnFlagSet.areAnySet(TxnFlags.MDB_RDONLY_TXN)).isTrue();
+    assertThat(txnFlagSet.areAnySet(TxnFlagSet.empty())).isFalse();
+  }
+
+  @Test
+  public void testEmpty() {
+    final TxnFlagSet txnFlagSet = TxnFlagSet.empty();
+    assertThat(txnFlagSet.getMask()).isEqualTo(0);
+    assertThat(txnFlagSet.size()).isEqualTo(0);
+    assertThat(txnFlagSet.isEmpty()).isEqualTo(true);
+    assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(false);
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder().build();
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+    assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.of(TxnFlags.MDB_RDONLY_TXN));
+    assertThat(txnFlagSet)
+        .isNotEqualTo(TxnFlagSet.builder().setFlag(TxnFlags.MDB_RDONLY_TXN).build());
+  }
+
+  @Test
+  public void testOf() {
+    final TxnFlags txnFlag = TxnFlags.MDB_RDONLY_TXN;
+    final TxnFlagSet txnFlagSet = TxnFlagSet.of(txnFlag);
+    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag));
+    assertThat(txnFlagSet.size()).isEqualTo(1);
+    for (TxnFlags flag : txnFlagSet) {
+      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
+    }
+
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder().setFlag(txnFlag).build();
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+  }
+
+  @Test
+  public void testBuilder() {
+    final TxnFlags txnFlag1 = TxnFlags.MDB_RDONLY_TXN;
+    final TxnFlagSet txnFlagSet = TxnFlagSet.builder().setFlag(txnFlag1).build();
+    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag1));
+    assertThat(txnFlagSet.size()).isEqualTo(1);
+    assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(true);
+    for (TxnFlags flag : txnFlagSet) {
+      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
+    }
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder().withFlags(txnFlag1).build();
+    final TxnFlagSet txnFlagSet3 =
+        TxnFlagSet.builder().withFlags(new HashSet<>(Collections.singletonList(txnFlag1))).build();
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet3);
+  }
+}

From 484a772b03ad439ba5977d2afdca6e1d8bbf0118 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 18:41:39 +0000
Subject: [PATCH 30/90] Merged new comparator code

---
 .../java/org/lmdbjava/CursorIterableRangeTest.java |  8 +++++---
 .../CursorIterableRangeTest/testIntegerKey.csv     | 14 ++++++--------
 .../CursorIterableRangeTest/testLongKey.csv        | 14 ++++++--------
 3 files changed, 17 insertions(+), 19 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 4fa036f5..f835c494 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -114,7 +114,7 @@ void testUnsignedComparatorDupsort(
   void testIntegerKey(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        AbstractByteBufferProxy::compareLexicographically,
+        AbstractByteBufferProxy::compareAsIntegerKeys,
         false,
         createIntegerDBPopulator(),
         EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
@@ -131,7 +131,7 @@ void testIntegerKey(
   void testLongKey(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        AbstractByteBufferProxy::compareLexicographically,
+        AbstractByteBufferProxy::compareAsIntegerKeys,
         false,
         createLongDBPopulator(),
         EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
@@ -183,7 +183,9 @@ private void testCSV(
               .setMapSize(KIBIBYTES.toBytes(256))
               .setMaxReaders(1)
               .setMaxDbs(1)
-              .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
+              .setFilePermissions(POSIX_MODE)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
         final Dbi<ByteBuffer> dbi =
             env.openDbi(DB_1, comparator, nativeCb, flags.toArray(new DbiFlags[0]));
         dbPopulator.accept(env, dbi);
diff --git a/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv b/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv
index d8d6dc35..df61bf73 100644
--- a/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv
+++ b/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv
@@ -43,13 +43,11 @@ BACKWARD_GREATER_THAN,1001,,[1000 2][0 1]
 BACKWARD_LESS_THAN,,999,[-1000 5][-1000000 4][1000000 3][1000 2]
 BACKWARD_LESS_THAN,,1000,[-1000 5][-1000000 4][1000000 3]
 BACKWARD_LESS_THAN,,1001,[-1000 5][-1000000 4][1000000 3]
-BACKWARD_OPEN,999,1001,[1000 2]
-BACKWARD_OPEN,999,1000,
-BACKWARD_OPEN,999,1001,[1000 2]
+BACKWARD_OPEN,1001,999,[1000 2]
+BACKWARD_OPEN,1000,999,
 BACKWARD_OPEN,1000,1000,
-BACKWARD_OPEN,1000,1001,
-BACKWARD_OPEN_CLOSED,999,1001,[1000 2]
-BACKWARD_OPEN_CLOSED,999,1000,[1000 2]
+BACKWARD_OPEN,1001,1000,
+BACKWARD_OPEN_CLOSED,1001,999,[1000 2]
+BACKWARD_OPEN_CLOSED,1000,999,
 BACKWARD_OPEN_CLOSED,1000,1000,
-BACKWARD_OPEN_CLOSED,1000,1001,
-BACKWARD_OPEN_CLOSED,1000,1001,
+BACKWARD_OPEN_CLOSED,1001,1000,[1000 2]
diff --git a/src/test/resources/CursorIterableRangeTest/testLongKey.csv b/src/test/resources/CursorIterableRangeTest/testLongKey.csv
index d8d6dc35..df61bf73 100644
--- a/src/test/resources/CursorIterableRangeTest/testLongKey.csv
+++ b/src/test/resources/CursorIterableRangeTest/testLongKey.csv
@@ -43,13 +43,11 @@ BACKWARD_GREATER_THAN,1001,,[1000 2][0 1]
 BACKWARD_LESS_THAN,,999,[-1000 5][-1000000 4][1000000 3][1000 2]
 BACKWARD_LESS_THAN,,1000,[-1000 5][-1000000 4][1000000 3]
 BACKWARD_LESS_THAN,,1001,[-1000 5][-1000000 4][1000000 3]
-BACKWARD_OPEN,999,1001,[1000 2]
-BACKWARD_OPEN,999,1000,
-BACKWARD_OPEN,999,1001,[1000 2]
+BACKWARD_OPEN,1001,999,[1000 2]
+BACKWARD_OPEN,1000,999,
 BACKWARD_OPEN,1000,1000,
-BACKWARD_OPEN,1000,1001,
-BACKWARD_OPEN_CLOSED,999,1001,[1000 2]
-BACKWARD_OPEN_CLOSED,999,1000,[1000 2]
+BACKWARD_OPEN,1001,1000,
+BACKWARD_OPEN_CLOSED,1001,999,[1000 2]
+BACKWARD_OPEN_CLOSED,1000,999,
 BACKWARD_OPEN_CLOSED,1000,1000,
-BACKWARD_OPEN_CLOSED,1000,1001,
-BACKWARD_OPEN_CLOSED,1000,1001,
+BACKWARD_OPEN_CLOSED,1001,1000,[1000 2]

From ad75cb2351ecf10b452e80005d68b04eb1af11f9 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 5 Nov 2025 21:08:15 +0000
Subject: [PATCH 31/90] Fix CodeQL issues, add setMapSizeXx methods

---
 .../java/org/lmdbjava/CursorIterable.java     |   2 +-
 src/main/java/org/lmdbjava/Dbi.java           | 120 +++---
 src/main/java/org/lmdbjava/DbiBuilder.java    |   8 +-
 src/main/java/org/lmdbjava/Env.java           | 125 +++++-
 src/main/java/org/lmdbjava/FlagSet.java       |   1 +
 src/main/java/org/lmdbjava/Verifier.java      |   2 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     |  21 +-
 .../java/org/lmdbjava/CursorParamTest.java    |   2 +-
 src/test/java/org/lmdbjava/CursorTest.java    |  16 +-
 src/test/java/org/lmdbjava/DbiTest.java       |   8 +-
 src/test/java/org/lmdbjava/EnvTest.java       | 387 +++++++++---------
 src/test/java/org/lmdbjava/TutorialTest.java  |   2 +-
 12 files changed, 404 insertions(+), 290 deletions(-)

diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 69d43fcd..89dc5e84 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -115,7 +115,7 @@ public KeyVal<T> next() {
 
       @Override
       public void remove() {
-        cursor.delete();
+        cursor.delete(PutFlags.EMPTY);
       }
     };
   }
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 5e8fa2f2..7347605f 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -49,7 +49,6 @@
  */
 public final class Dbi<T> {
 
-  private final ComparatorCallback callbackComparator;
   private boolean cleaned;
   // Used for CursorIterable KeyRange testing and/or native callbacks
   private final Comparator<T> comparator;
@@ -59,6 +58,14 @@ public final class Dbi<T> {
   private final BufferProxy<T> proxy;
   private final DbiFlagSet dbiFlagSet;
 
+  Dbi(final Env<T> env,
+      final Txn<T> txn,
+      final byte[] name,
+      final BufferProxy<T> proxy,
+      final DbiFlagSet dbiFlagSet) {
+    this(env, txn, name, null, false, proxy, dbiFlagSet);
+  }
+
   Dbi(
       final Env<T> env,
       final Txn<T> txn,
@@ -67,7 +74,11 @@ public final class Dbi<T> {
       final boolean nativeCb,
       final BufferProxy<T> proxy,
       final DbiFlagSet dbiFlagSet) {
+
     if (SHOULD_CHECK) {
+      if (nativeCb && comparator == null) {
+        throw new IllegalArgumentException("Is nativeCb is true, you must supply a comparator");
+      }
       requireNonNull(txn);
       txn.checkReady();
     }
@@ -75,40 +86,32 @@ public final class Dbi<T> {
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
     this.proxy = proxy;
     this.comparator = comparator;
-    this.dbiFlagSet = dbiFlagSet;
+    this.dbiFlagSet = dbiFlagSet == null ? DbiFlagSet.EMPTY : dbiFlagSet;
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
-    checkRc(LIB.mdb_dbi_open(txn.pointer(), name, dbiFlagSet.getMask(), dbiPtr));
+    checkRc(LIB.mdb_dbi_open(txn.pointer(), name, this.dbiFlagSet.getMask(), dbiPtr));
     ptr = dbiPtr.getPointer(0);
+    ComparatorCallback callbackComparator;
     if (nativeCb) {
-      requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
       // LMDB will call back to this comparator for insertion/iteration order
-//      if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
-//        this.callbackComparator =
-//            (keyA, keyB) -> {
-//              final T compKeyA  = proxy.out(proxy.allocate(), keyA);
-//              final T compKeyB = proxy.out(proxy.allocate(), keyB);
-//              final int result = this.comparator.compare(compKeyA, compKeyB);
-//              proxy.deallocate(compKeyA);
-//              proxy.deallocate(compKeyB);
-//              return result;
-//            };
-//      } else {
-        this.callbackComparator =
-            (keyA, keyB) -> {
-              final T compKeyA  = proxy.out(proxy.allocate(), keyA);
-              final T compKeyB = proxy.out(proxy.allocate(), keyB);
-              final int result = this.comparator.compare(compKeyA, compKeyB);
-              proxy.deallocate(compKeyA);
-              proxy.deallocate(compKeyB);
-              return result;
-            };
-//      }
+      callbackComparator = createCallbackComparator(proxy);
       LIB.mdb_set_compare(txn.pointer(), ptr, callbackComparator);
-    } else {
-      callbackComparator = null;
     }
   }
 
+  private ComparatorCallback createCallbackComparator(BufferProxy<T> proxy) {
+    ComparatorCallback callbackComparator;
+    callbackComparator =
+        (keyA, keyB) -> {
+          final T compKeyA = proxy.out(proxy.allocate(), keyA);
+          final T compKeyB = proxy.out(proxy.allocate(), keyB);
+          final int result = this.comparator.compare(compKeyA, compKeyB);
+          proxy.deallocate(compKeyA);
+          proxy.deallocate(compKeyB);
+          return result;
+        };
+    return callbackComparator;
+  }
+
   Pointer pointer() {
     return ptr;
   }
@@ -215,7 +218,7 @@ public void drop(final Txn<T> txn) {
    * closed. See {@link #close()} for implication of handle close. Otherwise, only the data in this
    * database will be dropped.
    *
-   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param txn    transaction handle (not null; not committed; must be R-W)
    * @param delete whether database should be deleted.
    */
   public void drop(final Txn<T> txn, final boolean delete) {
@@ -311,7 +314,7 @@ public CursorIterable<T> iterate(final Txn<T> txn) {
   /**
    * Iterate the database in accordance with the provided {@link KeyRange}.
    *
-   * @param txn transaction handle (not null; not committed)
+   * @param txn   transaction handle (not null; not committed)
    * @param range range of acceptable keys (not null)
    * @return iterator (never null)
    */
@@ -392,6 +395,12 @@ public void put(final T key, final T val) {
   }
 
   /**
+   * @param txn   transaction handle (not null; not committed; must be R-W)
+   * @param key   key to store in the database (not null)
+   * @param val   value to store in the database (not null)
+   * @param flags Special options for this operation
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   * key/value existed already.
    * @deprecated Use {@link Dbi#put(Txn, Object, Object, PutFlagSet)} instead, with a statically
    * held {@link PutFlagSet}.
    * <hr>
@@ -401,13 +410,6 @@ public void put(final T key, final T val) {
    * <p>This function stores key/data pairs in the database. The default behavior is to enter the
    * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
    * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
-   *
-   * @param txn transaction handle (not null; not committed; must be R-W)
-   * @param key key to store in the database (not null)
-   * @param val value to store in the database (not null)
-   * @param flags Special options for this operation
-   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
-   *     key/value existed already.
    */
   @Deprecated
   public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags... flags) {
@@ -421,7 +423,7 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
-   *     key/value existed already.
+   * key/value existed already.
    * @see #put(Txn, Object, Object, PutFlagSet)
    */
   public boolean put(final Txn<T> txn, final T key, final T val) {
@@ -435,12 +437,12 @@ public boolean put(final Txn<T> txn, final T key, final T val) {
    * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
    * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
    *
-   * @param txn transaction handle (not null; not committed; must be R-W)
-   * @param key key to store in the database (not null)
-   * @param val value to store in the database (not null)
+   * @param txn   transaction handle (not null; not committed; must be R-W)
+   * @param key   key to store in the database (not null)
+   * @param val   value to store in the database (not null)
    * @param flags Special options for this operation.
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
-   *     key/value existed already.
+   * key/value existed already.
    */
   public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
@@ -480,10 +482,10 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet
    *
    * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    *
-   * @param txn transaction handle (not null; not committed; must be R-W)
-   * @param key key to store in the database (not null)
+   * @param txn  transaction handle (not null; not committed; must be R-W)
+   * @param key  key to store in the database (not null)
    * @param size size of the value to be stored in the database
-   * @param op options for this operation
+   * @param op   options for this operation
    * @return a buffer that can be used to modify the value
    */
   public T reserve(final Txn<T> txn, final T key, final int size, final PutFlags... op) {
@@ -544,12 +546,14 @@ public String toString() {
       name = "?";
     }
     return "Dbi{" +
-            "name='" + name +
-            "', dbiFlagSet=" + dbiFlagSet +
-            '}';
+        "name='" + name +
+        "', dbiFlagSet=" + dbiFlagSet +
+        '}';
   }
 
-  /** The specified DBI was changed unexpectedly. */
+  /**
+   * The specified DBI was changed unexpectedly.
+   */
   public static final class BadDbiException extends LmdbNativeException {
 
     static final int MDB_BAD_DBI = -30_780;
@@ -560,7 +564,9 @@ public static final class BadDbiException extends LmdbNativeException {
     }
   }
 
-  /** Unsupported size of key/DB name/data, or wrong DUPFIXED size. */
+  /**
+   * Unsupported size of key/DB name/data, or wrong DUPFIXED size.
+   */
   public static final class BadValueSizeException extends LmdbNativeException {
 
     static final int MDB_BAD_VALSIZE = -30_781;
@@ -571,7 +577,9 @@ public static final class BadValueSizeException extends LmdbNativeException {
     }
   }
 
-  /** Environment maxdbs reached. */
+  /**
+   * Environment maxdbs reached.
+   */
   public static final class DbFullException extends LmdbNativeException {
 
     static final int MDB_DBS_FULL = -30_791;
@@ -604,7 +612,9 @@ public static final class IncompatibleException extends LmdbNativeException {
     }
   }
 
-  /** Key/data pair already exists. */
+  /**
+   * Key/data pair already exists.
+   */
   public static final class KeyExistsException extends LmdbNativeException {
 
     static final int MDB_KEYEXIST = -30_799;
@@ -615,7 +625,9 @@ public static final class KeyExistsException extends LmdbNativeException {
     }
   }
 
-  /** Key/data pair not found (EOF). */
+  /**
+   * Key/data pair not found (EOF).
+   */
   public static final class KeyNotFoundException extends LmdbNativeException {
 
     static final int MDB_NOTFOUND = -30_798;
@@ -626,7 +638,9 @@ public static final class KeyNotFoundException extends LmdbNativeException {
     }
   }
 
-  /** Database contents grew beyond environment mapsize. */
+  /**
+   * Database contents grew beyond environment mapsize.
+   */
   public static final class MapResizedException extends LmdbNativeException {
 
     static final int MDB_MAP_RESIZED = -30_785;
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 9cb85616..062e77f4 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -391,10 +391,10 @@ public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
     public Dbi<T> open() {
       final DbiBuilder<T> dbiBuilder = dbiBuilderStage2.dbiBuilder;
       if (txn != null) {
-        return open(txn, dbiBuilder);
+        return openDbi(txn, dbiBuilder);
       } else {
         try (final Txn<T> txn = getTxn(dbiBuilder)) {
-          final Dbi<T> dbi = open(txn, dbiBuilder);
+          final Dbi<T> dbi = openDbi(txn, dbiBuilder);
           // even RO Txns require a commit to retain Dbi in Env
           txn.commit();
           return dbi;
@@ -432,8 +432,8 @@ private Comparator<T> getComparator(final DbiBuilder<T> dbiBuilder,
       return comparator;
     }
 
-    private Dbi<T> open(final Txn<T> txn,
-                        final DbiBuilder<T> dbiBuilder) {
+    private Dbi<T> openDbi(final Txn<T> txn,
+                           final DbiBuilder<T> dbiBuilder) {
       final DbiFlagSet dbiFlagSet = flagSetBuilder.build();
       final ComparatorType comparatorType = dbiBuilderStage2.comparatorType;
       final Comparator<T> comparator = getComparator(dbiBuilder, comparatorType, dbiFlagSet);
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index b8003cbb..e01de06b 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -63,6 +63,11 @@ public final class Env<T> implements AutoCloseable {
    */
   public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
 
+  private static final long KIBIBYTES = 1_024;
+  private static final long MEBIBYTES = KIBIBYTES * 1_024;
+  private static final long GIBIBYTES = MEBIBYTES * 1_024;
+  private static final long TEBIBYTES = GIBIBYTES * 1_024;
+
   private boolean closed;
   private final int maxKeySize;
   private final boolean noSubDir;
@@ -104,20 +109,19 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
   }
 
   /**
-   * @deprecated Instead use {@link Env#create()} or {@link Env#create(BufferProxy)}
-   * <p>
-   * Opens an environment with a single default database in 0664 mode using the {@link
-   * ByteBufferProxy#PROXY_OPTIMAL}.
-   *
    * @param path  file system destination
    * @param size  size in megabytes
    * @param flags the flags for this new environment
    * @return env the environment (never null)
+   * @deprecated Instead use {@link Env#create()} or {@link Env#create(BufferProxy)}
+   * <p>
+   * Opens an environment with a single default database in 0664 mode using the {@link
+   * ByteBufferProxy#PROXY_OPTIMAL}.
    */
   @Deprecated
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
     return new Builder<>(PROXY_OPTIMAL)
-        .setMapSize(size * 1_024L * 1_024L)
+        .setMapSize(size * MEBIBYTES)
         .open(path, flags);
   }
 
@@ -193,9 +197,10 @@ public void copy(final File path, final CopyFlagSet flags) {
    */
   public List<byte[]> getDbiNames() {
     final List<byte[]> result = new ArrayList<>();
-    final Dbi<T> names = openDbi((byte[]) null);
-    try (Txn<T> txn = txnRead();
-         Cursor<T> cursor = names.openCursor(txn)) {
+    // The unnamed DB is special so the names of the named DBs are held as keys in it.
+    final Dbi<T> unnamedDb = openDbi((byte[]) null, DbiFlagSet.EMPTY);
+    try (final Txn<T> txn = txnRead();
+         final Cursor<T> cursor = unnamedDb.openCursor(txn)) {
       if (!cursor.first()) {
         return Collections.emptyList();
       }
@@ -204,7 +209,6 @@ public List<byte[]> getDbiNames() {
         result.add(name);
       } while (cursor.next());
     }
-
     return result;
   }
 
@@ -282,11 +286,49 @@ public DbiBuilder<T> buildDbi() {
     return new DbiBuilder<>(this, proxy, readOnly);
   }
 
+  /**
+   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default
+   * {@link Comparator} that is not invoked from native code.
+   * <p>
+   * For more options when opening a {@link Dbi} see {@link Env#buildDbi()}.
+   * </p>
+   * @param name       name of the database (or null if no name is required)
+   * @param dbiFlagSet Flags to open the database with
+   * @return a database that is ready to use
+   */
+  public Dbi<T> openDbi(final String name, final DbiFlagSet dbiFlagSet) {
+    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
+    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
+      final Dbi<T> dbi = new Dbi<>(this, txn, nameBytes, proxy, dbiFlagSet);
+      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
+      return dbi;
+    }
+  }
+
+  /**
+   * Convenience method that opens a {@link Dbi} with a default
+   * {@link Comparator} that is not invoked from native code.
+   * <p>
+   * For more options when opening a {@link Dbi} see {@link Env#buildDbi()}.
+   * </p>
+   * @param name       name of the database (or null if no name is required)
+   * @param dbiFlagSet Flags to open the database with
+   * @return a database that is ready to use
+   */
+  public Dbi<T> openDbi(final byte[] name,
+                        final DbiFlagSet dbiFlagSet) {
+    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
+      final Dbi<T> dbi = new Dbi<>(this, txn, name, proxy, dbiFlagSet);
+      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
+      return dbi;
+    }
+  }
+
   /**
    * @param name  name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#buildDbi()} or {@link Env#openDbi(String, DbiFlagSet)}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
    * Comparator} that is not invoked from native code.
    */
@@ -315,7 +357,7 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   public Dbi<T> openDbi(final String name,
                         final Comparator<T> comparator,
                         final DbiFlags... flags) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
+    final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
     return openDbi(nameBytes, comparator, false, flags);
   }
 
@@ -338,7 +380,7 @@ public Dbi<T> openDbi(final String name,
                         final Comparator<T> comparator,
                         final boolean nativeCb,
                         final DbiFlags... flags) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
+    final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
     return openDbi(nameBytes, comparator, nativeCb, flags);
   }
 
@@ -354,7 +396,11 @@ public Dbi<T> openDbi(final String name,
   @Deprecated()
   public Dbi<T> openDbi(final byte[] name,
                         final DbiFlags... flags) {
-    return openDbi(name, null, false, flags);
+    return buildDbi()
+        .setDbName(name)
+        .withDefaultComparator()
+        .setDbiFlags(flags)
+        .open();
   }
 
   /**
@@ -371,7 +417,12 @@ public Dbi<T> openDbi(final byte[] name,
   public Dbi<T> openDbi(final byte[] name,
                         final Comparator<T> comparator,
                         final DbiFlags... flags) {
-    return openDbi(name, comparator, false, flags);
+    requireNonNull(comparator);
+    return buildDbi()
+        .setDbName(name)
+        .withIteratorComparator(ignored -> comparator)
+        .setDbiFlags(flags)
+        .open();
   }
 
   /**
@@ -435,10 +486,6 @@ public Dbi<T> openDbi(
       final Comparator<T> comparator,
       final boolean nativeCb,
       final DbiFlags... flags) {
-
-    if (nativeCb && comparator == null) {
-      throw new IllegalArgumentException("Is nativeCb is true, you must supply a comparator");
-    }
     return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
   }
 
@@ -724,6 +771,46 @@ public Builder<T> setMapSize(final long mapSize) {
       return this;
     }
 
+    /**
+     * Sets the map size in kibibytes
+     *
+     * @param mapSizeKb new limit in kibibytes
+     * @return the builder
+     */
+    public Builder<T> setMapSizeKb(final long mapSizeKb) {
+      return setMapSize(mapSizeKb * KIBIBYTES);
+    }
+
+    /**
+     * Sets the map size in mebibytes.
+     *
+     * @param mapSizeMb new limit in mebibytes.
+     * @return the builder
+     */
+    public Builder<T> setMapSizeMb(final long mapSizeMb) {
+      return setMapSize(mapSizeMb * MEBIBYTES);
+    }
+
+    /**
+     * Sets the map size in gibibytes
+     *
+     * @param mapSizeGb new limit in gibibytes
+     * @return the builder
+     */
+    public Builder<T> setMapSizeGb(final long mapSizeGb) {
+      return setMapSize(mapSizeGb * GIBIBYTES);
+    }
+
+    /**
+     * Sets the map size in tebibytes.
+     *
+     * @param mapSizeTb new limit in tebibytes.
+     * @return the builder
+     */
+    public Builder<T> setMapSizeTb(final long mapSizeTb) {
+      return setMapSize(mapSizeTb * TEBIBYTES);
+    }
+
     /**
      * Sets the maximum number of databases (ie {@link Dbi}s permitted.
      *
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index 27513fcd..a9cffd47 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -88,6 +88,7 @@ default boolean isEmpty() {
   /**
    * @return The {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
    */
+  @Override
   default Iterator<T> iterator() {
     return getFlags().iterator();
   }
diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index ff9b28f8..cbe99b81 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -175,7 +175,7 @@ private void createDbis() {
 
   private void deleteDbis() {
     for (final byte[] existingDbiName : env.getDbiNames()) {
-      final Dbi<ByteBuffer> existingDbi = env.openDbi(existingDbiName);
+      final Dbi<ByteBuffer> existingDbi = env.openDbi(existingDbiName, DbiFlagSet.EMPTY);
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         existingDbi.drop(txn, true);
         txn.commit();
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index dc034f7f..e035911b 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -155,29 +155,32 @@ void unsafeIsDefault() {
    */
   @Test
   public void comparatorPerformance() {
-    final Random random = new Random();
+    final Random random = new Random(345098);
     final ByteBuffer buffer1 = ByteBuffer.allocateDirect(Long.BYTES);
     final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
     buffer1.limit(Long.BYTES);
     buffer2.limit(Long.BYTES);
-    final long[] values = random.longs(5_000_000).toArray();
+    final long[] values = random.longs(20_000_000).toArray();
 
     Instant time = Instant.now();
+    // x is to ensure result is used by the jvm
     int x = 0;
     for (int rounds = 0; rounds < 100; rounds++) {
       for (int i = 1; i < values.length; i++) {
-        buffer1.order(ByteOrder.nativeOrder())
+//        buffer1.order(ByteOrder.nativeOrder())
+        buffer1
             .putLong(0, values[i - 1]);
-        buffer2.order(ByteOrder.nativeOrder())
+//        buffer2.order(ByteOrder.nativeOrder())
+        buffer2
             .putLong(0, values[i]);
         final int result = ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
         x += result;
       }
     }
-    System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()));
+    System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()) + ", x: " + x);
 
     time = Instant.now();
-    x = 0;
+    int y = 0;
     for (int rounds = 0; rounds < 100; rounds++) {
       for (int i = 1; i < values.length; i++) {
         buffer1.order(BIG_ENDIAN)
@@ -185,10 +188,12 @@ public void comparatorPerformance() {
         buffer2.order(BIG_ENDIAN)
             .putLong(0, values[i]);
         final int result = ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
-        x += result;
+        y += result;
       }
     }
-    System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()));
+    System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()) + ", y: " + y);
+
+    assertThat(y).isEqualTo(x);
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 1a3604be..5b701382 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -88,7 +88,7 @@ protected AbstractBufferRunner(final BufferProxy<T> proxy) {
     public final void execute(final Path tmp) {
       try (Env<T> env = env(tmp)) {
         assertThat(env.getDbiNames()).isEmpty();
-        final Dbi<T> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+        final Dbi<T> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
         assertThat(env.getDbiNames().get(0)).isEqualTo(DB_1.getBytes(UTF_8));
         try (Txn<T> txn = env.txnWrite();
             Cursor<T> c = db.openCursor(txn)) {
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index a0c78855..41893ae6 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -175,7 +175,7 @@ void closedEnvRejectsDeleteCall() {
 
   @Test
   void count() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_APPENDDUP);
@@ -193,7 +193,7 @@ void count() {
   void cursorCannotCloseIfTransactionCommitted() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
               try (Txn<ByteBuffer> txn = env.txnWrite()) {
                 try (Cursor<ByteBuffer> c = db.openCursor(txn); ) {
                   c.put(bb(1), bb(2), MDB_APPENDDUP);
@@ -238,7 +238,7 @@ void cursorFirstLastNextPrev() {
 
   @Test
   void delete() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_NOOVERWRITE);
@@ -257,7 +257,7 @@ void delete() {
 
   @Test
   void getKeyVal() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_APPENDDUP);
@@ -278,7 +278,7 @@ void getKeyVal() {
 
   @Test
   void putMultiple() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED));
     final int elemCount = 20;
 
     final ByteBuffer values = allocateDirect(Integer.BYTES * elemCount);
@@ -300,7 +300,7 @@ void putMultiple() {
   void putMultipleWithoutMdbMultipleFlag() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
               try (Txn<ByteBuffer> txn = env.txnWrite();
                   Cursor<ByteBuffer> c = db.openCursor(txn)) {
                 c.putMultiple(bb(100), bb(1), 1);
@@ -345,7 +345,7 @@ void renewTxRw() {
 
   @Test
   void repeatedCloseCausesNotError() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final Cursor<ByteBuffer> c = db.openCursor(txn);
       c.close();
@@ -375,7 +375,7 @@ void reserve() {
 
   @Test
   void returnValueForNoDupData() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       // ok
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 7302018c..3e876f67 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -264,7 +264,7 @@ void drop() {
   @Test
   void dropAndDelete() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null);
+    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null, DbiFlagSet.EMPTY);
     final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
     final ByteBuffer dbNameBuffer = allocateDirect(dbNameBytes.length);
     dbNameBuffer.put(dbNameBytes).flip();
@@ -321,7 +321,7 @@ void getNamesWhenEmpty() {
 
   @Test
   void listsFlags() {
-    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY);
+    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY));
 
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       final List<DbiFlags> flags = dbi.listFlags(txn);
@@ -415,7 +415,7 @@ void putDelete() {
 
   @Test
   void putDuplicateDelete() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
@@ -474,7 +474,7 @@ void putZeroByteValueForNonMdbDupSortDatabase() {
 
   @Test
   void returnValueForNoDupData() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       // ok
       assertThat(db.put(txn, bb(5), bb(6), MDB_NODUPDATA)).isTrue();
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 87edd049..eb925b42 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -24,8 +24,6 @@
 import static org.lmdbjava.CopyFlags.MDB_CP_COMPACT;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.Builder.MAX_READERS_DEFAULT;
-import static org.lmdbjava.Env.create;
-import static org.lmdbjava.Env.open;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.TestUtils.DB_1;
@@ -45,7 +43,9 @@
 import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.Txn.BadReaderLockException;
 
-/** Test {@link Env}. */
+/**
+ * Test {@link Env}.
+ */
 public final class EnvTest {
 
   @Test
@@ -53,10 +53,10 @@ void byteUnit() {
     FileUtil.useTempFile(
         file -> {
           try (Env<ByteBuffer> env =
-              create()
-                  .setMaxReaders(1)
-                  .setMapSize(MEBIBYTES.toBytes(1))
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
+                   Env.create()
+                       .setMaxReaders(1)
+                       .setMapSize(MEBIBYTES.toBytes(1))
+                       .open(file.toFile(), MDB_NOSUBDIR)) {
             final EnvInfo info = env.info();
             assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
           }
@@ -66,116 +66,116 @@ void byteUnit() {
   @Test
   void cannotChangeMapSizeAfterOpen() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
-                      builder.setMapSize(1);
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+                try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                  builder.setMapSize(1);
+                }
+              });
+        })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotChangeMaxDbsAfterOpen() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
-                      builder.setMaxDbs(1);
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+                try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                  builder.setMaxDbs(1);
+                }
+              });
+        })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotChangeMaxReadersAfterOpen() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
-                      builder.setMaxReaders(1);
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+                try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                  builder.setMaxReaders(1);
+                }
+              });
+        })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotInfoOnceClosed() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
-                    env.close();
-                    env.info();
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Env<ByteBuffer> env =
+                    Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                env.close();
+                env.info();
+              });
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void cannotOpenTwice() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    builder.open(file.toFile(), MDB_NOSUBDIR).close();
-                    builder.open(file.toFile(), MDB_NOSUBDIR);
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+                builder.open(file.toFile(), MDB_NOSUBDIR).close();
+                builder.open(file.toFile(), MDB_NOSUBDIR);
+              });
+        })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotOverflowMapSize() {
     assertThatThrownBy(
-            () -> {
-              final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-              final int mb = 1_024 * 1_024;
-              final int size = mb * 2_048; // as per issue 18
-              builder.setMapSize(size);
-            })
+        () -> {
+          final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+          final int mb = 1_024 * 1_024;
+          final int size = mb * 2_048; // as per issue 18
+          builder.setMapSize(size);
+        })
         .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
   void cannotStatOnceClosed() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
-                    env.close();
-                    env.stat();
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Env<ByteBuffer> env =
+                    Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                env.close();
+                env.stat();
+              });
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void cannotSyncOnceClosed() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
-                    env.close();
-                    env.sync(false);
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Env<ByteBuffer> env =
+                    Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                env.close();
+                env.sync(false);
+              });
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
@@ -188,7 +188,7 @@ void copyDirectoryBased() {
           assertThat(FileUtil.count(dest)).isEqualTo(0);
           FileUtil.useTempDir(
               src -> {
-                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
+                try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
                   env.copy(dest.toFile(), MDB_CP_COMPACT);
                   assertThat(FileUtil.count(dest)).isEqualTo(1);
                 }
@@ -199,66 +199,66 @@ void copyDirectoryBased() {
   @Test
   void copyDirectoryRejectsFileDestination() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempDir(
-                  dest -> {
-                    FileUtil.deleteDir(dest);
-                    FileUtil.useTempDir(
-                        src -> {
-                          try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-                            env.copy(dest.toFile(), MDB_CP_COMPACT);
-                          }
-                        });
-                  });
-            })
+        () -> {
+          FileUtil.useTempDir(
+              dest -> {
+                FileUtil.deleteDir(dest);
+                FileUtil.useTempDir(
+                    src -> {
+                      try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+                        env.copy(dest.toFile(), MDB_CP_COMPACT);
+                      }
+                    });
+              });
+        })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
   void copyDirectoryRejectsMissingDestination() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempDir(
-                  dest -> {
-                    try {
-                      Files.delete(dest);
-                      FileUtil.useTempDir(
-                          src -> {
-                            try (Env<ByteBuffer> env =
-                                create().setMaxReaders(1).open(src.toFile())) {
-                              env.copy(dest.toFile(), MDB_CP_COMPACT);
-                            }
-                          });
-                    } catch (final IOException e) {
-                      throw new UncheckedIOException(e);
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempDir(
+              dest -> {
+                try {
+                  Files.delete(dest);
+                  FileUtil.useTempDir(
+                      src -> {
+                        try (Env<ByteBuffer> env =
+                                 Env.create().setMaxReaders(1).open(src.toFile())) {
+                          env.copy(dest.toFile(), MDB_CP_COMPACT);
+                        }
+                      });
+                } catch (final IOException e) {
+                  throw new UncheckedIOException(e);
+                }
+              });
+        })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
   void copyDirectoryRejectsNonEmptyDestination() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempDir(
-                  dest -> {
-                    try {
-                      final Path subDir = dest.resolve("hello");
-                      Files.createDirectory(subDir);
-                      assertThat(Files.isDirectory(subDir)).isTrue();
-                      FileUtil.useTempDir(
-                          src -> {
-                            try (Env<ByteBuffer> env =
-                                create().setMaxReaders(1).open(src.toFile())) {
-                              env.copy(dest.toFile(), MDB_CP_COMPACT);
-                            }
-                          });
-                    } catch (final IOException e) {
-                      throw new UncheckedIOException(e);
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempDir(
+              dest -> {
+                try {
+                  final Path subDir = dest.resolve("hello");
+                  Files.createDirectory(subDir);
+                  assertThat(Files.isDirectory(subDir)).isTrue();
+                  FileUtil.useTempDir(
+                      src -> {
+                        try (Env<ByteBuffer> env =
+                                 Env.create().setMaxReaders(1).open(src.toFile())) {
+                          env.copy(dest.toFile(), MDB_CP_COMPACT);
+                        }
+                      });
+                } catch (final IOException e) {
+                  throw new UncheckedIOException(e);
+                }
+              });
+        })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
@@ -271,7 +271,7 @@ void copyFileBased() {
           FileUtil.useTempFile(
               src -> {
                 try (Env<ByteBuffer> env =
-                    create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                         Env.create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
                   env.copy(dest.toFile(), MDB_CP_COMPACT);
                 }
                 assertThat(FileUtil.size(dest)).isGreaterThan(0L);
@@ -282,19 +282,19 @@ void copyFileBased() {
   @Test
   void copyFileRejectsExistingDestination() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  dest -> {
-                    assertThat(Files.exists(dest)).isTrue();
-                    FileUtil.useTempFile(
-                        src -> {
-                          try (Env<ByteBuffer> env =
-                              create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
-                            env.copy(dest.toFile(), MDB_CP_COMPACT);
-                          }
-                        });
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              dest -> {
+                assertThat(Files.exists(dest)).isTrue();
+                FileUtil.useTempFile(
+                    src -> {
+                      try (Env<ByteBuffer> env =
+                               Env.create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                        env.copy(dest.toFile(), MDB_CP_COMPACT);
+                      }
+                    });
+              });
+        })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
@@ -302,7 +302,7 @@ void copyFileRejectsExistingDestination() {
   void createAsDirectory() {
     FileUtil.useTempDir(
         dest -> {
-          final Env<ByteBuffer> env = create().setMaxReaders(1).open(dest.toFile());
+          final Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(dest.toFile());
           assertThat(Files.isDirectory(dest)).isTrue();
           env.sync(false);
           env.close();
@@ -316,11 +316,11 @@ void createAsFile() {
     FileUtil.useTempFile(
         file -> {
           try (Env<ByteBuffer> env =
-              create()
-                  .setMapSize(MEBIBYTES.toBytes(1))
-                  .setMaxDbs(1)
-                  .setMaxReaders(1)
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
+                   Env.create()
+                       .setMapSize(MEBIBYTES.toBytes(1))
+                       .setMaxDbs(1)
+                       .setMaxReaders(1)
+                       .open(file.toFile(), MDB_NOSUBDIR)) {
             env.sync(true);
             assertThat(Files.isRegularFile(file)).isTrue();
           }
@@ -330,16 +330,16 @@ void createAsFile() {
   @Test
   void detectTransactionThreadViolation() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    try (Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
-                      env.txnRead();
-                      env.txnRead();
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                try (Env<ByteBuffer> env =
+                         Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+                  env.txnRead();
+                  env.txnRead();
+                }
+              });
+        })
         .isInstanceOf(BadReaderLockException.class);
   }
 
@@ -348,7 +348,7 @@ void info() {
     FileUtil.useTempFile(
         file -> {
           try (Env<ByteBuffer> env =
-              create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
+                   Env.create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
             final EnvInfo info = env.info();
             assertThat(info).isNotNull();
             assertThat(info.lastPageNumber).isEqualTo(1L);
@@ -366,30 +366,30 @@ void info() {
   @Test
   void mapFull() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempDir(
-                  dir -> {
-                    final byte[] k = new byte[500];
-                    final ByteBuffer key = allocateDirect(500);
-                    final ByteBuffer val = allocateDirect(1_024);
-                    final Random rnd = new Random();
-                    try (Env<ByteBuffer> env =
-                        create()
-                            .setMaxReaders(1)
-                            .setMapSize(MEBIBYTES.toBytes(8))
-                            .setMaxDbs(1)
-                            .open(dir.toFile())) {
-                      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-                      for (; ; ) {
-                        rnd.nextBytes(k);
-                        key.clear();
-                        key.put(k).flip();
-                        val.clear();
-                        db.put(key, val);
-                      }
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempDir(
+              dir -> {
+                final byte[] k = new byte[500];
+                final ByteBuffer key = allocateDirect(500);
+                final ByteBuffer val = allocateDirect(1_024);
+                final Random rnd = new Random();
+                try (Env<ByteBuffer> env =
+                         Env.create()
+                             .setMaxReaders(1)
+                             .setMapSize(MEBIBYTES.toBytes(8))
+                             .setMaxDbs(1)
+                             .open(dir.toFile())) {
+                  final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                  for (; ; ) {
+                    rnd.nextBytes(k);
+                    key.clear();
+                    key.put(k).flip();
+                    val.clear();
+                    db.put(key, val);
+                  }
+                }
+              });
+        })
         .isInstanceOf(MapFullException.class);
   }
 
@@ -397,13 +397,17 @@ void mapFull() {
   void readOnlySupported() {
     FileUtil.useTempDir(
         dir -> {
-          try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(dir.toFile())) {
+          try (Env<ByteBuffer> rwEnv = Env.create()
+              .setMaxReaders(1)
+              .open(dir)) {
             final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
             rwDb.put(bb(1), bb(42));
           }
-          try (Env<ByteBuffer> roEnv =
-              create().setMaxReaders(1).open(dir.toFile(), MDB_RDONLY_ENV)) {
-            final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
+          try (Env<ByteBuffer> roEnv = Env.create()
+              .setMaxReaders(1)
+              .setEnvFlags(MDB_RDONLY_ENV)
+              .open(dir)) {
+            final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1, DbiFlagSet.EMPTY);
             try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
               assertThat(roDb.get(roTxn, bb(1))).isNotNull();
             }
@@ -420,11 +424,11 @@ void setMapSize() {
           final ByteBuffer val = allocateDirect(1_024);
           final Random rnd = new Random();
           try (Env<ByteBuffer> env =
-              create()
-                  .setMaxReaders(1)
-                  .setMapSize(KIBIBYTES.toBytes(256))
-                  .setMaxDbs(1)
-                  .open(dir.toFile())) {
+                   Env.create()
+                       .setMaxReaders(1)
+                       .setMapSize(KIBIBYTES.toBytes(256))
+                       .setMaxDbs(1)
+                       .open(dir)) {
             final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
             db.put(bb(1), bb(42));
@@ -471,7 +475,10 @@ void setMapSize() {
   void stats() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env = create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+          try (Env<ByteBuffer> env = Env.create()
+              .setMaxReaders(1)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
             final Stat stat = env.stat();
             assertThat(stat).isNotNull();
             assertThat(stat.branchPages).isEqualTo(0L);
@@ -489,7 +496,7 @@ void stats() {
   void testDefaultOpen() {
     FileUtil.useTempDir(
         dir -> {
-          try (Env<ByteBuffer> env = open(dir.toFile(), 10)) {
+          try (Env<ByteBuffer> env = Env.create().setMapSizeMb(10).open(dir)) {
             final EnvInfo info = env.info();
             assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
             final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 1b42b327..35e2c169 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -345,7 +345,7 @@ void tutorial5() {
 
           // This time we're going to tell the Dbi it can store > 1 value per key.
           // There are other flags available if we're storing integers etc.
-          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE, MDB_DUPSORT);
+          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
 
           // Duplicate support requires both keys and values to be <= max key size.
           final ByteBuffer key = allocateDirect(env.getMaxKeySize());

From 77a3494a4008a516b2d1c3fe517b3171b638fac3 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 5 Nov 2025 21:35:51 +0000
Subject: [PATCH 32/90] Fix failing test

---
 src/main/java/org/lmdbjava/Cursor.java        |  2 --
 src/main/java/org/lmdbjava/Dbi.java           | 28 +++++++++----------
 src/main/java/org/lmdbjava/DbiBuilder.java    |  5 ++--
 .../CursorIterableIntegerKeyTest.java         | 20 ++++++-------
 4 files changed, 25 insertions(+), 30 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 127fffc0..245a5a9a 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -110,8 +110,6 @@ public void delete(final PutFlags... flags) {
   }
 
   /**
-   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}.
-   * <hr>
    * Delete current key/data pair.
    *
    * <p>This function deletes the key/data pair to which the cursor refers.
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 7347605f..65527224 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -49,6 +49,8 @@
  */
 public final class Dbi<T> {
 
+  @SuppressWarnings("FieldCanBeLocal") // Needs to be instance variable for FFI
+  private final ComparatorCallback callbackComparator;
   private boolean cleaned;
   // Used for CursorIterable KeyRange testing and/or native callbacks
   private final Comparator<T> comparator;
@@ -90,26 +92,24 @@ public final class Dbi<T> {
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
     checkRc(LIB.mdb_dbi_open(txn.pointer(), name, this.dbiFlagSet.getMask(), dbiPtr));
     ptr = dbiPtr.getPointer(0);
-    ComparatorCallback callbackComparator;
     if (nativeCb) {
       // LMDB will call back to this comparator for insertion/iteration order
-      callbackComparator = createCallbackComparator(proxy);
+      this.callbackComparator = createCallbackComparator(proxy);
       LIB.mdb_set_compare(txn.pointer(), ptr, callbackComparator);
+    } else {
+      callbackComparator = null;
     }
   }
 
-  private ComparatorCallback createCallbackComparator(BufferProxy<T> proxy) {
-    ComparatorCallback callbackComparator;
-    callbackComparator =
-        (keyA, keyB) -> {
-          final T compKeyA = proxy.out(proxy.allocate(), keyA);
-          final T compKeyB = proxy.out(proxy.allocate(), keyB);
-          final int result = this.comparator.compare(compKeyA, compKeyB);
-          proxy.deallocate(compKeyA);
-          proxy.deallocate(compKeyB);
-          return result;
-        };
-    return callbackComparator;
+  private ComparatorCallback createCallbackComparator(final BufferProxy<T> proxy) {
+    return (keyA, keyB) -> {
+      final T compKeyA = proxy.out(proxy.allocate(), keyA);
+      final T compKeyB = proxy.out(proxy.allocate(), keyB);
+      final int result = this.comparator.compare(compKeyA, compKeyB);
+      proxy.deallocate(compKeyA);
+      proxy.deallocate(compKeyB);
+      return result;
+    };
   }
 
   Pointer pointer() {
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 062e77f4..1abff0a2 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -420,9 +420,8 @@ private Comparator<T> getComparator(final DbiBuilder<T> dbiBuilder,
           break;
         case CALLBACK:
         case ITERATOR:
-          comparator = Objects.requireNonNull(
-              dbiBuilderStage2.comparatorFactory.create(dbiFlagSet),
-              () -> "comparatorFactory returned null");
+          comparator = dbiBuilderStage2.comparatorFactory.create(dbiFlagSet);
+          Objects.requireNonNull(comparator, "comparatorFactory returned null");
           break;
         case NATIVE:
           break;
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index a0d9ab0c..87f7a952 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -234,18 +234,16 @@ public void testIntegerKeyKeySize() {
       db.put(txn, bbNative(Long.MAX_VALUE), bb("val_" + ++val));
       txn.commit();
     }
-
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      try (CursorIterable<ByteBuffer> iterable = db.iterate(txn)) {
-        for (KeyVal<ByteBuffer> keyVal : iterable) {
-          final String val = getString(keyVal.val());
-          final long key = getNativeLong(keyVal.key());
-          final int remaining = keyVal.key().remaining();
+//    try (Txn<ByteBuffer> txn = env.txnRead()) {
+//      try (CursorIterable<ByteBuffer> iterable = db.iterate(txn)) {
+//        for (KeyVal<ByteBuffer> keyVal : iterable) {
+//          final String val = getString(keyVal.val());
+//          final long key = getNativeLong(keyVal.key());
+//          final int remaining = keyVal.key().remaining();
 //          System.out.println("key: " + key + ", val: " + val + ", remaining: " + remaining);
-        }
-      }
-    }
-
+//        }
+//      }
+//    }
   }
 
   @Test

From 1d46e0b09251767be3f730a37c981535d1a11d5d Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 10:24:19 +0000
Subject: [PATCH 33/90] Refactor deprecated method calls

---
 src/main/java/org/lmdbjava/Env.java           |   8 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     |  64 +++--
 .../CursorIterableIntegerDupTest.java         |  42 +--
 .../CursorIterableIntegerKeyTest.java         |   6 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  |  27 +-
 .../java/org/lmdbjava/CursorParamTest.java    |   4 +-
 src/test/java/org/lmdbjava/CursorTest.java    |   4 +-
 src/test/java/org/lmdbjava/DbiTest.java       | 244 +++++++++---------
 src/test/java/org/lmdbjava/EnvTest.java       |  83 ++++--
 .../org/lmdbjava/GarbageCollectionTest.java   |   6 +-
 src/test/java/org/lmdbjava/TutorialTest.java  |  82 +++---
 src/test/java/org/lmdbjava/TxnTest.java       |  10 +-
 12 files changed, 308 insertions(+), 272 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index e01de06b..7ccebb4e 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -63,10 +63,10 @@ public final class Env<T> implements AutoCloseable {
    */
   public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
 
-  private static final long KIBIBYTES = 1_024;
-  private static final long MEBIBYTES = KIBIBYTES * 1_024;
-  private static final long GIBIBYTES = MEBIBYTES * 1_024;
-  private static final long TEBIBYTES = GIBIBYTES * 1_024;
+  private static final long KIBIBYTES = 1_024L;
+  private static final long MEBIBYTES = KIBIBYTES * 1_024L;
+  private static final long GIBIBYTES = MEBIBYTES * 1_024L;
+  private static final long TEBIBYTES = GIBIBYTES * 1_024L;
 
   private boolean closed;
   private final int maxKeySize;
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index e035911b..a91fbf75 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -148,11 +148,6 @@ void unsafeIsDefault() {
     assertThat(v.getClass().getSimpleName()).startsWith("Unsafe");
   }
 
-  /**
-   * For 100 rounds of 5,000,000 comparisons
-   * compareAsIntegerKeys: PT1.600525631S
-   * compareLexicographically: PT3.381935001S
-   */
   @Test
   public void comparatorPerformance() {
     final Random random = new Random(345098);
@@ -160,40 +155,41 @@ public void comparatorPerformance() {
     final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
     buffer1.limit(Long.BYTES);
     buffer2.limit(Long.BYTES);
-    final long[] values = random.longs(20_000_000).toArray();
+    final long[] values = random.longs(10_000_000).toArray();
+    final int rounds = 100;
 
-    Instant time = Instant.now();
-    // x is to ensure result is used by the jvm
-    int x = 0;
-    for (int rounds = 0; rounds < 100; rounds++) {
-      for (int i = 1; i < values.length; i++) {
-//        buffer1.order(ByteOrder.nativeOrder())
-        buffer1
-            .putLong(0, values[i - 1]);
-//        buffer2.order(ByteOrder.nativeOrder())
-        buffer2
-            .putLong(0, values[i]);
-        final int result = ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
-        x += result;
+    for (int run = 0; run < 3; run++) {
+      Instant time = Instant.now();
+      // x is to ensure result is used by the jvm
+      int x = 0;
+      for (int round = 0; round < rounds; round++) {
+        for (int i = 1; i < values.length; i++) {
+          buffer1.order(ByteOrder.nativeOrder())
+              .putLong(0, values[i - 1]);
+          buffer2.order(ByteOrder.nativeOrder())
+              .putLong(0, values[i]);
+          final int result = ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
+          x += result;
+        }
       }
-    }
-    System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()) + ", x: " + x);
+      System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()) + ", x: " + x);
 
-    time = Instant.now();
-    int y = 0;
-    for (int rounds = 0; rounds < 100; rounds++) {
-      for (int i = 1; i < values.length; i++) {
-        buffer1.order(BIG_ENDIAN)
-            .putLong(0, values[i - 1]);
-        buffer2.order(BIG_ENDIAN)
-            .putLong(0, values[i]);
-        final int result = ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
-        y += result;
+      time = Instant.now();
+      int y = 0;
+      for (int round = 0; round < rounds; round++) {
+        for (int i = 1; i < values.length; i++) {
+          buffer1.order(BIG_ENDIAN)
+              .putLong(0, values[i - 1]);
+          buffer2.order(BIG_ENDIAN)
+              .putLong(0, values[i]);
+          final int result = ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
+          y += result;
+        }
       }
-    }
-    System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()) + ", y: " + y);
+      System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()) + ", y: " + y);
 
-    assertThat(y).isEqualTo(x);
+      assertThat(y).isEqualTo(x);
+    }
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 775ac4bc..1098ca5c 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -44,7 +44,6 @@
 import static org.lmdbjava.TestUtils.DB_2;
 import static org.lmdbjava.TestUtils.DB_3;
 import static org.lmdbjava.TestUtils.DB_4;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.bbNative;
 import static org.lmdbjava.TestUtils.getNativeInt;
@@ -63,7 +62,6 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
-import java.util.NoSuchElementException;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -87,7 +85,7 @@
  */
 @Disabled // Waiting for the merge of stroomdev66's cursor tests
 @ParameterizedClass(name = "{index}: dbi: {0}")
-@ArgumentsSource(CursorIterableTest.MyArgumentProvider.class)
+@ArgumentsSource(CursorIterableIntegerDupTest.MyArgumentProvider.class)
 public final class CursorIterableIntegerDupTest {
 
   private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(
@@ -128,7 +126,8 @@ public void before() throws IOException {
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
             .setMaxDbs(3)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
 
     populateExpectedEntriesDeque();
   }
@@ -187,16 +186,15 @@ private void populateDatabase(final Dbi<ByteBuffer> dbi) {
       }
       txn.commit();
     }
-
-    try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
-
+//    try (Txn<ByteBuffer> txn = env.txnRead();
+//         CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
+//
 //      for (final KeyVal<ByteBuffer> kv : c) {
 //        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
 //        System.out.print(", ");
 //      }
 //      System.out.println();
-    }
+//    }
   }
 
   private int[] rangeInc(final int fromInc, final int toInc) {
@@ -278,6 +276,7 @@ public void iterate() {
 
       for (final KeyVal<ByteBuffer> kv : c) {
         final Map.Entry<Integer, Integer> entry = expectedEntriesDeque.pollFirst();
+        assertThat(entry).isNotNull();
 //        System.out.println(entry.getKey() + " => " + entry.getValue());
         assertThat(getNativeInt(kv.key())).isEqualTo(entry.getKey());
         assertThat(kv.val().getInt()).isEqualTo(entry.getValue());
@@ -308,24 +307,6 @@ public void lessThanTest() {
     verify(lessThan(bbNative(8)), 2, 4, 6);
   }
 
-  public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
-    Assertions.assertThatThrownBy(() -> {
-      populateExpectedEntriesDeque();
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
-        while (i.hasNext()) {
-          final KeyVal<ByteBuffer> kv = i.next();
-          assertThat(getNativeInt(kv.key())).isEqualTo(expectedEntriesDeque.pollFirst().getKey());
-          assertThat(kv.val().getInt()).isEqualTo(expectedEntriesDeque.pollFirst().getValue());
-        }
-        assertThat(i.hasNext()).isEqualTo(false);
-        i.next();
-      }
-    }).isInstanceOf(NoSuchElementException.class);
-  }
-
   @Test
   public void openBackwardTest() {
     verify(openBackward(bbNative(7), bbNative(2)), 6, 4);
@@ -355,7 +336,12 @@ public void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+
+    final Dbi<ByteBuffer> guavaDbi = env.buildDbi()
+        .setDbName(DB_1).withIteratorComparator(ignored -> comparator)
+        .setDbiFlags(MDB_CREATE)
+        .open();
+
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
     verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 87f7a952..007b5e29 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -432,7 +432,11 @@ public void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    final Dbi<ByteBuffer> guavaDbi = env.buildDbi()
+        .setDbName(DB_1)
+        .withIteratorComparator(ignored -> comparator)
+        .setDbiFlags(MDB_CREATE)
+        .open();
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
     verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index e0a40fd9..80555966 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -21,7 +21,6 @@
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.PutFlags.MDB_APPEND;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
 import java.io.IOException;
@@ -39,17 +38,12 @@
 
 public class CursorIterablePerfTest {
 
-  //    private static final int ITERATIONS = 5_000_000;
   private static final int ITERATIONS = 100_000;
-  //    private static final int ITERATIONS = 10;
 
-  private Path file;
-  private Dbi<ByteBuffer> dbJavaComparator;
-  private Dbi<ByteBuffer> dbLmdbComparator;
-  private Dbi<ByteBuffer> dbCallbackComparator;
-  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private final List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private final List<Integer> data = new ArrayList<>(ITERATIONS);
   private Env<ByteBuffer> env;
-  private List<Integer> data = new ArrayList<>(ITERATIONS);
+  private Path file;
 
   @BeforeEach
   public void before() throws IOException {
@@ -60,24 +54,25 @@ public void before() throws IOException {
             .setMapSize(GIBIBYTES.toBytes(1))
             .setMaxReaders(1)
             .setMaxDbs(3)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
 
     final DbiFlagSet dbiFlagSet = MDB_CREATE;
     // Use a java comparator for start/stop keys only
-    dbJavaComparator = env.buildDbi()
+    Dbi<ByteBuffer> dbJavaComparator = env.buildDbi()
         .setDbName("JavaComparator")
         .withDefaultComparator()
         .setDbiFlags(dbiFlagSet)
         .open();
     // Use LMDB comparator for start/stop keys
-    dbLmdbComparator = env.buildDbi()
+    Dbi<ByteBuffer> dbLmdbComparator = env.buildDbi()
         .setDbName("LmdbComparator")
         .withNativeComparator()
         .setDbiFlags(dbiFlagSet)
         .open();
 
     // Use a java comparator for start/stop keys and as a callback comparator
-    dbCallbackComparator = env.buildDbi()
+    Dbi<ByteBuffer> dbCallbackComparator = env.buildDbi()
         .setDbName("CallBackComparator")
         .withCallbackComparator(bufferProxy::getComparator)
         .setDbiFlags(dbiFlagSet)
@@ -171,14 +166,14 @@ public void comparePerf(final boolean randomOrder) {
     for (int round = 0; round < 3; round++) {
       System.out.println("round: " + round + " -----------------------------------------");
       for (final Dbi<ByteBuffer> db : dbs) {
-        final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+        final String dbName = db.getNameAsString();
 
         final Instant start = Instant.now();
         int cnt = 0;
         // Exercise the stop key comparator on every entry
         try (Txn<ByteBuffer> txn = env.txnRead();
-            CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
-          for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+            CursorIterable<ByteBuffer> cursorIterable = db.iterate(txn, keyRange)) {
+          for (final CursorIterable.KeyVal<ByteBuffer> ignored : cursorIterable) {
             cnt++;
           }
         }
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 5b701382..4dd52b6f 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -37,7 +37,6 @@
 import static org.lmdbjava.SeekOp.MDB_NEXT;
 import static org.lmdbjava.SeekOp.MDB_PREV;
 import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.mdb;
 import static org.lmdbjava.TestUtils.nb;
@@ -162,7 +161,8 @@ private Env<T> env(final Path tmp) {
           .setMapSize(MEBIBYTES.toBytes(1))
           .setMaxReaders(1)
           .setMaxDbs(1)
-          .open(tmp.resolve("db").toFile(), POSIX_MODE, MDB_NOSUBDIR);
+          .setEnvFlags(MDB_NOSUBDIR)
+          .open(tmp.resolve("db"));
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 41893ae6..9126026f 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -37,7 +37,6 @@
 import static org.lmdbjava.SeekOp.MDB_LAST;
 import static org.lmdbjava.SeekOp.MDB_NEXT;
 import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
 import java.nio.ByteBuffer;
@@ -65,7 +64,8 @@ void beforeEach() {
             .setMapSize(MEBIBYTES.toBytes(1))
             .setMaxReaders(1)
             .setMaxDbs(1)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
   }
 
   @AfterEach
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 3e876f67..95da87a4 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -108,16 +108,16 @@ void afterEach() {
   @Test
   void close() {
     assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = env.buildDbi()
-                  .setDbName(DB_1)
-                  .withDefaultComparator()
-                  .addDbiFlag(MDB_CREATE)
-                  .open();
-              db.put(bb(1), bb(42));
-              db.close();
-              db.put(bb(2), bb(42)); // error
-            })
+        () -> {
+          final Dbi<ByteBuffer> db = env.buildDbi()
+              .setDbName(DB_1)
+              .withDefaultComparator()
+              .addDbiFlag(MDB_CREATE)
+              .open();
+          db.put(bb(1), bb(42));
+          db.close();
+          db.put(bb(2), bb(42)); // error
+        })
         .isInstanceOf(ConstantDerivedException.class);
   }
 
@@ -152,7 +152,11 @@ private <T> void doCustomComparator(
       Comparator<T> comparator,
       IntFunction<T> serializer,
       ToIntFunction<T> deserializer) {
-    final Dbi<T> db = env.openDbi(DB_1, comparator, true, MDB_CREATE);
+    final Dbi<T> db = env.buildDbi()
+        .setDbName(DB_1)
+        .withCallbackComparator(ignored -> comparator)
+        .setDbiFlags(MDB_CREATE)
+        .open();
     try (Txn<T> txn = env.txnWrite()) {
       assertThat(db.put(txn, serializer.apply(2), serializer.apply(3))).isTrue();
       assertThat(db.put(txn, serializer.apply(4), serializer.apply(6))).isTrue();
@@ -172,11 +176,11 @@ private <T> void doCustomComparator(
   @Test
   void dbOpenMaxDatabases() {
     assertThatThrownBy(
-            () -> {
-              env.openDbi("db1 is OK", MDB_CREATE);
-              env.openDbi("db2 is OK", MDB_CREATE);
-              env.openDbi("db3 fails", MDB_CREATE);
-            })
+        () -> {
+          env.openDbi("db1 is OK", MDB_CREATE);
+          env.openDbi("db2 is OK", MDB_CREATE);
+          env.openDbi("db3 fails", MDB_CREATE);
+        })
         .isInstanceOf(DbFullException.class);
   }
 
@@ -197,49 +201,56 @@ private <T> void doDbiWithComparatorThreadSafety(
       Supplier<Comparator<T>> comparatorSupplier,
       IntFunction<T> serializer,
       ToIntFunction<T> deserializer) {
-    final DbiFlags[] flags = new DbiFlags[]{MDB_CREATE, MDB_INTEGERKEY};
-    final Comparator<T> c = comparatorSupplier.get();
-    final Dbi<T> db = env.openDbi(DB_1, c, true, flags);
-
-    final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
-
-    final ExecutorService pool = Executors.newCachedThreadPool();
-    final AtomicBoolean proceed = new AtomicBoolean(true);
-    final Future<?> reader =
-        pool.submit(
-            () -> {
-              while (proceed.get()) {
-                try (Txn<T> txn = env.txnRead()) {
-                  db.get(txn, serializer.apply(50));
+    final DbiFlagSet flags = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
+    final Comparator<T> comparator = comparatorSupplier.get();
+    final Dbi<T> db = env.buildDbi()
+        .setDbName(DB_1)
+        .withCallbackComparator(ignored -> comparator)
+        .setDbiFlags(flags)
+        .open();
+
+    final List<Integer> keys = range(0, 1_000)
+        .boxed()
+        .collect(toList());
+
+    try (ExecutorService pool = Executors.newCachedThreadPool()) {
+      final AtomicBoolean proceed = new AtomicBoolean(true);
+      final Future<?> reader =
+          pool.submit(
+              () -> {
+                while (proceed.get()) {
+                  try (Txn<T> txn = env.txnRead()) {
+                    db.get(txn, serializer.apply(50));
+                  }
                 }
-              }
-            });
+              });
 
-    for (final Integer key : keys) {
-      try (Txn<T> txn = env.txnWrite()) {
-        db.put(txn, serializer.apply(key), serializer.apply(3));
-        txn.commit();
+      for (final Integer key : keys) {
+        try (Txn<T> txn = env.txnWrite()) {
+          db.put(txn, serializer.apply(key), serializer.apply(3));
+          txn.commit();
+        }
       }
-    }
 
-    try (Txn<T> txn = env.txnRead();
-         CursorIterable<T> ci = db.iterate(txn)) {
-      final Iterator<KeyVal<T>> iter = ci.iterator();
-      final List<Integer> result = new ArrayList<>();
-      while (iter.hasNext()) {
-        result.add(deserializer.applyAsInt(iter.next().key()));
-      }
+      try (Txn<T> txn = env.txnRead();
+           CursorIterable<T> ci = db.iterate(txn)) {
+        final Iterator<KeyVal<T>> iter = ci.iterator();
+        final List<Integer> result = new ArrayList<>();
+        while (iter.hasNext()) {
+          result.add(deserializer.applyAsInt(iter.next().key()));
+        }
 
-      assertThat(result).contains(keys.toArray(new Integer[0]));
-    }
+        assertThat(result).contains(keys.toArray(new Integer[0]));
+      }
 
-    proceed.set(false);
-    try {
-      reader.get(1, SECONDS);
-      pool.shutdown();
-      pool.awaitTermination(1, SECONDS);
-    } catch (ExecutionException | InterruptedException | TimeoutException e) {
-      throw new IllegalStateException(e);
+      proceed.set(false);
+      try {
+        reader.get(1, SECONDS);
+        pool.shutdown();
+        pool.awaitTermination(1, SECONDS);
+      } catch (ExecutionException | InterruptedException | TimeoutException e) {
+        throw new IllegalStateException(e);
+      }
     }
   }
 
@@ -280,7 +291,7 @@ void dropAndDelete() {
   @Test
   void dropAndDeleteAnonymousDb() {
     env.openDbi(DB_1, MDB_CREATE);
-    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null);
+    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null, DbiFlagSet.EMPTY);
     final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
     final ByteBuffer dbNameBuffer = allocateDirect(dbNameBytes.length);
     dbNameBuffer.put(dbNameBytes).flip();
@@ -380,12 +391,12 @@ void putCommitGet() {
   void putCommitGetByteArray() {
     FileUtil.useTempFile(
         file -> {
-    try (Env<byte[]> envBa =
-             create(PROXY_BA)
-                 .setMapSize(MEBIBYTES.toBytes(64))
-                 .setMaxReaders(1)
-                 .setMaxDbs(2)
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
+          try (Env<byte[]> envBa = create(PROXY_BA)
+                       .setMapSize(MEBIBYTES.toBytes(64))
+                       .setMaxReaders(1)
+                       .setMaxDbs(2)
+                       .setEnvFlags(MDB_NOSUBDIR)
+                       .open(file)) {
             final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
             try (Txn<byte[]> txn = envBa.txnWrite()) {
               db.put(txn, ba(5), ba(5));
@@ -517,19 +528,19 @@ void stats() {
   @Test
   void testMapFullException() {
     assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-              try (Txn<ByteBuffer> txn = env.txnWrite()) {
-                final ByteBuffer v;
-                try {
-                  v = allocateDirect(1_024 * 1_024 * 1_024);
-                } catch (final OutOfMemoryError e) {
-                  // Travis CI OS X build cannot allocate this much memory, so assume OK
-                  throw new MapFullException();
-                }
-                db.put(txn, bb(1), v);
-              }
-            })
+        () -> {
+          final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+          try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            final ByteBuffer v;
+            try {
+              v = allocateDirect(1_024 * 1_024 * 1_024);
+            } catch (final OutOfMemoryError e) {
+              // Travis CI OS X build cannot allocate this much memory, so assume OK
+              throw new MapFullException();
+            }
+            db.put(txn, bb(1), v);
+          }
+        })
         .isInstanceOf(MapFullException.class);
   }
 
@@ -554,109 +565,110 @@ void testParallelWritesStress() {
   @Test
   void closedEnvRejectsOpenCall() {
     assertThatThrownBy(
-            () -> {
-              env.close();
-              env.openDbi(DB_1, MDB_CREATE);
-            })
+        () -> {
+          env.close();
+          env.openDbi(DB_1, MDB_CREATE);
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsCloseCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, (db, txn) -> db.close());
-            })
+        () -> {
+          doEnvClosedTest(null, (db, txn) -> db.close());
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsGetCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(
-                  (db, txn) -> {
-                    final ByteBuffer valBuf = db.get(txn, bb(1));
-                    assertThat(valBuf.getInt()).isEqualTo(10);
-                  },
-                  (db, txn) -> db.get(txn, bb(2)));
-            })
+        () -> {
+          doEnvClosedTest(
+              (db, txn) -> {
+                final ByteBuffer valBuf = db.get(txn, bb(1));
+                assertThat(valBuf).isNotNull();
+                assertThat(valBuf.getInt()).isEqualTo(10);
+              },
+              (db, txn) -> db.get(txn, bb(2)));
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsPutCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
-            })
+        () -> {
+          doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsPutWithTxnCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(
-                  null,
-                  (db, txn) -> {
-                    db.put(txn, bb(5), bb(50));
-                  });
-            })
+        () -> {
+          doEnvClosedTest(
+              null,
+              (db, txn) -> {
+                db.put(txn, bb(5), bb(50));
+              });
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsIterateCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, Dbi::iterate);
-            })
+        () -> {
+          doEnvClosedTest(null, Dbi::iterate);
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsDropCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, Dbi::drop);
-            })
+        () -> {
+          doEnvClosedTest(null, Dbi::drop);
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsDropAndDeleteCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
-            })
+        () -> {
+          doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsOpenCursorCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, Dbi::openCursor);
-            })
+        () -> {
+          doEnvClosedTest(null, Dbi::openCursor);
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsReserveCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
-            })
+        () -> {
+          doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsStatCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, Dbi::stat);
-            })
+        () -> {
+          doEnvClosedTest(null, Dbi::stat);
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index eb925b42..69c20c1b 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -56,7 +56,8 @@ void byteUnit() {
                    Env.create()
                        .setMaxReaders(1)
                        .setMapSize(MEBIBYTES.toBytes(1))
-                       .open(file.toFile(), MDB_NOSUBDIR)) {
+                       .setEnvFlags(MDB_NOSUBDIR)
+                       .open(file)) {
             final EnvInfo info = env.info();
             assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
           }
@@ -69,8 +70,10 @@ void cannotChangeMapSizeAfterOpen() {
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
-                try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                final Builder<ByteBuffer> builder = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR);
+                try (Env<ByteBuffer> ignored = builder.open(file)) {
                   builder.setMapSize(1);
                 }
               });
@@ -84,8 +87,10 @@ void cannotChangeMaxDbsAfterOpen() {
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
-                try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                final Builder<ByteBuffer> builder = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR);
+                try (Env<ByteBuffer> ignored = builder.open(file)) {
                   builder.setMaxDbs(1);
                 }
               });
@@ -99,8 +104,10 @@ void cannotChangeMaxReadersAfterOpen() {
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
-                try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                final Builder<ByteBuffer> builder = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR);
+                try (Env<ByteBuffer> ignored = builder.open(file)) {
                   builder.setMaxReaders(1);
                 }
               });
@@ -114,8 +121,10 @@ void cannotInfoOnceClosed() {
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Env<ByteBuffer> env =
-                    Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                final Env<ByteBuffer> env = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR)
+                    .open(file);
                 env.close();
                 env.info();
               });
@@ -129,9 +138,12 @@ void cannotOpenTwice() {
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
-                builder.open(file.toFile(), MDB_NOSUBDIR).close();
-                builder.open(file.toFile(), MDB_NOSUBDIR);
+                final Builder<ByteBuffer> builder = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR);
+                builder.open(file).close();
+                //noinspection resource // This will fail to open
+                builder.open(file);
               });
         })
         .isInstanceOf(AlreadyOpenException.class);
@@ -143,20 +155,33 @@ void cannotOverflowMapSize() {
         () -> {
           final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
           final int mb = 1_024 * 1_024;
+          //noinspection NumericOverflow // Intentional overflow
           final int size = mb * 2_048; // as per issue 18
           builder.setMapSize(size);
         })
         .isInstanceOf(IllegalArgumentException.class);
   }
 
+  @Test
+  void negativeMapSize() {
+    assertThatThrownBy(
+        () -> {
+          final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+          builder.setMapSize(-1);
+        })
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+
   @Test
   void cannotStatOnceClosed() {
     assertThatThrownBy(
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Env<ByteBuffer> env =
-                    Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                final Env<ByteBuffer> env = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR)
+                    .open(file);
                 env.close();
                 env.stat();
               });
@@ -170,8 +195,10 @@ void cannotSyncOnceClosed() {
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Env<ByteBuffer> env =
-                    Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                final Env<ByteBuffer> env = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR)
+                    .open(file);
                 env.close();
                 env.sync(false);
               });
@@ -188,7 +215,7 @@ void copyDirectoryBased() {
           assertThat(FileUtil.count(dest)).isEqualTo(0);
           FileUtil.useTempDir(
               src -> {
-                try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+                try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
                   env.copy(dest.toFile(), MDB_CP_COMPACT);
                   assertThat(FileUtil.count(dest)).isEqualTo(1);
                 }
@@ -205,7 +232,7 @@ void copyDirectoryRejectsFileDestination() {
                 FileUtil.deleteDir(dest);
                 FileUtil.useTempDir(
                     src -> {
-                      try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+                      try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
                         env.copy(dest.toFile(), MDB_CP_COMPACT);
                       }
                     });
@@ -225,7 +252,7 @@ void copyDirectoryRejectsMissingDestination() {
                   FileUtil.useTempDir(
                       src -> {
                         try (Env<ByteBuffer> env =
-                                 Env.create().setMaxReaders(1).open(src.toFile())) {
+                                 Env.create().setMaxReaders(1).open(src)) {
                           env.copy(dest.toFile(), MDB_CP_COMPACT);
                         }
                       });
@@ -250,7 +277,7 @@ void copyDirectoryRejectsNonEmptyDestination() {
                   FileUtil.useTempDir(
                       src -> {
                         try (Env<ByteBuffer> env =
-                                 Env.create().setMaxReaders(1).open(src.toFile())) {
+                                 Env.create().setMaxReaders(1).open(src)) {
                           env.copy(dest.toFile(), MDB_CP_COMPACT);
                         }
                       });
@@ -271,7 +298,7 @@ void copyFileBased() {
           FileUtil.useTempFile(
               src -> {
                 try (Env<ByteBuffer> env =
-                         Env.create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                         Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
                   env.copy(dest.toFile(), MDB_CP_COMPACT);
                 }
                 assertThat(FileUtil.size(dest)).isGreaterThan(0L);
@@ -289,7 +316,7 @@ void copyFileRejectsExistingDestination() {
                 FileUtil.useTempFile(
                     src -> {
                       try (Env<ByteBuffer> env =
-                               Env.create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                               Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
                         env.copy(dest.toFile(), MDB_CP_COMPACT);
                       }
                     });
@@ -302,7 +329,7 @@ void copyFileRejectsExistingDestination() {
   void createAsDirectory() {
     FileUtil.useTempDir(
         dest -> {
-          final Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(dest.toFile());
+          final Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(dest);
           assertThat(Files.isDirectory(dest)).isTrue();
           env.sync(false);
           env.close();
@@ -320,7 +347,8 @@ void createAsFile() {
                        .setMapSize(MEBIBYTES.toBytes(1))
                        .setMaxDbs(1)
                        .setMaxReaders(1)
-                       .open(file.toFile(), MDB_NOSUBDIR)) {
+                       .setEnvFlags(MDB_NOSUBDIR)
+                       .open(file)) {
             env.sync(true);
             assertThat(Files.isRegularFile(file)).isTrue();
           }
@@ -334,7 +362,7 @@ void detectTransactionThreadViolation() {
           FileUtil.useTempFile(
               file -> {
                 try (Env<ByteBuffer> env =
-                         Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+                         Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file)) {
                   env.txnRead();
                   env.txnRead();
                 }
@@ -348,7 +376,7 @@ void info() {
     FileUtil.useTempFile(
         file -> {
           try (Env<ByteBuffer> env =
-                   Env.create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
+                   Env.create().setMaxReaders(4).setMapSize(123_456).setEnvFlags(MDB_NOSUBDIR).open(file)) {
             final EnvInfo info = env.info();
             assertThat(info).isNotNull();
             assertThat(info.lastPageNumber).isEqualTo(1L);
@@ -378,8 +406,9 @@ void mapFull() {
                              .setMaxReaders(1)
                              .setMapSize(MEBIBYTES.toBytes(8))
                              .setMaxDbs(1)
-                             .open(dir.toFile())) {
+                             .open(dir)) {
                   final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                  //noinspection InfiniteLoopStatement // Needs infinite loop to fill the env
                   for (; ; ) {
                     rnd.nextBytes(k);
                     key.clear();
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index f0aa64e4..21ef5182 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -37,8 +37,10 @@ public class GarbageCollectionTest {
   void buffersNotGarbageCollectedTest() {
     FileUtil.useTempDir(
         dir -> {
-          try (Env<ByteBuffer> env =
-              create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir.toFile())) {
+          try (Env<ByteBuffer> env = create()
+              .setMapSize(2_085_760_999)
+              .setMaxDbs(1)
+              .open(dir)) {
             final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
             try (Txn<ByteBuffer> txn = env.txnWrite()) {
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 35e2c169..93c4a031 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -16,16 +16,13 @@
 
 package org.lmdbjava;
 
-import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static java.util.concurrent.Executors.newCachedThreadPool;
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
-import static org.lmdbjava.Env.create;
 import static org.lmdbjava.GetOp.MDB_SET;
 import static org.lmdbjava.SeekOp.MDB_FIRST;
 import static org.lmdbjava.SeekOp.MDB_LAST;
@@ -34,6 +31,7 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import org.agrona.DirectBuffer;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
@@ -57,7 +55,9 @@ public final class TutorialTest {
 
   private static final String DB_NAME = "my DB";
 
-  /** In this first tutorial we will use LmdbJava with some basic defaults. */
+  /**
+   * In this first tutorial we will use LmdbJava with some basic defaults.
+   */
   @Test
   void tutorial1() {
     // We need a storage directory first.
@@ -67,16 +67,15 @@ void tutorial1() {
 
           // We always need an Env. An Env owns a physical on-disk storage file. One
           // Env can store many different databases (ie sorted maps).
-          final Env<ByteBuffer> env =
-              create()
-                  // LMDB also needs to know how large our DB might be. Over-estimating is OK.
-                  .setMapSize(10_485_760)
-                  // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
-                  .setMaxDbs(1)
-                  // Now let's open the Env. The same path can be concurrently opened and
-                  // used in different processes, but do not open the same path twice in
-                  // the same process at the same time.
-                  .open(dir.toFile());
+          final Env<ByteBuffer> env = Env.create()
+              // LMDB also needs to know how large our DB might be. Over-estimating is OK.
+              .setMapSize(10_485_760)
+              // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
+              .setMaxDbs(1)
+              // Now let's open the Env. The same path can be concurrently opened and
+              // used in different processes, but do not open the same path twice in
+              // the same process at the same time.
+              .open(dir);
 
           // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
           // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
@@ -85,8 +84,8 @@ void tutorial1() {
           // We want to store some data, so we will need a direct ByteBuffer.
           // Note that LMDB keys cannot exceed maxKeySize bytes (511 bytes by default).
           // Values can be larger.
-          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-          final ByteBuffer val = allocateDirect(700);
+          final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
+          final ByteBuffer val = ByteBuffer.allocateDirect(700);
           key.put("greeting".getBytes(UTF_8)).flip();
           val.put("Hello world".getBytes(UTF_8)).flip();
           final int valSize = val.remaining();
@@ -125,7 +124,9 @@ void tutorial1() {
         });
   }
 
-  /** In this second tutorial we'll learn more about LMDB's ACID Txns. */
+  /**
+   * In this second tutorial we'll learn more about LMDB's ACID Txns.
+   */
   @Test
   void tutorial2() {
     FileUtil.useTempDir(
@@ -133,8 +134,8 @@ void tutorial2() {
           try {
             final Env<ByteBuffer> env = createSimpleEnv(dir);
             final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-            final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-            final ByteBuffer val = allocateDirect(700);
+            final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
+            final ByteBuffer val = ByteBuffer.allocateDirect(700);
 
             // Let's write and commit "key1" via a Txn. A Txn can include multiple Dbis.
             // Note write Txns block other write Txns, due to writes being serialized.
@@ -163,7 +164,7 @@ void tutorial2() {
             // typically permitted (the exception is a read-only Env with MDB_NOTLS).
             //
             // Let's write out a "key2" via a new write Txn in a different thread.
-            final ExecutorService es = newCachedThreadPool();
+            final ExecutorService es = Executors.newCachedThreadPool();
             es.execute(
                 () -> {
                   try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -211,8 +212,8 @@ void tutorial3() {
         dir -> {
           final Env<ByteBuffer> env = createSimpleEnv(dir);
           final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-          final ByteBuffer val = allocateDirect(700);
+          final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
+          final ByteBuffer val = ByteBuffer.allocateDirect(700);
 
           try (Txn<ByteBuffer> txn = env.txnWrite()) {
             // A cursor always belongs to a particular Dbi.
@@ -288,8 +289,8 @@ void tutorial4() {
           final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
           try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-            final ByteBuffer val = allocateDirect(700);
+            final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
+            final ByteBuffer val = ByteBuffer.allocateDirect(700);
 
             // Insert some data. Note that ByteBuffer order defaults to Big Endian.
             // LMDB does not persist the byte order, but it's critical to sort keys.
@@ -336,7 +337,9 @@ void tutorial4() {
         });
   }
 
-  /** In this fifth tutorial we'll explore multiple values sharing a single key. */
+  /**
+   * In this fifth tutorial we'll explore multiple values sharing a single key.
+   */
   @Test
   void tutorial5() {
     FileUtil.useTempDir(
@@ -348,8 +351,8 @@ void tutorial5() {
           final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
 
           // Duplicate support requires both keys and values to be <= max key size.
-          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-          final ByteBuffer val = allocateDirect(env.getMaxKeySize());
+          final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
+          final ByteBuffer val = ByteBuffer.allocateDirect(env.getMaxKeySize());
 
           try (Txn<ByteBuffer> txn = env.txnWrite()) {
             final Cursor<ByteBuffer> c = db.openCursor(txn);
@@ -396,11 +399,10 @@ void tutorial6() {
     FileUtil.useTempDir(
         dir -> {
           // Note we need to specify the Verifier's DBI_COUNT for the Env.
-          final Env<ByteBuffer> env =
-              create(PROXY_OPTIMAL)
+          final Env<ByteBuffer> env = Env.create(PROXY_OPTIMAL)
                   .setMapSize(10_485_760)
                   .setMaxDbs(Verifier.DBI_COUNT)
-                  .open(dir.toFile());
+                  .open(dir);
 
           // Create a Verifier (it's a Callable<Long> for those needing full control).
           final Verifier v = new Verifier(env);
@@ -413,7 +415,9 @@ void tutorial6() {
         });
   }
 
-  /** In this final tutorial we'll look at using Agrona's DirectBuffer. */
+  /**
+   * In this final tutorial we'll look at using Agrona's DirectBuffer.
+   */
   @Test
   void tutorial7() {
     FileUtil.useTempDir(
@@ -421,14 +425,16 @@ void tutorial7() {
           // The critical difference is we pass the PROXY_DB field to Env.create().
           // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
           // Aside from that and a different type argument, it's the same as usual...
-          final Env<DirectBuffer> env =
-              create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir.toFile());
+          final Env<DirectBuffer> env = Env.create(PROXY_DB)
+              .setMapSize(10_485_760)
+              .setMaxDbs(1)
+              .open(dir);
 
           final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
-          final ByteBuffer keyBb = allocateDirect(env.getMaxKeySize());
+          final ByteBuffer keyBb = ByteBuffer.allocateDirect(env.getMaxKeySize());
           final MutableDirectBuffer key = new UnsafeBuffer(keyBb);
-          final MutableDirectBuffer val = new UnsafeBuffer(allocateDirect(700));
+          final MutableDirectBuffer val = new UnsafeBuffer(ByteBuffer.allocateDirect(700));
 
           try (Txn<DirectBuffer> txn = env.txnWrite()) {
             try (Cursor<DirectBuffer> c = db.openCursor(txn)) {
@@ -479,6 +485,10 @@ void tutorial7() {
   // or reverse ordered keys, using Env.DISABLE_CHECKS_PROP etc), but you now
   // know enough to tackle the JavaDocs with confidence. Have fun!
   private Env<ByteBuffer> createSimpleEnv(final Path path) {
-    return create().setMapSize(10_485_760).setMaxDbs(1).setMaxReaders(1).open(path.toFile());
+    return Env.create()
+        .setMapSize(10_485_760)
+        .setMaxDbs(1)
+        .setMaxReaders(1)
+        .open(path);
   }
 }
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 46ffeb70..f81b525e 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -27,7 +27,6 @@
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.KeyRange.closed;
 import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.Txn.State.DONE;
 import static org.lmdbjava.Txn.State.READY;
@@ -68,7 +67,8 @@ void beforeEach() {
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
             .setMaxDbs(2)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
   }
 
   @AfterEach
@@ -126,8 +126,10 @@ void rangeSearch() {
   @Test
   void readOnlyTxnAllowedInReadOnlyEnv() {
     env.openDbi(DB_1, MDB_CREATE);
-    try (Env<ByteBuffer> roEnv =
-        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
+    try (Env<ByteBuffer> roEnv = create()
+        .setMaxReaders(1)
+        .setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV)
+        .open(file)) {
       assertThat(roEnv.txnRead()).isNotNull();
     }
   }

From 577062f6d5df8e0cde054d11334e507419c63414 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 10:33:06 +0000
Subject: [PATCH 34/90] Fix compile issue

---
 .../org/lmdbjava/AbstractFlagSetTest.java     | 20 +++++
 src/test/java/org/lmdbjava/DbiTest.java       | 75 ++++++++++---------
 2 files changed, 58 insertions(+), 37 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/AbstractFlagSetTest.java

diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
new file mode 100644
index 00000000..f986fa7f
--- /dev/null
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+public abstract class AbstractFlagSetTest {
+
+}
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 95da87a4..6d86bd85 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -213,44 +213,45 @@ private <T> void doDbiWithComparatorThreadSafety(
         .boxed()
         .collect(toList());
 
-    try (ExecutorService pool = Executors.newCachedThreadPool()) {
-      final AtomicBoolean proceed = new AtomicBoolean(true);
-      final Future<?> reader =
-          pool.submit(
-              () -> {
-                while (proceed.get()) {
-                  try (Txn<T> txn = env.txnRead()) {
-                    db.get(txn, serializer.apply(50));
-                  }
+    // TODO surround with try-with-resources in J19+
+    //noinspection resource // Not in J8
+    ExecutorService pool = Executors.newCachedThreadPool();
+    final AtomicBoolean proceed = new AtomicBoolean(true);
+    final Future<?> reader =
+        pool.submit(
+            () -> {
+              while (proceed.get()) {
+                try (Txn<T> txn = env.txnRead()) {
+                  db.get(txn, serializer.apply(50));
                 }
-              });
+              }
+            });
 
-      for (final Integer key : keys) {
-        try (Txn<T> txn = env.txnWrite()) {
-          db.put(txn, serializer.apply(key), serializer.apply(3));
-          txn.commit();
-        }
+    for (final Integer key : keys) {
+      try (Txn<T> txn = env.txnWrite()) {
+        db.put(txn, serializer.apply(key), serializer.apply(3));
+        txn.commit();
       }
+    }
 
-      try (Txn<T> txn = env.txnRead();
-           CursorIterable<T> ci = db.iterate(txn)) {
-        final Iterator<KeyVal<T>> iter = ci.iterator();
-        final List<Integer> result = new ArrayList<>();
-        while (iter.hasNext()) {
-          result.add(deserializer.applyAsInt(iter.next().key()));
-        }
-
-        assertThat(result).contains(keys.toArray(new Integer[0]));
+    try (Txn<T> txn = env.txnRead();
+         CursorIterable<T> ci = db.iterate(txn)) {
+      final Iterator<KeyVal<T>> iter = ci.iterator();
+      final List<Integer> result = new ArrayList<>();
+      while (iter.hasNext()) {
+        result.add(deserializer.applyAsInt(iter.next().key()));
       }
 
-      proceed.set(false);
-      try {
-        reader.get(1, SECONDS);
-        pool.shutdown();
-        pool.awaitTermination(1, SECONDS);
-      } catch (ExecutionException | InterruptedException | TimeoutException e) {
-        throw new IllegalStateException(e);
-      }
+      assertThat(result).contains(keys.toArray(new Integer[0]));
+    }
+
+    proceed.set(false);
+    try {
+      reader.get(1, SECONDS);
+      pool.shutdown();
+      pool.awaitTermination(1, SECONDS);
+    } catch (ExecutionException | InterruptedException | TimeoutException e) {
+      throw new IllegalStateException(e);
     }
   }
 
@@ -392,11 +393,11 @@ void putCommitGetByteArray() {
     FileUtil.useTempFile(
         file -> {
           try (Env<byte[]> envBa = create(PROXY_BA)
-                       .setMapSize(MEBIBYTES.toBytes(64))
-                       .setMaxReaders(1)
-                       .setMaxDbs(2)
-                       .setEnvFlags(MDB_NOSUBDIR)
-                       .open(file)) {
+              .setMapSize(MEBIBYTES.toBytes(64))
+              .setMaxReaders(1)
+              .setMaxDbs(2)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
             final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
             try (Txn<byte[]> txn = envBa.txnWrite()) {
               db.put(txn, ba(5), ba(5));

From 12a9679899aefe8e27a9af9da4b688189ba0085f Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 11:31:32 +0000
Subject: [PATCH 35/90] Improve FlagSet tests

---
 .../java/org/lmdbjava/AbstractFlagSet.java    |  12 +-
 src/main/java/org/lmdbjava/CopyFlagSet.java   |   4 +-
 src/main/java/org/lmdbjava/DbiBuilder.java    |   8 +-
 src/main/java/org/lmdbjava/DbiFlagSet.java    |   4 +-
 src/main/java/org/lmdbjava/Env.java           |   8 +-
 src/main/java/org/lmdbjava/EnvFlagSet.java    |   4 +-
 src/main/java/org/lmdbjava/PutFlagSet.java    |   4 +-
 src/main/java/org/lmdbjava/TxnFlagSet.java    |  15 +-
 .../org/lmdbjava/AbstractFlagSetTest.java     | 153 ++++++++++++++++--
 .../java/org/lmdbjava/CopyFlagSetTest.java    |  85 ++++------
 .../java/org/lmdbjava/DbiFlagSetTest.java     |  99 ++++--------
 .../java/org/lmdbjava/EnvFlagSetTest.java     |  99 ++++--------
 .../java/org/lmdbjava/PutFlagSetTest.java     |  96 ++++-------
 .../java/org/lmdbjava/TxnFlagSetTest.java     |  96 ++++-------
 14 files changed, 324 insertions(+), 363 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 058969de..849bbe73 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -278,7 +278,7 @@ protected Builder(final Class<E> type,
      * @param flags The flags to set in the builder.
      * @return this builder instance.
      */
-    public Builder<E, S> withFlags(final Collection<E> flags) {
+    public Builder<E, S> setFlags(final Collection<E> flags) {
       clear();
       if (flags != null) {
         for (E flag : flags) {
@@ -295,7 +295,7 @@ public Builder<E, S> withFlags(final Collection<E> flags) {
      * @return this builder instance.
      */
     @SafeVarargs
-    public final Builder<E, S> withFlags(final E... flags) {
+    public final Builder<E, S> setFlags(final E... flags) {
       clear();
       if (flags != null) {
         for (E flag : flags) {
@@ -311,12 +311,12 @@ public final Builder<E, S> withFlags(final E... flags) {
     }
 
     /**
-     * Sets a single flag in the builder.
+     * Adds a single flag in the builder.
      *
      * @param flag The flag to set in the builder.
      * @return this builder instance.
      */
-    public Builder<E, S> setFlag(final E flag) {
+    public Builder<E, S> addFlag(final E flag) {
       if (flag != null) {
         enumSet.add(flag);
       }
@@ -324,12 +324,12 @@ public Builder<E, S> setFlag(final E flag) {
     }
 
     /**
-     * Sets multiple flag in the builder.
+     * Adds multiple flag in the builder.
      *
      * @param flags The flags to set in the builder.
      * @return this builder instance.
      */
-    public Builder<E, S> setFlags(final Collection<E> flags) {
+    public Builder<E, S> addFlags(final Collection<E> flags) {
       if (flags != null) {
         enumSet.addAll(flags);
       }
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index 5f7901de..e21680dd 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -34,13 +34,13 @@ static CopyFlagSet of(final CopyFlags dbiFlag) {
 
   static CopyFlagSet of(final CopyFlags... CopyFlags) {
     return builder()
-        .withFlags(CopyFlags)
+        .setFlags(CopyFlags)
         .build();
   }
 
   static CopyFlagSet of(final Collection<CopyFlags> CopyFlags) {
     return builder()
-        .withFlags(CopyFlags)
+        .setFlags(CopyFlags)
         .build();
   }
 
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 1abff0a2..b478c9df 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -300,7 +300,7 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
       if (dbiFlags != null) {
         Arrays.stream(dbiFlags)
             .filter(Objects::nonNull)
-            .forEach(this.flagSetBuilder::setFlag);
+            .forEach(this.flagSetBuilder::addFlag);
       }
       return this;
     }
@@ -322,7 +322,7 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
     public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
       flagSetBuilder.clear();
       if (dbiFlagSet != null) {
-        this.flagSetBuilder.withFlags(dbiFlagSet.getFlags());
+        this.flagSetBuilder.setFlags(dbiFlagSet.getFlags());
       }
       return this;
     }
@@ -337,7 +337,7 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
      * @return this builder instance.
      */
     public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
-      this.flagSetBuilder.setFlag(dbiFlag);
+      this.flagSetBuilder.addFlag(dbiFlag);
       return this;
     }
 
@@ -352,7 +352,7 @@ public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
      */
     public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
       if (dbiFlagSet != null) {
-        flagSetBuilder.setFlags(dbiFlagSet.getFlags());
+        flagSetBuilder.addFlags(dbiFlagSet.getFlags());
       }
       return this;
     }
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 5a0bc83e..8ffd2499 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -40,13 +40,13 @@ static DbiFlagSet of(final DbiFlags dbiFlag) {
 
   static DbiFlagSet of(final DbiFlags... DbiFlags) {
     return builder()
-        .withFlags(DbiFlags)
+        .setFlags(DbiFlags)
         .build();
   }
 
   static DbiFlagSet of(final Collection<DbiFlags> DbiFlags) {
     return builder()
-        .withFlags(DbiFlags)
+        .setFlags(DbiFlags)
         .build();
   }
 
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 7ccebb4e..542b67c3 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -885,7 +885,7 @@ public Builder<T> setEnvFlags(final EnvFlags... envFlags) {
       if (envFlags != null) {
         Arrays.stream(envFlags)
             .filter(Objects::nonNull)
-            .forEach(this.flagSetBuilder::setFlag);
+            .forEach(this.flagSetBuilder::addFlag);
       }
       return this;
     }
@@ -901,7 +901,7 @@ public Builder<T> setEnvFlags(final EnvFlags... envFlags) {
     public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
       flagSetBuilder.clear();
       if (envFlagSet != null) {
-        this.flagSetBuilder.withFlags(envFlagSet.getFlags());
+        this.flagSetBuilder.setFlags(envFlagSet.getFlags());
       }
       return this;
     }
@@ -914,7 +914,7 @@ public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
      * @return this builder instance.
      */
     public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
-      this.flagSetBuilder.setFlag(dbiFlag);
+      this.flagSetBuilder.addFlag(dbiFlag);
       return this;
     }
 
@@ -927,7 +927,7 @@ public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
      */
     public Builder<T> addEnvFlags(final EnvFlagSet dbiFlagSet) {
       if (dbiFlagSet != null) {
-        flagSetBuilder.setFlags(dbiFlagSet.getFlags());
+        flagSetBuilder.addFlags(dbiFlagSet.getFlags());
       }
       return this;
     }
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index a3c8d1fa..c104edd9 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -34,13 +34,13 @@ static EnvFlagSet of(final EnvFlags envFlag) {
 
   static EnvFlagSet of(final EnvFlags... EnvFlags) {
     return builder()
-        .withFlags(EnvFlags)
+        .setFlags(EnvFlags)
         .build();
   }
 
   static EnvFlagSet of(final Collection<EnvFlags> EnvFlags) {
     return builder()
-        .withFlags(EnvFlags)
+        .setFlags(EnvFlags)
         .build();
   }
 
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 9d3a7288..aaba7cb7 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -34,13 +34,13 @@ static PutFlagSet of(final PutFlags putFlag) {
 
     static PutFlagSet of(final PutFlags... putFlags) {
         return builder()
-                .withFlags(putFlags)
+                .setFlags(putFlags)
                 .build();
     }
 
     static PutFlagSet of(final Collection<PutFlags> putFlags) {
         return builder()
-            .withFlags(putFlags)
+            .setFlags(putFlags)
             .build();
     }
 
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index 8e6310b3..0943b362 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -15,6 +15,7 @@
  */
 package org.lmdbjava;
 
+import java.util.Collection;
 import java.util.EnumSet;
 import java.util.Objects;
 
@@ -26,14 +27,20 @@ static TxnFlagSet empty() {
     return TxnFlagSetImpl.EMPTY;
   }
 
-  static TxnFlagSet of(final TxnFlags putFlag) {
-    Objects.requireNonNull(putFlag);
-    return new SingleTxnFlagSet(putFlag);
+  static TxnFlagSet of(final TxnFlags putflag) {
+    Objects.requireNonNull(putflag);
+    return new SingleTxnFlagSet(putflag);
   }
 
   static TxnFlagSet of(final TxnFlags... TxnFlags) {
     return builder()
-        .withFlags(TxnFlags)
+        .setFlags(TxnFlags)
+        .build();
+  }
+
+  static TxnFlagSet of(final Collection<TxnFlags> txnFlags) {
+    return builder()
+        .setFlags(txnFlags)
         .build();
   }
 
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index f986fa7f..e09d72c6 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -1,20 +1,141 @@
-/*
- * Copyright © 2016-2025 The LmdbJava Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.lmdbjava;
 
-public abstract class AbstractFlagSetTest {
+import static org.assertj.core.api.Assertions.assertThat;
 
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import org.junit.jupiter.api.Test;
+
+public abstract class AbstractFlagSetTest<T extends Enum<T> & MaskedFlag & FlagSet<T>, F extends FlagSet<T>> {
+
+  abstract List<T> getAllFlags();
+
+  abstract F getEmptyFlagSet();
+
+  abstract AbstractFlagSet.Builder<T, F> getBuilder();
+
+  abstract F getFlagSet(final Collection<T> flags);
+
+  abstract F getFlagSet(final T[] flags);
+
+  abstract F getFlagSet(final T flag);
+
+  abstract Class<T> getFlagType();
+
+  T getFirst() {
+    return getAllFlags().get(0);
+  }
+
+  int getFlagCount() {
+    return getAllFlags().size();
+  }
+
+  @Test
+  void testEmpty() {
+    final F emptyFlagSet = getEmptyFlagSet();
+    assertThat(emptyFlagSet.getMask())
+        .isEqualTo(0);
+    assertThat(emptyFlagSet.getFlags())
+        .isEmpty();
+    assertThat(emptyFlagSet.isEmpty())
+        .isTrue();
+    assertThat(emptyFlagSet.size())
+        .isEqualTo(0);
+    assertThat(emptyFlagSet.isSet(getFirst()))
+        .isFalse();
+    assertThat(getBuilder().build().getFlags())
+        .isEqualTo(emptyFlagSet.getFlags());
+  }
+
+  @Test
+  void testSingleFlagSet() {
+    final List<T> allFlags = getAllFlags();
+    for (T flag : allFlags) {
+      final F flagSet = getBuilder()
+          .addFlag(flag)
+          .build();
+      assertThat(flagSet.getMask())
+          .isEqualTo(flag.getMask());
+      assertThat(flagSet.getMask())
+          .isEqualTo(MaskedFlag.mask(flag));
+      assertThat(flagSet.getFlags())
+          .containsExactly(flag);
+      assertThat(flagSet.size())
+          .isEqualTo(1);
+      assertThat(FlagSet.equals(flagSet, flag))
+          .isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flag)))
+          .isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flagSet.getFlags())))
+          .isTrue();
+      assertThat(flagSet.areAnySet(flag))
+          .isTrue();
+      assertThat(flagSet.isSet(getFirst()))
+          .isEqualTo(getFirst() == flag);
+      if (getFirst() == flag) {
+        assertThat(flagSet.getMask())
+            .isEqualTo(MaskedFlag.mask(getFirst()));
+      } else {
+        assertThat(flagSet.getMask())
+            .isNotEqualTo(MaskedFlag.mask(getFirst()));
+      }
+      assertThat(flagSet.toString())
+          .isNotNull();
+      assertThat(flag.name())
+          .isNotNull();
+    }
+  }
+
+  @Test
+  void testAllFlags() {
+    final List<T> allFlags = getAllFlags();
+    final List<T> flags = new ArrayList<>(allFlags.size());
+    final Set<Integer> masks = new HashSet<>();
+    final T firstFlag = getFirst();
+    for (T flag : allFlags) {
+      flags.add(flag);
+      final F flagSet = getBuilder()
+          .setFlags(flags)
+          .build();
+      final int flagSetMask = flagSet.getMask();
+
+      assertThat(masks)
+          .doesNotContain(flagSetMask);
+      masks.add(flagSetMask);
+      assertThat(flagSetMask)
+          .isEqualTo(MaskedFlag.mask(flags));
+      final T[] flagsArr = flags.stream().toArray(this::toArray);
+      assertThat(flagSetMask)
+          .isEqualTo(MaskedFlag.mask(flagsArr));
+      assertThat(flagSet.getFlags())
+          .containsExactlyElementsOf(flags);
+      assertThat(flagSet)
+          .isNotEmpty();
+      assertThat(FlagSet.equals(flagSet, getBuilder().setFlags(flagsArr).build()))
+          .isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flags)))
+          .isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flagsArr)))
+          .isTrue();
+      assertThat(flagSet.size())
+          .isEqualTo(flags.size());
+      assertThat(flagSet.isSet(getFirst()))
+          .isEqualTo(true);
+
+      final int maskWith = flagSet.getMaskWith(firstFlag);
+      final List<T> combinedList = new ArrayList<>(flags);
+      combinedList.add(firstFlag);
+      assertThat(maskWith)
+          .isEqualTo(MaskedFlag.mask(combinedList));
+    }
+  }
+
+  private T[] toArray(final int cnt) {
+    //noinspection unchecked
+    return (T[]) Array.newInstance(getFlagType(), cnt);
+  }
 }
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 2782fe81..e53c7508 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -15,65 +15,46 @@
  */
 package org.lmdbjava;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
 
-import java.util.Collections;
-import java.util.HashSet;
-import org.junit.jupiter.api.Test;
+public class CopyFlagSetTest extends AbstractFlagSetTest<CopyFlags, CopyFlagSet> {
 
-public class CopyFlagSetTest {
+    @Override
+    List<CopyFlags> getAllFlags() {
+        return Arrays.stream(CopyFlags.values())
+            .collect(Collectors.toList());
+    }
+
+    @Override
+    CopyFlagSet getEmptyFlagSet() {
+        return CopyFlagSet.empty();
+    }
 
-    @Test
-    public void testEmpty() {
-        final CopyFlagSet copyFlagSet = CopyFlagSet.empty();
-        assertThat(copyFlagSet.getMask()).isEqualTo(0);
-        assertThat(copyFlagSet.size()).isEqualTo(0);
-        assertThat(copyFlagSet.isEmpty()).isEqualTo(true);
-        assertThat(copyFlagSet.isSet(CopyFlags.MDB_CP_COMPACT)).isEqualTo(false);
-        final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
-            .build();
-        assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
-        assertThat(copyFlagSet).isNotEqualTo(CopyFlagSet.of(CopyFlags.MDB_CP_COMPACT));
-        assertThat(copyFlagSet).isNotEqualTo(CopyFlagSet.builder()
-            .setFlag(CopyFlags.MDB_CP_COMPACT)
-            .build());
+    @Override
+    AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> getBuilder() {
+        return CopyFlagSet.builder();
     }
 
-    @Test
-    public void testOf() {
-        final CopyFlags copyFlag = CopyFlags.MDB_CP_COMPACT;
-        final CopyFlagSet copyFlagSet = CopyFlagSet.of(copyFlag);
-        assertThat(copyFlagSet.getMask()).isEqualTo(MaskedFlag.mask(copyFlag));
-        assertThat(copyFlagSet.size()).isEqualTo(1);
-        for (CopyFlags flag : copyFlagSet) {
-            assertThat(copyFlagSet.isSet(flag)).isEqualTo(true);
-        }
+    @Override
+    CopyFlagSet getFlagSet(Collection<CopyFlags> flags) {
+        return CopyFlagSet.of(flags);
+    }
+
+    @Override
+    CopyFlagSet getFlagSet(CopyFlags[] flags) {
+        return CopyFlagSet.of(flags);
+    }
 
-        final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
-            .setFlag(copyFlag)
-            .build();
-        assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
+    @Override
+    CopyFlagSet getFlagSet(CopyFlags flag) {
+        return CopyFlagSet.of(flag);
     }
 
-    @Test
-    public void testBuilder() {
-        final CopyFlags copyFlag1 = CopyFlags.MDB_CP_COMPACT;
-        final CopyFlagSet copyFlagSet = CopyFlagSet.builder()
-                .setFlag(copyFlag1)
-                .build();
-        assertThat(copyFlagSet.getMask()).isEqualTo(MaskedFlag.mask(copyFlag1));
-        assertThat(copyFlagSet.size()).isEqualTo(1);
-        assertThat(copyFlagSet.isSet(CopyFlags.MDB_CP_COMPACT)).isEqualTo(true);
-        for (CopyFlags flag : copyFlagSet) {
-            assertThat(copyFlagSet.isSet(flag)).isEqualTo(true);
-        }
-        final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
-                .withFlags(copyFlag1)
-                .build();
-        final CopyFlagSet copyFlagSet3 = CopyFlagSet.builder()
-                .withFlags(new HashSet<>(Collections.singletonList(copyFlag1)))
-                .build();
-        assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
-        assertThat(copyFlagSet).isEqualTo(copyFlagSet3);
+    @Override
+    Class<CopyFlags> getFlagType() {
+        return CopyFlags.class;
     }
 }
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index aa66313f..06236497 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -15,83 +15,46 @@
  */
 package org.lmdbjava;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 import java.util.Arrays;
-import java.util.HashSet;
-import org.junit.jupiter.api.Test;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class DbiFlagSetTest extends AbstractFlagSetTest<DbiFlags, DbiFlagSet> {
+
+    @Override
+    List<DbiFlags> getAllFlags() {
+        return Arrays.stream(DbiFlags.values())
+            .collect(Collectors.toList());
+    }
 
-public class DbiFlagSetTest {
+    @Override
+    DbiFlagSet getEmptyFlagSet() {
+        return DbiFlagSet.empty();
+    }
 
-    @Test
-    public void testEmpty() {
-        final DbiFlagSet dbiFlagSet = DbiFlagSet.empty();
-        assertThat(dbiFlagSet.getMask()).isEqualTo(0);
-        assertThat(dbiFlagSet.size()).isEqualTo(0);
-        assertThat(dbiFlagSet.isEmpty()).isEqualTo(true);
-        assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
-        final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder()
-            .build();
-        assertThat(dbiFlagSet).isEqualTo(dbiFlagSet2);
-        assertThat(dbiFlagSet).isNotEqualTo(DbiFlagSet.of(DbiFlags.MDB_CREATE));
-        assertThat(dbiFlagSet).isNotEqualTo(DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_DUPSORT));
-        assertThat(dbiFlagSet).isNotEqualTo(DbiFlagSet.builder()
-            .setFlag(DbiFlags.MDB_CREATE)
-            .setFlag(DbiFlags.MDB_DUPFIXED)
-            .build());
+    @Override
+    AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> getBuilder() {
+        return DbiFlagSet.builder();
     }
 
-    @Test
-    public void testOf() {
-        final DbiFlags dbiFlag = DbiFlags.MDB_CREATE;
-        final DbiFlagSet dbiFlagSet = DbiFlagSet.of(dbiFlag);
-        assertThat(dbiFlagSet.getMask()).isEqualTo(MaskedFlag.mask(dbiFlag));
-        assertThat(dbiFlagSet.size()).isEqualTo(1);
-        assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
-        for (DbiFlags flag : dbiFlagSet) {
-            assertThat(dbiFlagSet.isSet(flag)).isEqualTo(true);
-        }
+    @Override
+    Class<DbiFlags> getFlagType() {
+        return DbiFlags.class;
+    }
 
-        final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder()
-            .setFlag(dbiFlag)
-            .build();
-        assertThat(dbiFlagSet).isEqualTo(dbiFlagSet2);
+    @Override
+    DbiFlagSet getFlagSet(Collection<DbiFlags> flags) {
+        return DbiFlagSet.of(flags);
     }
 
-    @Test
-    public void testOf2() {
-        final DbiFlags dbiFlag1 = DbiFlags.MDB_CREATE;
-        final DbiFlags dbiFlag2 = DbiFlags.MDB_INTEGERKEY;
-        final DbiFlagSet dbiFlagSet = DbiFlagSet.of(dbiFlag1, dbiFlag2);
-        assertThat(dbiFlagSet.getMask()).isEqualTo(MaskedFlag.mask(dbiFlag1, dbiFlag2));
-        assertThat(dbiFlagSet.size()).isEqualTo(2);
-        assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
-        for (DbiFlags flag : dbiFlagSet) {
-            assertThat(dbiFlagSet.isSet(flag)).isEqualTo(true);
-        }
+    @Override
+    DbiFlagSet getFlagSet(DbiFlags[] flags) {
+        return DbiFlagSet.of(flags);
     }
 
-    @Test
-    public void testBuilder() {
-        final DbiFlags dbiFlag1 = DbiFlags.MDB_CREATE;
-        final DbiFlags dbiFlag2 = DbiFlags.MDB_INTEGERKEY;
-        final DbiFlagSet dbiFlagSet = DbiFlagSet.builder()
-                .setFlag(dbiFlag1)
-                .setFlag(dbiFlag2)
-                .build();
-        assertThat(dbiFlagSet.getMask()).isEqualTo(MaskedFlag.mask(dbiFlag1, dbiFlag2));
-        assertThat(dbiFlagSet.size()).isEqualTo(2);
-        assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
-        for (DbiFlags flag : dbiFlagSet) {
-            assertThat(dbiFlagSet.isSet(flag)).isEqualTo(true);
-        }
-        final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder()
-                .withFlags(dbiFlag1, dbiFlag2)
-                .build();
-        final DbiFlagSet dbiFlagSet3 = DbiFlagSet.builder()
-                .withFlags(new HashSet<>(Arrays.asList(dbiFlag1, dbiFlag2)))
-                .build();
-        assertThat(dbiFlagSet).isEqualTo(dbiFlagSet2);
-        assertThat(dbiFlagSet).isEqualTo(dbiFlagSet3);
+    @Override
+    DbiFlagSet getFlagSet(DbiFlags flag) {
+        return DbiFlagSet.of(flag);
     }
 }
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index 485aae13..98a033f5 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -15,83 +15,46 @@
  */
 package org.lmdbjava;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 import java.util.Arrays;
-import java.util.HashSet;
-import org.junit.jupiter.api.Test;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class EnvFlagSetTest extends AbstractFlagSetTest<EnvFlags, EnvFlagSet> {
+
+    @Override
+    List<EnvFlags> getAllFlags() {
+        return Arrays.stream(EnvFlags.values())
+            .collect(Collectors.toList());
+    }
 
-public class EnvFlagSetTest {
+    @Override
+    EnvFlagSet getEmptyFlagSet() {
+        return EnvFlagSet.empty();
+    }
 
-    @Test
-    public void testEmpty() {
-        final EnvFlagSet envFlagSet = EnvFlagSet.empty();
-        assertThat(envFlagSet.getMask()).isEqualTo(0);
-        assertThat(envFlagSet.size()).isEqualTo(0);
-        assertThat(envFlagSet.isEmpty()).isEqualTo(true);
-        assertThat(envFlagSet.isSet(EnvFlags.MDB_NOSUBDIR)).isEqualTo(false);
-        final EnvFlagSet envFlagSet2 = EnvFlagSet.builder()
-            .build();
-        assertThat(envFlagSet).isEqualTo(envFlagSet2);
-        assertThat(envFlagSet).isNotEqualTo(EnvFlagSet.of(EnvFlags.MDB_FIXEDMAP));
-        assertThat(envFlagSet).isNotEqualTo(EnvFlagSet.of(EnvFlags.MDB_FIXEDMAP, EnvFlags.MDB_NORDAHEAD));
-        assertThat(envFlagSet).isNotEqualTo(EnvFlagSet.builder()
-            .setFlag(EnvFlags.MDB_FIXEDMAP)
-            .setFlag(EnvFlags.MDB_NORDAHEAD)
-            .build());
+    @Override
+    AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> getBuilder() {
+        return EnvFlagSet.builder();
     }
 
-    @Test
-    public void testOf() {
-        final EnvFlags envFlag = EnvFlags.MDB_FIXEDMAP;
-        final EnvFlagSet envFlagSet = EnvFlagSet.of(envFlag);
-        assertThat(envFlagSet.getMask()).isEqualTo(MaskedFlag.mask(envFlag));
-        assertThat(envFlagSet.size()).isEqualTo(1);
-        assertThat(envFlagSet.isSet(EnvFlags.MDB_NOSUBDIR)).isEqualTo(false);
-        for (EnvFlags flag : envFlagSet) {
-            assertThat(envFlagSet.isSet(flag)).isEqualTo(true);
-        }
+    @Override
+    EnvFlagSet getFlagSet(Collection<EnvFlags> flags) {
+        return EnvFlagSet.of(flags);
+    }
 
-        final EnvFlagSet envFlagSet2 = EnvFlagSet.builder()
-            .setFlag(envFlag)
-            .build();
-        assertThat(envFlagSet).isEqualTo(envFlagSet2);
+    @Override
+    EnvFlagSet getFlagSet(EnvFlags[] flags) {
+        return EnvFlagSet.of(flags);
     }
 
-    @Test
-    public void testOf2() {
-        final EnvFlags envFlag1 = EnvFlags.MDB_FIXEDMAP;
-        final EnvFlags envFlag2 = EnvFlags.MDB_NORDAHEAD;
-        final EnvFlagSet envFlagSet = EnvFlagSet.of(envFlag1, envFlag2);
-        assertThat(envFlagSet.getMask()).isEqualTo(MaskedFlag.mask(envFlag1, envFlag2));
-        assertThat(envFlagSet.size()).isEqualTo(2);
-        assertThat(envFlagSet.isSet(EnvFlags.MDB_WRITEMAP)).isEqualTo(false);
-        for (EnvFlags flag : envFlagSet) {
-            assertThat(envFlagSet.isSet(flag)).isEqualTo(true);
-        }
+    @Override
+    EnvFlagSet getFlagSet(EnvFlags flag) {
+        return EnvFlagSet.of(flag);
     }
 
-    @Test
-    public void testBuilder() {
-        final EnvFlags envFlag1 = EnvFlags.MDB_FIXEDMAP;
-        final EnvFlags envFlag2 = EnvFlags.MDB_NORDAHEAD;
-        final EnvFlagSet envFlagSet = EnvFlagSet.builder()
-                .setFlag(envFlag1)
-                .setFlag(envFlag2)
-                .build();
-        assertThat(envFlagSet.getMask()).isEqualTo(MaskedFlag.mask(envFlag1, envFlag2));
-        assertThat(envFlagSet.size()).isEqualTo(2);
-        assertThat(envFlagSet.isSet(EnvFlags.MDB_NOTLS)).isEqualTo(false);
-        for (EnvFlags flag : envFlagSet) {
-            assertThat(envFlagSet.isSet(flag)).isEqualTo(true);
-        }
-        final EnvFlagSet envFlagSet2 = EnvFlagSet.builder()
-                .withFlags(envFlag1, envFlag2)
-                .build();
-        final EnvFlagSet envFlagSet3 = EnvFlagSet.builder()
-                .withFlags(new HashSet<>(Arrays.asList(envFlag1, envFlag2)))
-                .build();
-        assertThat(envFlagSet).isEqualTo(envFlagSet2);
-        assertThat(envFlagSet).isEqualTo(envFlagSet3);
+    @Override
+    Class<EnvFlags> getFlagType() {
+        return EnvFlags.class;
     }
 }
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 23cf65a4..9991b870 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -15,89 +15,51 @@
  */
 package org.lmdbjava;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 import java.time.Duration;
 import java.time.Instant;
 import java.util.Arrays;
-import java.util.HashSet;
+import java.util.Collection;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import org.junit.jupiter.api.Test;
 
-public class PutFlagSetTest {
+public class PutFlagSetTest extends AbstractFlagSetTest<PutFlags, PutFlagSet> {
 
-  @Test
-  public void testEmpty() {
-    final PutFlagSet putFlagSet = PutFlagSet.empty();
-    assertThat(putFlagSet.getMask()).isEqualTo(0);
-    assertThat(putFlagSet.size()).isEqualTo(0);
-    assertThat(putFlagSet.isEmpty()).isEqualTo(true);
-    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
-    final PutFlagSet putFlagSet2 = PutFlagSet.builder()
-        .build();
-    assertThat(putFlagSet).isEqualTo(putFlagSet2);
-    assertThat(putFlagSet).isNotEqualTo(PutFlagSet.of(PutFlags.MDB_APPEND));
-    assertThat(putFlagSet).isNotEqualTo(PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_RESERVE));
-    assertThat(putFlagSet).isNotEqualTo(PutFlagSet.builder()
-        .setFlag(PutFlags.MDB_CURRENT)
-        .setFlag(PutFlags.MDB_MULTIPLE)
-        .build());
+  @Override
+  List<PutFlags> getAllFlags() {
+    return Arrays.stream(PutFlags.values())
+        .collect(Collectors.toList());
   }
 
-  @Test
-  public void testOf() {
-    final PutFlags putFlag = PutFlags.MDB_APPEND;
-    final PutFlagSet putFlagSet = PutFlagSet.of(putFlag);
-    assertThat(putFlagSet.getMask()).isEqualTo(MaskedFlag.mask(putFlag));
-    assertThat(putFlagSet.size()).isEqualTo(1);
-    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
-    for (PutFlags flag : putFlagSet) {
-      assertThat(putFlagSet.isSet(flag)).isEqualTo(true);
-    }
+  @Override
+  PutFlagSet getEmptyFlagSet() {
+    return PutFlagSet.empty();
+  }
 
-    final PutFlagSet putFlagSet2 = PutFlagSet.builder()
-        .setFlag(putFlag)
-        .build();
-    assertThat(putFlagSet).isEqualTo(putFlagSet2);
+  @Override
+  AbstractFlagSet.Builder<PutFlags, PutFlagSet> getBuilder() {
+    return PutFlagSet.builder();
   }
 
-  @Test
-  public void testOf2() {
-    final PutFlags putFlag1 = PutFlags.MDB_APPEND;
-    final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
-    final PutFlagSet putFlagSet = PutFlagSet.of(putFlag1, putFlag2);
-    assertThat(putFlagSet.getMask()).isEqualTo(MaskedFlag.mask(putFlag1, putFlag2));
-    assertThat(putFlagSet.size()).isEqualTo(2);
-    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
-    for (PutFlags flag : putFlagSet) {
-      assertThat(putFlagSet.isSet(flag)).isEqualTo(true);
-    }
+  @Override
+  PutFlagSet getFlagSet(Collection<PutFlags> flags) {
+    return PutFlagSet.of(flags);
   }
 
-  @Test
-  public void testBuilder() {
-    final PutFlags putFlag1 = PutFlags.MDB_APPEND;
-    final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
-    final PutFlagSet putFlagSet = PutFlagSet.builder()
-        .setFlag(putFlag1)
-        .setFlag(putFlag2)
-        .build();
-    assertThat(putFlagSet.getMask()).isEqualTo(MaskedFlag.mask(putFlag1, putFlag2));
-    assertThat(putFlagSet.size()).isEqualTo(2);
-    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
-    for (PutFlags flag : putFlagSet) {
-      assertThat(putFlagSet.isSet(flag)).isEqualTo(true);
-    }
-    final PutFlagSet putFlagSet2 = PutFlagSet.builder()
-        .withFlags(putFlag1, putFlag2)
-        .build();
-    final PutFlagSet putFlagSet3 = PutFlagSet.builder()
-        .withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2)))
-        .build();
-    assertThat(putFlagSet).isEqualTo(putFlagSet2);
-    assertThat(putFlagSet).isEqualTo(putFlagSet3);
+  @Override
+  PutFlagSet getFlagSet(PutFlags[] flags) {
+    return PutFlagSet.of(flags);
+  }
+
+  @Override
+  PutFlagSet getFlagSet(PutFlags flag) {
+    return PutFlagSet.of(flag);
+  }
+
+  @Override
+  Class<PutFlags> getFlagType() {
+    return PutFlags.class;
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 58f75aa6..87455cb7 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -15,82 +15,46 @@
  */
 package org.lmdbjava;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
 
-import java.util.Collections;
-import java.util.HashSet;
-import org.junit.jupiter.api.Test;
+public class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
 
-public class TxnFlagSetTest {
+  @Override
+  List<TxnFlags> getAllFlags() {
+    return Arrays.stream(TxnFlags.values())
+        .collect(Collectors.toList());
+  }
 
-  @Test
-  void testSingleEnum() {
-    final TxnFlagSet txnFlagSet = TxnFlags.MDB_RDONLY_TXN;
-    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(TxnFlags.MDB_RDONLY_TXN));
-    assertThat(txnFlagSet.size()).isEqualTo(1);
-    for (TxnFlags flag : txnFlagSet) {
-      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
-    }
+  @Override
+  TxnFlagSet getEmptyFlagSet() {
+    return TxnFlagSet.empty();
+  }
 
-    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-        .setFlag(TxnFlags.MDB_RDONLY_TXN)
-        .build();
-    assertThat(txnFlagSet2.getFlags()).containsExactlyElementsOf(txnFlagSet.getFlags());
-    assertThat(txnFlagSet.areAnySet(TxnFlags.MDB_RDONLY_TXN)).isTrue();
-    assertThat(txnFlagSet.areAnySet(TxnFlagSet.empty())).isFalse();
+  @Override
+  AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> getBuilder() {
+    return TxnFlagSet.builder();
   }
 
-  @Test
-  public void testEmpty() {
-    final TxnFlagSet txnFlagSet = TxnFlagSet.empty();
-    assertThat(txnFlagSet.getMask()).isEqualTo(0);
-    assertThat(txnFlagSet.size()).isEqualTo(0);
-    assertThat(txnFlagSet.isEmpty()).isEqualTo(true);
-    assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(false);
-    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-        .build();
-    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
-    assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.of(TxnFlags.MDB_RDONLY_TXN));
-    assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.builder()
-        .setFlag(TxnFlags.MDB_RDONLY_TXN)
-        .build());
+  @Override
+  TxnFlagSet getFlagSet(Collection<TxnFlags> flags) {
+    return TxnFlagSet.of(flags);
   }
 
-  @Test
-  public void testOf() {
-    final TxnFlags txnFlag = TxnFlags.MDB_RDONLY_TXN;
-    final TxnFlagSet txnFlagSet = TxnFlagSet.of(txnFlag);
-    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag));
-    assertThat(txnFlagSet.size()).isEqualTo(1);
-    for (TxnFlags flag : txnFlagSet) {
-      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
-    }
+  @Override
+  TxnFlagSet getFlagSet(TxnFlags[] flags) {
+    return TxnFlagSet.of(flags);
+  }
 
-    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-        .setFlag(txnFlag)
-        .build();
-    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+  @Override
+  TxnFlagSet getFlagSet(TxnFlags flag) {
+    return TxnFlagSet.of(flag);
   }
 
-  @Test
-  public void testBuilder() {
-    final TxnFlags txnFlag1 = TxnFlags.MDB_RDONLY_TXN;
-    final TxnFlagSet txnFlagSet = TxnFlagSet.builder()
-        .setFlag(txnFlag1)
-        .build();
-    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag1));
-    assertThat(txnFlagSet.size()).isEqualTo(1);
-    assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(true);
-    for (TxnFlags flag : txnFlagSet) {
-      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
-    }
-    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-        .withFlags(txnFlag1)
-        .build();
-    final TxnFlagSet txnFlagSet3 = TxnFlagSet.builder()
-        .withFlags(new HashSet<>(Collections.singletonList(txnFlag1)))
-        .build();
-    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
-    assertThat(txnFlagSet).isEqualTo(txnFlagSet3);
+  @Override
+  Class<TxnFlags> getFlagType() {
+    return TxnFlags.class;
   }
 }

From 7a6910b545363fabaa17b9a6f4017671c72968e6 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 11:33:35 +0000
Subject: [PATCH 36/90] Add licence header

---
 .../java/org/lmdbjava/AbstractFlagSetTest.java    | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index e09d72c6..298ee2fe 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import static org.assertj.core.api.Assertions.assertThat;

From 167cdadf3059ad0626e13349a5f84a65d8f454be Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 11:35:58 +0000
Subject: [PATCH 37/90] Rename buildDbi to createDbi to be consistent with
 Env.create()

---
 src/main/java/org/lmdbjava/Env.java           | 24 +++++++++----------
 .../org/lmdbjava/ByteBufferProxyTest.java     |  2 +-
 .../CursorIterableIntegerDupTest.java         | 10 ++++----
 .../CursorIterableIntegerKeyTest.java         | 10 ++++----
 .../org/lmdbjava/CursorIterablePerfTest.java  |  6 ++---
 .../java/org/lmdbjava/CursorIterableTest.java | 10 ++++----
 .../java/org/lmdbjava/DbiBuilderTest.java     | 12 +++++-----
 src/test/java/org/lmdbjava/DbiTest.java       |  6 ++---
 8 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 542b67c3..b414101a 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -282,7 +282,7 @@ public boolean isReadOnly() {
    *
    * @return A new builder instance for creating/opening a {@link Dbi}.
    */
-  public DbiBuilder<T> buildDbi() {
+  public DbiBuilder<T> createDbi() {
     return new DbiBuilder<>(this, proxy, readOnly);
   }
 
@@ -290,7 +290,7 @@ public DbiBuilder<T> buildDbi() {
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default
    * {@link Comparator} that is not invoked from native code.
    * <p>
-   * For more options when opening a {@link Dbi} see {@link Env#buildDbi()}.
+   * For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
    * </p>
    * @param name       name of the database (or null if no name is required)
    * @param dbiFlagSet Flags to open the database with
@@ -309,7 +309,7 @@ public Dbi<T> openDbi(final String name, final DbiFlagSet dbiFlagSet) {
    * Convenience method that opens a {@link Dbi} with a default
    * {@link Comparator} that is not invoked from native code.
    * <p>
-   * For more options when opening a {@link Dbi} see {@link Env#buildDbi()}.
+   * For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
    * </p>
    * @param name       name of the database (or null if no name is required)
    * @param dbiFlagSet Flags to open the database with
@@ -328,7 +328,7 @@ public Dbi<T> openDbi(final byte[] name,
    * @param name  name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()} or {@link Env#openDbi(String, DbiFlagSet)}
+   * @deprecated Instead use {@link Env#createDbi()} or {@link Env#openDbi(String, DbiFlagSet)}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
    * Comparator} that is not invoked from native code.
    */
@@ -344,7 +344,7 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
    *                   comparator will be used.
    * @param flags      to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#createDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
    *
@@ -368,7 +368,7 @@ public Dbi<T> openDbi(final String name,
    * @param nativeCb   whether LMDB native code calls back to the Java comparator
    * @param flags      to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#createDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop
    * keys as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to
@@ -388,7 +388,7 @@ public Dbi<T> openDbi(final String name,
    * @param name  name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#createDbi()}
    * <hr>
    * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
    * invoked from native code.
@@ -396,7 +396,7 @@ public Dbi<T> openDbi(final String name,
   @Deprecated()
   public Dbi<T> openDbi(final byte[] name,
                         final DbiFlags... flags) {
-    return buildDbi()
+    return createDbi()
         .setDbName(name)
         .withDefaultComparator()
         .setDbiFlags(flags)
@@ -408,7 +408,7 @@ public Dbi<T> openDbi(final byte[] name,
    * @param comparator custom comparator callback (or null to use LMDB default)
    * @param flags      to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#createDbi()}
    * <hr>
    * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that is not
    * invoked from native code.
@@ -418,7 +418,7 @@ public Dbi<T> openDbi(final byte[] name,
                         final Comparator<T> comparator,
                         final DbiFlags... flags) {
     requireNonNull(comparator);
-    return buildDbi()
+    return createDbi()
         .setDbName(name)
         .withIteratorComparator(ignored -> comparator)
         .setDbiFlags(flags)
@@ -431,7 +431,7 @@ public Dbi<T> openDbi(final byte[] name,
    * @param nativeCb   whether native code calls back to the Java comparator
    * @param flags      to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#createDbi()}
    * <hr>
    * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that may be
    * invoked from native code if specified.
@@ -459,7 +459,7 @@ public Dbi<T> openDbi(
    * @param nativeCb   whether native LMDB code should call back to the Java comparator
    * @param flags      to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#createDbi()}
    * Open the {@link Dbi} using the passed {@link Txn}.
    *
    * <p>The caller must commit the transaction after this method returns in order to retain the
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index a91fbf75..d9312cce 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -67,7 +67,7 @@ void buffersMustBeDirect() {
                 try (Env<ByteBuffer> env = create()
                     .setMaxReaders(1)
                     .open(dir)) {
-                  final Dbi<ByteBuffer> db = env.buildDbi()
+                  final Dbi<ByteBuffer> db = env.createDbi()
                       .setDbName(DB_1)
                       .withDefaultComparator()
                       .setDbiFlags(MDB_CREATE)
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 1098ca5c..091f5768 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -337,7 +337,7 @@ public void openClosedBackwardTestWithGuava() {
           return guava.compare(array1, array2);
         };
 
-    final Dbi<ByteBuffer> guavaDbi = env.buildDbi()
+    final Dbi<ByteBuffer> guavaDbi = env.createDbi()
         .setDbName(DB_1).withIteratorComparator(ignored -> comparator)
         .setDbiFlags(MDB_CREATE)
         .open();
@@ -529,25 +529,25 @@ static class MyArgumentProvider implements ArgumentsProvider {
     public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters,
                                                         ExtensionContext context) throws Exception {
       final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_1)
               .withDefaultComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_2)
               .withNativeComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_3)
               .withCallbackComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_4)
               .withIteratorComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 007b5e29..e4f89302 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -432,7 +432,7 @@ public void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.buildDbi()
+    final Dbi<ByteBuffer> guavaDbi = env.createDbi()
         .setDbName(DB_1)
         .withIteratorComparator(ignored -> comparator)
         .setDbiFlags(MDB_CREATE)
@@ -602,25 +602,25 @@ static class MyArgumentProvider implements ArgumentsProvider {
     public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters,
                                                         ExtensionContext context) throws Exception {
       final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_1)
               .withDefaultComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_2)
               .withNativeComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_3)
               .withCallbackComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_4)
               .withIteratorComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 80555966..cc91a8fb 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -59,20 +59,20 @@ public void before() throws IOException {
 
     final DbiFlagSet dbiFlagSet = MDB_CREATE;
     // Use a java comparator for start/stop keys only
-    Dbi<ByteBuffer> dbJavaComparator = env.buildDbi()
+    Dbi<ByteBuffer> dbJavaComparator = env.createDbi()
         .setDbName("JavaComparator")
         .withDefaultComparator()
         .setDbiFlags(dbiFlagSet)
         .open();
     // Use LMDB comparator for start/stop keys
-    Dbi<ByteBuffer> dbLmdbComparator = env.buildDbi()
+    Dbi<ByteBuffer> dbLmdbComparator = env.createDbi()
         .setDbName("LmdbComparator")
         .withNativeComparator()
         .setDbiFlags(dbiFlagSet)
         .open();
 
     // Use a java comparator for start/stop keys and as a callback comparator
-    Dbi<ByteBuffer> dbCallbackComparator = env.buildDbi()
+    Dbi<ByteBuffer> dbCallbackComparator = env.createDbi()
         .setDbName("CallBackComparator")
         .withCallbackComparator(bufferProxy::getComparator)
         .setDbiFlags(dbiFlagSet)
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index e48f1e69..b991b809 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -308,7 +308,7 @@ void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.buildDbi()
+    final Dbi<ByteBuffer> guavaDbi = env.createDbi()
         .setDbName(DB_1)
         .withDefaultComparator()
         .setDbiFlags(MDB_CREATE)
@@ -537,25 +537,25 @@ static class MyArgumentProvider implements ArgumentsProvider {
     public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters,
                                                         ExtensionContext context) throws Exception {
       final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_1)
               .withDefaultComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_2)
               .withNativeComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_3)
               .withCallbackComparator(BUFFER_PROXY::getComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_4)
               .withIteratorComparator(BUFFER_PROXY::getComparator)
               .setDbiFlags(DBI_FLAGS)
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index d01f6417..87b1db46 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -57,7 +57,7 @@ public void after() {
 
   @Test
   public void unnamed() {
-    final Dbi<ByteBuffer> dbi = env.buildDbi()
+    final Dbi<ByteBuffer> dbi = env.createDbi()
         .withoutDbName()
         .withDefaultComparator()
         .setDbiFlags(DbiFlags.MDB_CREATE)
@@ -70,7 +70,7 @@ public void unnamed() {
 
   @Test
   public void named() {
-    final Dbi<ByteBuffer> dbi = env.buildDbi()
+    final Dbi<ByteBuffer> dbi = env.createDbi()
         .setDbName("foo")
         .withDefaultComparator()
         .setDbiFlags(DbiFlags.MDB_CREATE)
@@ -89,7 +89,7 @@ public void named() {
 
   @Test
   public void named2() {
-    final Dbi<ByteBuffer> dbi = env.buildDbi()
+    final Dbi<ByteBuffer> dbi = env.createDbi()
         .setDbName("foo".getBytes(StandardCharsets.US_ASCII))
         .withDefaultComparator()
         .setDbiFlags(DbiFlags.MDB_CREATE)
@@ -108,7 +108,7 @@ public void named2() {
 
   @Test
   public void nativeComparator() {
-    final Dbi<ByteBuffer> dbi = env.buildDbi()
+    final Dbi<ByteBuffer> dbi = env.createDbi()
         .setDbName("foo")
         .withNativeComparator()
         .addDbiFlags(DbiFlags.MDB_CREATE)
@@ -131,7 +131,7 @@ public void callback() {
       }
     };
 
-    final Dbi<ByteBuffer> dbi = env.buildDbi()
+    final Dbi<ByteBuffer> dbi = env.createDbi()
         .setDbName("foo")
         .withCallbackComparator(ignored -> comparator)
         .addDbiFlags(DbiFlags.MDB_CREATE)
@@ -163,7 +163,7 @@ public void callback() {
 
   @Test
   public void flags() {
-    final Dbi<ByteBuffer> dbi = env.buildDbi()
+    final Dbi<ByteBuffer> dbi = env.createDbi()
         .setDbName("foo")
         .withDefaultComparator()
         .setDbiFlags(DbiFlags.MDB_DUPSORT, DbiFlags.MDB_DUPFIXED) // Will get overwritten
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 6d86bd85..2d84b467 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -109,7 +109,7 @@ void afterEach() {
   void close() {
     assertThatThrownBy(
         () -> {
-          final Dbi<ByteBuffer> db = env.buildDbi()
+          final Dbi<ByteBuffer> db = env.createDbi()
               .setDbName(DB_1)
               .withDefaultComparator()
               .addDbiFlag(MDB_CREATE)
@@ -152,7 +152,7 @@ private <T> void doCustomComparator(
       Comparator<T> comparator,
       IntFunction<T> serializer,
       ToIntFunction<T> deserializer) {
-    final Dbi<T> db = env.buildDbi()
+    final Dbi<T> db = env.createDbi()
         .setDbName(DB_1)
         .withCallbackComparator(ignored -> comparator)
         .setDbiFlags(MDB_CREATE)
@@ -203,7 +203,7 @@ private <T> void doDbiWithComparatorThreadSafety(
       ToIntFunction<T> deserializer) {
     final DbiFlagSet flags = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
     final Comparator<T> comparator = comparatorSupplier.get();
-    final Dbi<T> db = env.buildDbi()
+    final Dbi<T> db = env.createDbi()
         .setDbName(DB_1)
         .withCallbackComparator(ignored -> comparator)
         .setDbiFlags(flags)

From d47694ec249c3b48d51090f566e3d7b20eefb84b Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 12:20:47 +0000
Subject: [PATCH 38/90] Remove ByteUnits dep, add ByteUnit enum, add
 setMapSize() overload

---
 pom.xml                                       |  7 --
 src/main/java/org/lmdbjava/ByteUnit.java      | 90 +++++++++++++++++++
 src/main/java/org/lmdbjava/Env.java           | 66 ++++++--------
 src/test/java/org/lmdbjava/ByteUnitTest.java  | 64 +++++++++++++
 .../CursorIterableIntegerDupTest.java         |  3 +-
 .../CursorIterableIntegerKeyTest.java         |  3 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  |  3 +-
 .../java/org/lmdbjava/CursorIterableTest.java |  3 +-
 .../java/org/lmdbjava/CursorParamTest.java    |  3 +-
 src/test/java/org/lmdbjava/CursorTest.java    |  3 +-
 .../java/org/lmdbjava/DbiBuilderTest.java     |  3 +-
 src/test/java/org/lmdbjava/DbiTest.java       | 27 +++---
 src/test/java/org/lmdbjava/EnvTest.java       | 42 ++++-----
 src/test/java/org/lmdbjava/TxnTest.java       |  3 +-
 src/test/java/org/lmdbjava/VerifierTest.java  | 17 ++--
 15 files changed, 228 insertions(+), 109 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/ByteUnit.java
 create mode 100644 src/test/java/org/lmdbjava/ByteUnitTest.java

diff --git a/pom.xml b/pom.xml
index 4d60b903..11dbdeb5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -29,7 +29,6 @@
     <agrona.version>1.22.0</agrona.version>
     <assertj.version>3.27.6</assertj.version>
     <buildnumber-maven-plugin.version>3.2.1</buildnumber-maven-plugin.version>
-    <byteunits.version>0.9.1</byteunits.version>
     <central-publishing-maven-plugin.version>0.9.0</central-publishing-maven-plugin.version>
     <fmt-maven-plugin.version>2.29</fmt-maven-plugin.version>
     <google-java-format.version>1.28.0</google-java-format.version>
@@ -85,12 +84,6 @@
       <version>${guava.version}</version>
       <scope>test</scope>
     </dependency>
-    <dependency>
-      <groupId>com.jakewharton.byteunits</groupId>
-      <artifactId>byteunits</artifactId>
-      <version>${byteunits.version}</version>
-      <scope>test</scope>
-    </dependency>
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-buffer</artifactId>
diff --git a/src/main/java/org/lmdbjava/ByteUnit.java b/src/main/java/org/lmdbjava/ByteUnit.java
new file mode 100644
index 00000000..96d0dba7
--- /dev/null
+++ b/src/main/java/org/lmdbjava/ByteUnit.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+/**
+ * Simple {@link Enum} for converting various IEC and SI byte units down a number of bytes.
+ */
+public enum ByteUnit {
+
+  BYTES(1L),
+
+  /**
+   * IEC byte unit for 1024 bytes.
+   */
+  KIBIBYTES(1024L),
+  /**
+   * IEC byte unit for 1024^2 bytes.
+   */
+  MEBIBYTES(1_0485_76L),
+  /**
+   * IEC byte unit for 1024^3 bytes.
+   */
+  GIBIBYTES(1_073_741_824L),
+  /**
+   * IEC byte unit for 1024^4 bytes.
+   */
+  TEBIBYTES(1_099_511_627_776L),
+  /**
+   * IEC byte unit for 1024^5 bytes.
+   */
+  PEBIBYTES(1_125_899_906_842_624L),
+
+  /**
+   * SI byte unit for 1000 bytes.
+   */
+  KILOBYTES(1_000L),
+  /**
+   * SI byte unit for 1000^2 bytes.
+   */
+  MEGABYTES(1_000_000L),
+  /**
+   * SI byte unit for 1000^3 bytes.
+   */
+  GIGABYTES(1_000_000_000L),
+  /**
+   * SI byte unit for 1000^4 bytes.
+   */
+  TERABYTES(1_000_000_000_000L),
+  /**
+   * SI byte unit for 1000^5 bytes.
+   */
+  PETABYTES(1_000_000_000_000_000L),
+  ;
+
+  private final long factor;
+
+  ByteUnit(long factor) {
+    this.factor = factor;
+  }
+
+  /**
+   * Convert the value in this byte unit into bytes.
+   *
+   * @param value The value to convert.
+   * @return The number of bytes.
+   */
+  public long toBytes(final long value) {
+    return value * factor;
+  }
+
+  /**
+   * @return The factor to apply when converting this unit into bytes.
+   */
+  public long getFactor() {
+    return factor;
+  }
+}
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index b414101a..2565bc65 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -63,11 +63,6 @@ public final class Env<T> implements AutoCloseable {
    */
   public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
 
-  private static final long KIBIBYTES = 1_024L;
-  private static final long MEBIBYTES = KIBIBYTES * 1_024L;
-  private static final long GIBIBYTES = MEBIBYTES * 1_024L;
-  private static final long TEBIBYTES = GIBIBYTES * 1_024L;
-
   private boolean closed;
   private final int maxKeySize;
   private final boolean noSubDir;
@@ -120,8 +115,9 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
    */
   @Deprecated
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
+
     return new Builder<>(PROXY_OPTIMAL)
-        .setMapSize(size * MEBIBYTES)
+        .setMapSize(size, ByteUnit.MEBIBYTES)
         .open(path, flags);
   }
 
@@ -218,9 +214,22 @@ public List<byte[]> getDbiNames() {
    * @param mapSize the new size, in bytes
    */
   public void setMapSize(final long mapSize) {
+    if (mapSize < 0) {
+      throw new IllegalArgumentException("Negative value; overflow?");
+    }
     checkRc(LIB.mdb_env_set_mapsize(ptr, mapSize));
   }
 
+  /**
+   * Set the size of the data memory map.
+   *
+   * @param mapSize the new size, in bytes
+   */
+  public void setMapSize(final long mapSize, final ByteUnit byteUnit) {
+    requireNonNull(byteUnit);
+    setMapSize(byteUnit.toBytes(mapSize));
+  }
+
   /**
    * Get the maximum size of keys and MDB_DUPSORT data we can write.
    *
@@ -668,7 +677,8 @@ public AlreadyOpenException() {
   public static final class Builder<T> {
 
     static final int MAX_READERS_DEFAULT = 126;
-    private long mapSize = 1_024 * 1_024;
+    static final long MAP_SIZE_DEFAULT = ByteUnit.MEBIBYTES.toBytes(1);
+    private long mapSize = MAP_SIZE_DEFAULT;
     private int maxDbs = 1;
     private int maxReaders = MAX_READERS_DEFAULT;
     private boolean opened;
@@ -772,43 +782,17 @@ public Builder<T> setMapSize(final long mapSize) {
     }
 
     /**
-     * Sets the map size in kibibytes
-     *
-     * @param mapSizeKb new limit in kibibytes
-     * @return the builder
-     */
-    public Builder<T> setMapSizeKb(final long mapSizeKb) {
-      return setMapSize(mapSizeKb * KIBIBYTES);
-    }
-
-    /**
-     * Sets the map size in mebibytes.
+     * Sets the map size in the supplied unit.
      *
-     * @param mapSizeMb new limit in mebibytes.
+     * @param mapSize new limit in
      * @return the builder
      */
-    public Builder<T> setMapSizeMb(final long mapSizeMb) {
-      return setMapSize(mapSizeMb * MEBIBYTES);
-    }
-
-    /**
-     * Sets the map size in gibibytes
-     *
-     * @param mapSizeGb new limit in gibibytes
-     * @return the builder
-     */
-    public Builder<T> setMapSizeGb(final long mapSizeGb) {
-      return setMapSize(mapSizeGb * GIBIBYTES);
-    }
-
-    /**
-     * Sets the map size in tebibytes.
-     *
-     * @param mapSizeTb new limit in tebibytes.
-     * @return the builder
-     */
-    public Builder<T> setMapSizeTb(final long mapSizeTb) {
-      return setMapSize(mapSizeTb * TEBIBYTES);
+    public Builder<T> setMapSize(final long mapSize, final ByteUnit byteUnit) {
+      requireNonNull(byteUnit);
+      if (mapSize < 0) {
+        throw new IllegalArgumentException("Negative value; overflow?");
+      }
+      return setMapSize(byteUnit.toBytes(mapSize));
     }
 
     /**
diff --git a/src/test/java/org/lmdbjava/ByteUnitTest.java b/src/test/java/org/lmdbjava/ByteUnitTest.java
new file mode 100644
index 00000000..a899cbc3
--- /dev/null
+++ b/src/test/java/org/lmdbjava/ByteUnitTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class ByteUnitTest {
+
+  @Test
+  void test() {
+    Assertions.assertThat(ByteUnit.BYTES.toBytes(2)).isEqualTo(2);
+
+    // BYTES
+    Assertions.assertThat(ByteUnit.BYTES.toBytes(2)).isEqualTo(2L);
+    Assertions.assertThat(ByteUnit.BYTES.toBytes(0)).isEqualTo(0L);
+
+    // IEC Units
+    Assertions.assertThat(ByteUnit.KIBIBYTES.toBytes(1)).isEqualTo(1024L);
+    Assertions.assertThat(ByteUnit.KIBIBYTES.toBytes(2)).isEqualTo(2048L);
+
+    Assertions.assertThat(ByteUnit.MEBIBYTES.toBytes(1)).isEqualTo(1048576L);
+    Assertions.assertThat(ByteUnit.MEBIBYTES.toBytes(2)).isEqualTo(2097152L);
+
+    Assertions.assertThat(ByteUnit.GIBIBYTES.toBytes(1)).isEqualTo(1073741824L);
+    Assertions.assertThat(ByteUnit.GIBIBYTES.toBytes(2)).isEqualTo(2147483648L);
+
+    Assertions.assertThat(ByteUnit.TEBIBYTES.toBytes(1)).isEqualTo(1099511627776L);
+    Assertions.assertThat(ByteUnit.TEBIBYTES.toBytes(2)).isEqualTo(2199023255552L);
+
+    Assertions.assertThat(ByteUnit.PEBIBYTES.toBytes(1)).isEqualTo(1125899906842624L);
+    Assertions.assertThat(ByteUnit.PEBIBYTES.toBytes(2)).isEqualTo(2251799813685248L);
+
+    // SI Units
+    Assertions.assertThat(ByteUnit.KILOBYTES.toBytes(1)).isEqualTo(1000L);
+    Assertions.assertThat(ByteUnit.KILOBYTES.toBytes(2)).isEqualTo(2000L);
+
+    Assertions.assertThat(ByteUnit.MEGABYTES.toBytes(1)).isEqualTo(1000000L);
+    Assertions.assertThat(ByteUnit.MEGABYTES.toBytes(2)).isEqualTo(2000000L);
+
+    Assertions.assertThat(ByteUnit.GIGABYTES.toBytes(1)).isEqualTo(1000000000L);
+    Assertions.assertThat(ByteUnit.GIGABYTES.toBytes(2)).isEqualTo(2000000000L);
+
+    Assertions.assertThat(ByteUnit.TERABYTES.toBytes(1)).isEqualTo(1000000000000L);
+    Assertions.assertThat(ByteUnit.TERABYTES.toBytes(2)).isEqualTo(2000000000000L);
+
+    Assertions.assertThat(ByteUnit.PETABYTES.toBytes(1)).isEqualTo(1000000000000000L);
+    Assertions.assertThat(ByteUnit.PETABYTES.toBytes(2)).isEqualTo(2000000000000000L);
+
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 091f5768..0e3d4e3e 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -15,7 +15,6 @@
  */
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
@@ -123,7 +122,7 @@ public void before() throws IOException {
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env =
         create(bufferProxy)
-            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMapSize(256, ByteUnit.KIBIBYTES)
             .setMaxReaders(1)
             .setMaxDbs(3)
             .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index e4f89302..3ff4364f 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -15,7 +15,6 @@
  */
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
@@ -104,7 +103,7 @@ public void before() throws IOException {
     file = FileUtil.createTempFile();
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env = Env.create(bufferProxy)
-        .setMapSize(KIBIBYTES.toBytes(256))
+        .setMapSize(256, ByteUnit.KIBIBYTES)
         .setMaxReaders(1)
         .setMaxDbs(3)
         .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index cc91a8fb..82bf337d 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -15,7 +15,6 @@
  */
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.GIBIBYTES;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -51,7 +50,7 @@ public void before() throws IOException {
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env =
         create(bufferProxy)
-            .setMapSize(GIBIBYTES.toBytes(1))
+            .setMapSize(1, ByteUnit.GIBIBYTES)
             .setMaxReaders(1)
             .setMaxDbs(3)
             .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index b991b809..e57e8ca4 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -98,7 +97,7 @@ void beforeEach() {
     file = FileUtil.createTempFile();
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env = create(bufferProxy)
-        .setMapSize(KIBIBYTES.toBytes(256))
+        .setMapSize(256, ByteUnit.KIBIBYTES)
         .setMaxReaders(1)
         .setMaxDbs(3)
         .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 4dd52b6f..f2fc5fbb 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.lang.Long.BYTES;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -158,7 +157,7 @@ public final void execute(final Path tmp) {
 
     private Env<T> env(final Path tmp) {
       return create(proxy)
-          .setMapSize(MEBIBYTES.toBytes(1))
+          .setMapSize(1, ByteUnit.MEBIBYTES)
           .setMaxReaders(1)
           .setMaxDbs(1)
           .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 9126026f..7177000a 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.lang.Long.BYTES;
 import static java.lang.Long.MIN_VALUE;
 import static java.nio.ByteBuffer.allocateDirect;
@@ -61,7 +60,7 @@ void beforeEach() {
     file = FileUtil.createTempFile();
     env =
         create(PROXY_OPTIMAL)
-            .setMapSize(MEBIBYTES.toBytes(1))
+            .setMapSize(1, ByteUnit.MEBIBYTES)
             .setMaxReaders(1)
             .setMaxDbs(1)
             .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index 87b1db46..ede387c9 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -15,7 +15,6 @@
  */
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -42,7 +41,7 @@ public class DbiBuilderTest {
   public void before() {
     file = FileUtil.createTempFile();
     env = create()
-        .setMapSize(MEBIBYTES.toBytes(64))
+        .setMapSize(64, ByteUnit.MEBIBYTES)
         .setMaxReaders(2)
         .setMaxDbs(2)
         .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 2d84b467..8b8a461b 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.lang.Long.MAX_VALUE;
 import static java.lang.System.getProperty;
 import static java.nio.ByteBuffer.allocateDirect;
@@ -82,19 +81,19 @@ public final class DbiTest {
   @BeforeEach
   void beforeEach() {
     file = FileUtil.createTempFile();
-    env =
-        create()
-            .setMapSize(MEBIBYTES.toBytes(64))
-            .setMaxReaders(2)
-            .setMaxDbs(2)
-            .open(file.toFile(), MDB_NOSUBDIR);
+    env = create()
+        .setMapSize(64, ByteUnit.MEBIBYTES)
+        .setMaxReaders(2)
+        .setMaxDbs(2)
+        .setEnvFlags(MDB_NOSUBDIR)
+        .open(file);
     fileBa = FileUtil.createTempFile();
-    envBa =
-        create(PROXY_BA)
-            .setMapSize(MEBIBYTES.toBytes(64))
-            .setMaxReaders(2)
-            .setMaxDbs(2)
-            .open(fileBa.toFile(), MDB_NOSUBDIR);
+    envBa = create(PROXY_BA)
+        .setMapSize(64, ByteUnit.MEBIBYTES)
+        .setMaxReaders(2)
+        .setMaxDbs(2)
+        .setEnvFlags(MDB_NOSUBDIR)
+        .open(fileBa);
   }
 
   @AfterEach
@@ -393,7 +392,7 @@ void putCommitGetByteArray() {
     FileUtil.useTempFile(
         file -> {
           try (Env<byte[]> envBa = create(PROXY_BA)
-              .setMapSize(MEBIBYTES.toBytes(64))
+              .setMapSize(64, ByteUnit.MEBIBYTES)
               .setMaxReaders(1)
               .setMaxDbs(2)
               .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 69c20c1b..6332ddc8 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.nio.ByteBuffer.allocateDirect;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -52,12 +51,11 @@ public final class EnvTest {
   void byteUnit() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env =
-                   Env.create()
-                       .setMaxReaders(1)
-                       .setMapSize(MEBIBYTES.toBytes(1))
-                       .setEnvFlags(MDB_NOSUBDIR)
-                       .open(file)) {
+          try (Env<ByteBuffer> env = Env.create()
+              .setMaxReaders(1)
+              .setMapSize(1, ByteUnit.MEBIBYTES)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
             final EnvInfo info = env.info();
             assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
           }
@@ -342,13 +340,12 @@ void createAsDirectory() {
   void createAsFile() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env =
-                   Env.create()
-                       .setMapSize(MEBIBYTES.toBytes(1))
-                       .setMaxDbs(1)
-                       .setMaxReaders(1)
-                       .setEnvFlags(MDB_NOSUBDIR)
-                       .open(file)) {
+          try (Env<ByteBuffer> env = Env.create()
+              .setMapSize(1, ByteUnit.MEBIBYTES)
+              .setMaxDbs(1)
+              .setMaxReaders(1)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
             env.sync(true);
             assertThat(Files.isRegularFile(file)).isTrue();
           }
@@ -404,7 +401,7 @@ void mapFull() {
                 try (Env<ByteBuffer> env =
                          Env.create()
                              .setMaxReaders(1)
-                             .setMapSize(MEBIBYTES.toBytes(8))
+                             .setMapSize(8, ByteUnit.MEBIBYTES)
                              .setMaxDbs(1)
                              .open(dir)) {
                   final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
@@ -452,12 +449,11 @@ void setMapSize() {
           final ByteBuffer key = allocateDirect(500);
           final ByteBuffer val = allocateDirect(1_024);
           final Random rnd = new Random();
-          try (Env<ByteBuffer> env =
-                   Env.create()
-                       .setMaxReaders(1)
-                       .setMapSize(KIBIBYTES.toBytes(256))
-                       .setMaxDbs(1)
-                       .open(dir)) {
+          try (Env<ByteBuffer> env = Env.create()
+              .setMaxReaders(1)
+              .setMapSize(256, ByteUnit.KIBIBYTES)
+              .setMaxDbs(1)
+              .open(dir)) {
             final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
             db.put(bb(1), bb(42));
@@ -475,7 +471,7 @@ void setMapSize() {
             }
             assertThat(mapFullExThrown).isTrue();
 
-            env.setMapSize(KIBIBYTES.toBytes(1024));
+            env.setMapSize(1024, ByteUnit.KIBIBYTES);
 
             try (Txn<ByteBuffer> roTxn = env.txnRead()) {
               final ByteBuffer byteBuffer = db.get(roTxn, bb(1));
@@ -525,7 +521,7 @@ void stats() {
   void testDefaultOpen() {
     FileUtil.useTempDir(
         dir -> {
-          try (Env<ByteBuffer> env = Env.create().setMapSizeMb(10).open(dir)) {
+          try (Env<ByteBuffer> env = Env.create().setMapSize(10, ByteUnit.MEBIBYTES).open(dir)) {
             final EnvInfo info = env.info();
             assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
             final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index f81b525e..ba8e55d3 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -64,7 +63,7 @@ void beforeEach() {
     file = FileUtil.createTempFile();
     env =
         create()
-            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMapSize(256, ByteUnit.KIBIBYTES)
             .setMaxReaders(1)
             .setMaxDbs(2)
             .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 64214568..75812e18 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -25,19 +24,21 @@
 import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.Test;
 
-/** Test {@link Verifier}. */
+/**
+ * Test {@link Verifier}.
+ */
 public final class VerifierTest {
 
   @Test
   void verification() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env =
-              create()
-                  .setMaxReaders(1)
-                  .setMaxDbs(Verifier.DBI_COUNT)
-                  .setMapSize(MEBIBYTES.toBytes(10))
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
+          try (Env<ByteBuffer> env = create()
+              .setMaxReaders(1)
+              .setMaxDbs(Verifier.DBI_COUNT)
+              .setMapSize(10, ByteUnit.MEBIBYTES)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
             final Verifier v = new Verifier(env);
             final int seconds = Integer.getInteger("verificationSeconds", 2);
             assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);

From fb087797f5154dfe77d568253ea1c72e11817973 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 12:25:47 +0000
Subject: [PATCH 39/90] Fix compile errors

---
 src/test/java/org/lmdbjava/EnvTest.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 6332ddc8..a2e3cb47 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.nio.ByteBuffer.allocateDirect;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -57,7 +56,7 @@ void byteUnit() {
               .setEnvFlags(MDB_NOSUBDIR)
               .open(file)) {
             final EnvInfo info = env.info();
-            assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
+            assertThat(info.mapSize).isEqualTo(ByteUnit.MEBIBYTES.toBytes(1));
           }
         });
   }

From a82d7f234d33f35ae15cf0340fe9068af6d967c1 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 12:38:47 +0000
Subject: [PATCH 40/90] Add more test coverage

---
 src/main/java/org/lmdbjava/Env.java            |  7 ++++---
 src/main/java/org/lmdbjava/FlagSet.java        | 15 ++++++---------
 .../java/org/lmdbjava/AbstractFlagSetTest.java | 18 ++++++++++++++----
 3 files changed, 24 insertions(+), 16 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 2565bc65..9b2a4360 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -115,7 +115,6 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
    */
   @Deprecated
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
-
     return new Builder<>(PROXY_OPTIMAL)
         .setMapSize(size, ByteUnit.MEBIBYTES)
         .open(path, flags);
@@ -678,13 +677,15 @@ public static final class Builder<T> {
 
     static final int MAX_READERS_DEFAULT = 126;
     static final long MAP_SIZE_DEFAULT = ByteUnit.MEBIBYTES.toBytes(1);
+    static final int POSIX_MODE_DEFAULT = 0664;
+
     private long mapSize = MAP_SIZE_DEFAULT;
     private int maxDbs = 1;
     private int maxReaders = MAX_READERS_DEFAULT;
     private boolean opened;
     private final BufferProxy<T> proxy;
-    private int mode = 0664;
-    private AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> flagSetBuilder = EnvFlagSet.builder();
+    private int mode = POSIX_MODE_DEFAULT;
+    private final AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> flagSetBuilder = EnvFlagSet.builder();
 
     Builder(final BufferProxy<T> proxy) {
       requireNonNull(proxy);
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index a9cffd47..94cb3dca 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -55,6 +55,11 @@ default int getMaskWith(final FlagSet<T> other) {
    */
   boolean isSet(T flag);
 
+  /**
+   * @return The number of flags in this set.
+   */
+  int size();
+
   /**
    * @return True if at least one of flags are included in thie {@link FlagSet}
    */
@@ -71,19 +76,11 @@ default boolean areAnySet(final FlagSet<T> flags) {
     return false;
   }
 
-  /**
-   * @return The size of this {@link FlagSet}
-   */
-  default int size() {
-    return getFlags().size();
-  }
 
   /**
    * @return True if this {@link FlagSet} is empty.
    */
-  default boolean isEmpty() {
-    return getFlags().isEmpty();
-  }
+  boolean isEmpty();
 
   /**
    * @return The {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index 298ee2fe..011d3efd 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -45,10 +45,6 @@ T getFirst() {
     return getAllFlags().get(0);
   }
 
-  int getFlagCount() {
-    return getAllFlags().size();
-  }
-
   @Test
   void testEmpty() {
     final F emptyFlagSet = getEmptyFlagSet();
@@ -81,6 +77,12 @@ void testSingleFlagSet() {
           .containsExactly(flag);
       assertThat(flagSet.size())
           .isEqualTo(1);
+      assertThat(FlagSet.equals(flagSet, new Object()))
+          .isFalse();
+      assertThat(FlagSet.equals(flagSet, null))
+          .isFalse();
+      assertThat(FlagSet.equals(flag, flag))
+          .isTrue();
       assertThat(FlagSet.equals(flagSet, flag))
           .isTrue();
       assertThat(FlagSet.equals(flagSet, getFlagSet(flag)))
@@ -89,6 +91,10 @@ void testSingleFlagSet() {
           .isTrue();
       assertThat(flagSet.areAnySet(flag))
           .isTrue();
+      assertThat(flagSet.areAnySet(null))
+          .isFalse();
+      assertThat(flagSet.areAnySet(getEmptyFlagSet()))
+          .isFalse();
       assertThat(flagSet.isSet(getFirst()))
           .isEqualTo(getFirst() == flag);
       if (getFirst() == flag) {
@@ -97,11 +103,15 @@ void testSingleFlagSet() {
       } else {
         assertThat(flagSet.getMask())
             .isNotEqualTo(MaskedFlag.mask(getFirst()));
+        assertThat(flagSet.getMaskWith(getFirst()))
+            .isEqualTo(MaskedFlag.mask(flag, getFirst()));
       }
       assertThat(flagSet.toString())
           .isNotNull();
       assertThat(flag.name())
           .isNotNull();
+      assertThat(flagSet.getMaskWith(null))
+          .isEqualTo(flagSet.getMask());
     }
   }
 

From 534b76ba3ba890810a99f2c4a13c5db4de672a23 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 18:34:20 +0000
Subject: [PATCH 41/90] Fix codeQL issue

---
 src/main/java/org/lmdbjava/DbiBuilder.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index b478c9df..7824458b 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -393,10 +393,10 @@ public Dbi<T> open() {
       if (txn != null) {
         return openDbi(txn, dbiBuilder);
       } else {
-        try (final Txn<T> txn = getTxn(dbiBuilder)) {
-          final Dbi<T> dbi = openDbi(txn, dbiBuilder);
+        try (final Txn<T> localTxn = getTxn(dbiBuilder)) {
+          final Dbi<T> dbi = openDbi(localTxn, dbiBuilder);
           // even RO Txns require a commit to retain Dbi in Env
-          txn.commit();
+          localTxn.commit();
           return dbi;
         }
       }

From e9f9ac4f8879ac9f0ca667b66a0cf4eacf7b424e Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 18:46:25 +0000
Subject: [PATCH 42/90] Add test coverage on FlagSet

---
 src/main/java/org/lmdbjava/CopyFlagSet.java   |  2 +-
 .../org/lmdbjava/AbstractFlagSetTest.java     | 33 +++++++++++++++++++
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index e21680dd..5350bada 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -21,7 +21,7 @@
 
 public interface CopyFlagSet extends FlagSet<CopyFlags> {
 
-  static CopyFlagSet EMPTY = CopyFlagSetImpl.EMPTY;
+  CopyFlagSet EMPTY = CopyFlagSetImpl.EMPTY;
 
   static CopyFlagSet empty() {
     return CopyFlagSetImpl.EMPTY;
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index 011d3efd..7358416b 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -159,6 +159,39 @@ void testAllFlags() {
     }
   }
 
+  /**
+   * Test as an enum instance rather than a {@link FlagSet}
+   */
+  @Test
+  void testAsFlag() {
+    final T flag = getFirst();
+    assertThat(flag.size())
+        .isEqualTo(1);
+    assertThat(flag.getFlags())
+        .hasSize(1);
+    final T flag2 = flag.getFlags().iterator().next();
+    assertThat(flag2 == flag)
+        .isTrue();
+    assertThat(flag.getMask())
+        .isEqualTo(MaskedFlag.mask(flag));
+    assertThat(flag.isEmpty())
+        .isFalse();
+    assertThat(flag.toString())
+        .isNotNull();
+    assertThat(flag.isSet(flag))
+        .isTrue();
+    assertThat(flag.isSet(flag2))
+        .isTrue();
+    assertThat(flag.isSet(null))
+        .isFalse();
+    final List<T> allFlags = getAllFlags();
+    if (allFlags.size() > 1) {
+      T secondFlag = allFlags.get(1);
+      assertThat(flag.isSet(secondFlag))
+          .isFalse();
+    }
+  }
+
   private T[] toArray(final int cnt) {
     //noinspection unchecked
     return (T[]) Array.newInstance(getFlagType(), cnt);

From b0112bb788347043ba4d19c3f138c06404d0fb35 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 19:02:00 +0000
Subject: [PATCH 43/90] Add tests

---
 src/test/java/org/lmdbjava/EnvTest.java | 52 ++++++++++++++++++++++++-
 1 file changed, 50 insertions(+), 2 deletions(-)

diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index a2e3cb47..e1e72401 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -32,6 +32,7 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.List;
 import java.util.Random;
 import org.junit.jupiter.api.Test;
 import org.lmdbjava.Env.AlreadyClosedException;
@@ -371,8 +372,11 @@ void detectTransactionThreadViolation() {
   void info() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env =
-                   Env.create().setMaxReaders(4).setMapSize(123_456).setEnvFlags(MDB_NOSUBDIR).open(file)) {
+          try (Env<ByteBuffer> env = Env.create()
+              .setMaxReaders(4)
+              .setMapSize(123_456)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
             final EnvInfo info = env.info();
             assertThat(info).isNotNull();
             assertThat(info.lastPageNumber).isEqualTo(1L);
@@ -470,6 +474,10 @@ void setMapSize() {
             }
             assertThat(mapFullExThrown).isTrue();
 
+            assertThatThrownBy(() -> {
+              env.setMapSize(-1, ByteUnit.KIBIBYTES);
+            }).isInstanceOf(IllegalArgumentException.class);
+
             env.setMapSize(1024, ByteUnit.KIBIBYTES);
 
             try (Txn<ByteBuffer> roTxn = env.txnRead()) {
@@ -528,4 +536,44 @@ void testDefaultOpen() {
           }
         });
   }
+
+  @Test
+  void testDefaultOpenNoName1() {
+    FileUtil.useTempDir(
+        dir -> {
+          try (Env<ByteBuffer> env = Env.create().setMapSize(10, ByteUnit.MEBIBYTES).open(dir)) {
+            final EnvInfo info = env.info();
+            assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
+            final Dbi<ByteBuffer> db = env.openDbi((String) null, MDB_CREATE);
+            db.put(bb("abc"), allocateDirect(1));
+            db.put(bb("def"), allocateDirect(1));
+
+            // As this is the unnamed database it returns all keys in the unnamed db
+            final List<byte[]> dbiNames = env.getDbiNames();
+            assertThat(dbiNames)
+                .hasSize(2);
+            assertThat(dbiNames.get(0))
+                .isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
+          }
+        });
+  }
+
+  @Test
+  void testDefaultOpenNoName2() {
+    FileUtil.useTempDir(
+        dir -> {
+          try (Env<ByteBuffer> env = Env.create().setMapSize(10, ByteUnit.MEBIBYTES).open(dir)) {
+            final EnvInfo info = env.info();
+            assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
+            final Dbi<ByteBuffer> db = env.openDbi((byte[]) null, MDB_CREATE);
+
+            // As this is the unnamed database it returns all keys in the unnamed db
+            final List<byte[]> dbiNames = env.getDbiNames();
+            assertThat(dbiNames)
+                .hasSize(1);
+            assertThat(dbiNames.get(0))
+                .isEqualTo(new byte[0]);
+          }
+        });
+  }
 }

From c25a7d243d2ca9103f527f784185d35ceae4c330 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 10:09:54 +0000
Subject: [PATCH 44/90] Run format plugin

---
 .../java/org/lmdbjava/AbstractFlagSet.java    |  28 +-
 src/main/java/org/lmdbjava/BufferProxy.java   |   1 -
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  15 +-
 .../java/org/lmdbjava/ByteBufferProxy.java    |  36 +-
 src/main/java/org/lmdbjava/ByteUnit.java      |  45 +-
 src/main/java/org/lmdbjava/CopyFlagSet.java   |  21 +-
 src/main/java/org/lmdbjava/Cursor.java        |  85 ++--
 .../java/org/lmdbjava/CursorIterable.java     |   4 -
 src/main/java/org/lmdbjava/Dbi.java           |  83 ++--
 src/main/java/org/lmdbjava/DbiBuilder.java    | 305 +++++-------
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  25 +-
 src/main/java/org/lmdbjava/DbiFlags.java      |  36 +-
 .../java/org/lmdbjava/DirectBufferProxy.java  |  18 +-
 src/main/java/org/lmdbjava/Env.java           | 306 +++++-------
 src/main/java/org/lmdbjava/EnvFlagSet.java    |  21 +-
 src/main/java/org/lmdbjava/FlagSet.java       |  33 +-
 src/main/java/org/lmdbjava/MaskedFlag.java    |   4 +-
 src/main/java/org/lmdbjava/PutFlagSet.java    |  65 ++-
 src/main/java/org/lmdbjava/Txn.java           |   4 +-
 src/main/java/org/lmdbjava/TxnFlagSet.java    |  26 +-
 .../org/lmdbjava/AbstractFlagSetTest.java     | 156 ++----
 .../org/lmdbjava/ByteBufferProxyTest.java     | 124 ++---
 src/test/java/org/lmdbjava/ByteUnitTest.java  |   1 -
 .../lmdbjava/ComparatorIntegerKeyTest.java    | 101 ++--
 .../java/org/lmdbjava/CopyFlagSetTest.java    |  69 ++-
 .../CursorIterableIntegerDupTest.java         | 310 ++++++------
 .../CursorIterableIntegerKeyTest.java         | 335 ++++++-------
 .../org/lmdbjava/CursorIterablePerfTest.java  |  33 +-
 .../java/org/lmdbjava/CursorIterableTest.java | 368 ++++++++-------
 .../java/org/lmdbjava/CursorParamTest.java    |   3 +-
 src/test/java/org/lmdbjava/CursorTest.java    |   3 +-
 .../java/org/lmdbjava/DbiBuilderTest.java     | 182 +++----
 .../java/org/lmdbjava/DbiFlagSetTest.java     |  69 ++-
 src/test/java/org/lmdbjava/DbiTest.java       | 225 ++++-----
 .../java/org/lmdbjava/EnvFlagSetTest.java     |  69 ++-
 src/test/java/org/lmdbjava/EnvTest.java       | 444 +++++++++---------
 .../org/lmdbjava/GarbageCollectionTest.java   |   5 +-
 .../java/org/lmdbjava/PutFlagSetTest.java     |  15 +-
 src/test/java/org/lmdbjava/TestUtils.java     |  15 +-
 src/test/java/org/lmdbjava/TutorialTest.java  |  50 +-
 .../java/org/lmdbjava/TxnFlagSetTest.java     |   3 +-
 src/test/java/org/lmdbjava/TxnTest.java       |   6 +-
 src/test/java/org/lmdbjava/VerifierTest.java  |  17 +-
 43 files changed, 1736 insertions(+), 2028 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 849bbe73..fbaa4c6f 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -24,9 +24,7 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
-/**
- * Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
- */
+/** Encapsulates an immutable set of flags and the associated bit mask for the flags in the set. */
 public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
 
   private final Set<T> flags;
@@ -60,8 +58,7 @@ public Set<T> getFlags() {
   @Override
   public boolean isSet(final T flag) {
     // Probably cheaper to compare the masks than to use EnumSet.contains()
-    return flag != null
-        && MaskedFlag.isSet(mask, flag);
+    return flag != null && MaskedFlag.isSet(mask, flag);
   }
 
   /**
@@ -103,11 +100,10 @@ public String toString() {
     return FlagSet.asString(this);
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  static abstract class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
+  abstract static class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag>
+      implements FlagSet<T> {
 
     private final T flag;
     // Only holding this for iterator() and getFlags() so make it lazy.
@@ -186,10 +182,8 @@ private Set<T> initSet() {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   static class AbstractEmptyFlagSet<T extends MaskedFlag> implements FlagSet<T> {
 
     @Override
@@ -243,10 +237,8 @@ public int hashCode() {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * A builder for creating a {@link AbstractFlagSet}.
    *
@@ -261,10 +253,11 @@ public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>
     final Function<E, S> singletonSetConstructor;
     final Supplier<S> emptySetSupplier;
 
-    protected Builder(final Class<E> type,
-                      final Function<EnumSet<E>, S> constructor,
-                      final Function<E, S> singletonSetConstructor,
-                      final Supplier<S> emptySetSupplier) {
+    protected Builder(
+        final Class<E> type,
+        final Function<EnumSet<E>, S> constructor,
+        final Function<E, S> singletonSetConstructor,
+        final Supplier<S> emptySetSupplier) {
       this.type = type;
       this.enumSet = EnumSet.noneOf(type);
       this.constructor = Objects.requireNonNull(constructor);
@@ -273,7 +266,8 @@ protected Builder(final Class<E> type,
     }
 
     /**
-     * Replaces any flags already set in the builder with the contents of the passed flags {@link Collection}
+     * Replaces any flags already set in the builder with the contents of the passed flags {@link
+     * Collection}
      *
      * @param flags The flags to set in the builder.
      * @return this builder instance.
diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index f857ade7..a3c339bf 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -40,7 +40,6 @@ public abstract class BufferProxy<T> {
   /** Offset from a pointer of the <code>MDB_val.mv_size</code> field. */
   protected static final int STRUCT_FIELD_OFFSET_SIZE = 0;
 
-
   /** Explicitly-defined default constructor to avoid warnings. */
   protected BufferProxy() {}
 
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 19d94392..bcbb6ebf 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -89,8 +89,8 @@ public static int compareLexicographically(final ByteBuf o1, final ByteBuf o2) {
   }
 
   /**
-   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
-   * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs, i.e. when using
+   * MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
    *
    * @param o1 left operand (required)
    * @param o2 right operand (required)
@@ -101,12 +101,17 @@ public static int compareAsIntegerKeys(final ByteBuf o1, final ByteBuf o2) {
     requireNonNull(o2);
     // Both buffers should be same length according to LMDB API.
     // From the LMDB docs for MDB_INTEGER_KEY
-    // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the same size.
+    // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the
+    // same size.
     final int len1 = o1.readableBytes();
     final int len2 = o2.readableBytes();
     if (len1 != len2) {
-      throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
-          + ". Lengths must be identical and either 4 or 8 bytes.");
+      throw new RuntimeException(
+          "Length mismatch, len1: "
+              + len1
+              + ", len2: "
+              + len2
+              + ". Lengths must be identical and either 4 or 8 bytes.");
     }
     if (len1 == 8) {
       final long lw;
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 1f82e953..52bfc924 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -55,9 +55,7 @@ public final class ByteBufferProxy {
    */
   public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
 
-  /**
-   * The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null.
-   */
+  /** The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null. */
   public static final BufferProxy<ByteBuffer> PROXY_SAFE;
 
   private static final ByteOrder NATIVE_ORDER = ByteOrder.nativeOrder();
@@ -67,8 +65,7 @@ public final class ByteBufferProxy {
     PROXY_OPTIMAL = getProxyOptimal();
   }
 
-  private ByteBufferProxy() {
-  }
+  private ByteBufferProxy() {}
 
   private static BufferProxy<ByteBuffer> getProxyOptimal() {
     try {
@@ -78,25 +75,19 @@ private static BufferProxy<ByteBuffer> getProxyOptimal() {
     }
   }
 
-  /**
-   * The buffer must be a direct buffer (not heap allocated).
-   */
+  /** The buffer must be a direct buffer (not heap allocated). */
   public static final class BufferMustBeDirectException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public BufferMustBeDirectException() {
       super("The buffer must be a direct buffer (not heap allocated");
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -150,8 +141,8 @@ public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer
     }
 
     /**
-     * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
-     * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+     * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs, i.e. when
+     * using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
      *
      * @param o1 left operand (required)
      * @param o2 right operand (required)
@@ -162,12 +153,17 @@ public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2)
       requireNonNull(o2);
       // Both buffers should be same length according to LMDB API.
       // From the LMDB docs for MDB_INTEGER_KEY
-      // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the same size.
+      // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of
+      // the same size.
       final int len1 = o1.limit();
       final int len2 = o2.limit();
       if (len1 != len2) {
-        throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
-            + ". Lengths must be identical and either 4 or 8 bytes.");
+        throw new RuntimeException(
+            "Length mismatch, len1: "
+                + len1
+                + ", len2: "
+                + len2
+                + ". Lengths must be identical and either 4 or 8 bytes.");
       }
       // Keys for MDB_INTEGER_KEY are written in native order so ensure we read them in that order
       o1.order(NATIVE_ORDER);
@@ -250,10 +246,8 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -298,10 +292,8 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.
diff --git a/src/main/java/org/lmdbjava/ByteUnit.java b/src/main/java/org/lmdbjava/ByteUnit.java
index 96d0dba7..ed4b1ca8 100644
--- a/src/main/java/org/lmdbjava/ByteUnit.java
+++ b/src/main/java/org/lmdbjava/ByteUnit.java
@@ -15,53 +15,30 @@
  */
 package org.lmdbjava;
 
-/**
- * Simple {@link Enum} for converting various IEC and SI byte units down a number of bytes.
- */
+/** Simple {@link Enum} for converting various IEC and SI byte units down a number of bytes. */
 public enum ByteUnit {
-
   BYTES(1L),
 
-  /**
-   * IEC byte unit for 1024 bytes.
-   */
+  /** IEC byte unit for 1024 bytes. */
   KIBIBYTES(1024L),
-  /**
-   * IEC byte unit for 1024^2 bytes.
-   */
+  /** IEC byte unit for 1024^2 bytes. */
   MEBIBYTES(1_0485_76L),
-  /**
-   * IEC byte unit for 1024^3 bytes.
-   */
+  /** IEC byte unit for 1024^3 bytes. */
   GIBIBYTES(1_073_741_824L),
-  /**
-   * IEC byte unit for 1024^4 bytes.
-   */
+  /** IEC byte unit for 1024^4 bytes. */
   TEBIBYTES(1_099_511_627_776L),
-  /**
-   * IEC byte unit for 1024^5 bytes.
-   */
+  /** IEC byte unit for 1024^5 bytes. */
   PEBIBYTES(1_125_899_906_842_624L),
 
-  /**
-   * SI byte unit for 1000 bytes.
-   */
+  /** SI byte unit for 1000 bytes. */
   KILOBYTES(1_000L),
-  /**
-   * SI byte unit for 1000^2 bytes.
-   */
+  /** SI byte unit for 1000^2 bytes. */
   MEGABYTES(1_000_000L),
-  /**
-   * SI byte unit for 1000^3 bytes.
-   */
+  /** SI byte unit for 1000^3 bytes. */
   GIGABYTES(1_000_000_000L),
-  /**
-   * SI byte unit for 1000^4 bytes.
-   */
+  /** SI byte unit for 1000^4 bytes. */
   TERABYTES(1_000_000_000_000L),
-  /**
-   * SI byte unit for 1000^5 bytes.
-   */
+  /** SI byte unit for 1000^5 bytes. */
   PETABYTES(1_000_000_000_000_000L),
   ;
 
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index 5350bada..1aed9878 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -33,29 +33,20 @@ static CopyFlagSet of(final CopyFlags dbiFlag) {
   }
 
   static CopyFlagSet of(final CopyFlags... CopyFlags) {
-    return builder()
-        .setFlags(CopyFlags)
-        .build();
+    return builder().setFlags(CopyFlags).build();
   }
 
   static CopyFlagSet of(final Collection<CopyFlags> CopyFlags) {
-    return builder()
-        .setFlags(CopyFlags)
-        .build();
+    return builder().setFlags(CopyFlags).build();
   }
 
   static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
-        CopyFlags.class,
-        CopyFlagSetImpl::new,
-        copyFlag -> copyFlag,
-        () -> CopyFlagSetImpl.EMPTY);
+        CopyFlags.class, CopyFlagSetImpl::new, copyFlag -> copyFlag, () -> CopyFlagSetImpl.EMPTY);
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
 
     static final CopyFlagSet EMPTY = new EmptyCopyFlagSet();
@@ -65,10 +56,8 @@ private CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags> implements CopyFlagSet {
-  }
+  class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
+      implements CopyFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 245a5a9a..09c461e2 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -95,13 +95,10 @@ public long count() {
     checkRc(LIB.mdb_cursor_count(ptrCursor, longByReference));
     return longByReference.longValue();
   }
+
   /**
-   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}.
-   * <hr>
-   * Delete current key/data pair.
-   *
-   * <p>This function deletes the key/data pair to which the cursor refers.
-   *
+   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}. <hr> Delete current key/data pair.
+   *     <p>This function deletes the key/data pair to which the cursor refers.
    * @param flags flags (either null or {@link PutFlags#MDB_NODUPDATA}
    */
   @Deprecated
@@ -132,9 +129,7 @@ public void delete(final PutFlagSet flags) {
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final PutFlagSet putFlagSet = flags != null
-        ? flags
-        : PutFlagSet.EMPTY;
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
     checkRc(LIB.mdb_cursor_del(ptrCursor, putFlagSet.getMask()));
   }
 
@@ -257,12 +252,8 @@ public boolean prev() {
   }
 
   /**
-   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead.
-   * <hr>
-   * Store by cursor.
-   *
-   * <p>This function stores key/data pairs into the database.
-   *
+   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead. <hr> Store by cursor.
+   *     <p>This function stores key/data pairs into the database.
    * @param key key to store
    * @param val data to store
    * @param flags options for this operation
@@ -310,10 +301,9 @@ public boolean put(final T key, final T val, final PutFlagSet flags) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(val);
-    final PutFlagSet putFlagSet = flags != null
-        ? flags
-        : PutFlagSet.EMPTY;
-    final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), putFlagSet.getMask());
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
+    final int rc =
+        LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), putFlagSet.getMask());
     if (rc == MDB_KEYEXIST) {
       if (putFlagSet.isSet(MDB_NOOVERWRITE)) {
         kv.valOut(); // marked as in,out in LMDB C docs
@@ -331,15 +321,12 @@ public boolean put(final T key, final T val, final PutFlagSet flags) {
   }
 
   /**
-   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead.
-   * <hr>
-   * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
-   *
-   * <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
-   * contain fixed-sized values to be inserted. The size of each element is calculated from the
-   * buffer's size divided by the given element count. For example, to populate 10 X 4 byte integers
-   * at once, present a buffer of 40 bytes and specify the element as 10.
-   *
+   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead. <hr> Put multiple
+   *     values into the database in one <code>MDB_MULTIPLE</code> operation.
+   *     <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
+   *     contain fixed-sized values to be inserted. The size of each element is calculated from the
+   *     buffer's size divided by the given element count. For example, to populate 10 X 4 byte
+   *     integers at once, present a buffer of 40 bytes and specify the element as 10.
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
    * @param elements number of elements contained in the passed value buffer
@@ -377,8 +364,8 @@ public void putMultiple(final T key, final T val, final int elements) {
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
    * @param elements number of elements contained in the passed value buffer
-   * @param flags options for operation (must set <code>MDB_MULTIPLE</code>)
-   *              Either a {@link PutFlagSet} or a single {@link PutFlags}.
+   * @param flags options for operation (must set <code>MDB_MULTIPLE</code>) Either a {@link
+   *     PutFlagSet} or a single {@link PutFlags}.
    */
   public void putMultiple(final T key, final T val, final int elements, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
@@ -389,15 +376,14 @@ public void putMultiple(final T key, final T val, final int elements, final PutF
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final PutFlagSet putFlagSet = flags != null
-        ? flags
-        : PutFlagSet.EMPTY;
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
     if (SHOULD_CHECK && !putFlagSet.isSet(MDB_MULTIPLE)) {
       throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
     }
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer dataPtr = txn.kv().valInMulti(val, elements);
-    final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, putFlagSet.getMask());
+    final int rc =
+        LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, putFlagSet.getMask());
     checkRc(rc);
     ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(dataPtr);
@@ -429,16 +415,13 @@ public void renew(final Txn<T> newTxn) {
   }
 
   /**
-   * @deprecated Use {@link Cursor#reserve(Object, int, PutFlagSet)} instead.
-   * <hr>
-   * Reserve space for data of the given size, but don't copy the given val. Instead, return a
-   * pointer to the reserved space, which the caller can fill in later - before the next update
-   * operation or the transaction ends. This saves an extra memcpy if the data is being generated
-   * later. LMDB does nothing else with this memory, the caller is expected to modify all of the
-   * space requested.
-   *
-   * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
-   *
+   * @deprecated Use {@link Cursor#reserve(Object, int, PutFlagSet)} instead. <hr> Reserve space for
+   *     data of the given size, but don't copy the given val. Instead, return a pointer to the
+   *     reserved space, which the caller can fill in later - before the next update operation or
+   *     the transaction ends. This saves an extra memcpy if the data is being generated later. LMDB
+   *     does nothing else with this memory, the caller is expected to modify all of the space
+   *     requested.
+   *     <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    * @param key key to store in the database (not null)
    * @param size size of the value to be stored in the database (not null)
    * @param flags options for this operation
@@ -452,9 +435,9 @@ public T reserve(final T key, final int size, final PutFlags... flags) {
   /**
    * Reserve space for data of the given size, but don't copy the given val. Instead, return a
    * pointer to the reserved space, which the caller can fill in later - before the next update
-   * operation or the transaction ends. This saves an extra {@code memcpy} if the data is being generated
-   * later. LMDB does nothing else with this memory, the caller is expected to modify all the
-   * space requested.
+   * operation or the transaction ends. This saves an extra {@code memcpy} if the data is being
+   * generated later. LMDB does nothing else with this memory, the caller is expected to modify all
+   * the space requested.
    *
    * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    *
@@ -470,8 +453,8 @@ public T reserve(final T key, final int size) {
    * Reserve space for data of the given size, but don't copy the given val. Instead, return a
    * pointer to the reserved space, which the caller can fill in later - before the next update
    * operation or the transaction ends. This saves an extra memcpy if the data is being generated
-   * later. LMDB does nothing else with this memory, the caller is expected to modify all the
-   * space requested.
+   * later. LMDB does nothing else with this memory, the caller is expected to modify all the space
+   * requested.
    *
    * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    *
@@ -490,9 +473,7 @@ public T reserve(final T key, final int size, final PutFlagSet flags) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(size);
-    final PutFlagSet putFlagSet = flags != null
-        ? flags
-        : PutFlagSet.EMPTY;
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
     // This is inconsistent with putMultiple which require MDB_MULTIPLE to be in the set.
     final int flagsMask = putFlagSet.getMaskWith(MDB_RESERVE);
     checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flagsMask));
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 89dc5e84..2289f130 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -239,10 +239,8 @@ enum State {
     TERMINATED
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   static class JavaRangeComparator<T> implements RangeComparator {
 
     private final Comparator<T> comparator;
@@ -276,10 +274,8 @@ public void close() throws Exception {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order. Has a
    * very slight overhead as compared to {@link JavaRangeComparator}.
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 65527224..12ff6a36 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -51,6 +51,7 @@ public final class Dbi<T> {
 
   @SuppressWarnings("FieldCanBeLocal") // Needs to be instance variable for FFI
   private final ComparatorCallback callbackComparator;
+
   private boolean cleaned;
   // Used for CursorIterable KeyRange testing and/or native callbacks
   private final Comparator<T> comparator;
@@ -60,7 +61,8 @@ public final class Dbi<T> {
   private final BufferProxy<T> proxy;
   private final DbiFlagSet dbiFlagSet;
 
-  Dbi(final Env<T> env,
+  Dbi(
+      final Env<T> env,
       final Txn<T> txn,
       final byte[] name,
       final BufferProxy<T> proxy,
@@ -218,7 +220,7 @@ public void drop(final Txn<T> txn) {
    * closed. See {@link #close()} for implication of handle close. Otherwise, only the data in this
    * database will be dropped.
    *
-   * @param txn    transaction handle (not null; not committed; must be R-W)
+   * @param txn transaction handle (not null; not committed; must be R-W)
    * @param delete whether database should be deleted.
    */
   public void drop(final Txn<T> txn, final boolean delete) {
@@ -280,12 +282,11 @@ public String getNameAsString() {
     return getNameAsString(Env.DEFAULT_NAME_CHARSET);
   }
 
-
   /**
    * Obtains the name of this database, using the supplied {@link Charset}.
    *
-   * @return The name of the database. If this is the unnamed database an empty
-   * string will be returned.
+   * @return The name of the database. If this is the unnamed database an empty string will be
+   *     returned.
    * @throws RuntimeException if the name can't be decoded.
    */
   public String getNameAsString(final Charset charset) {
@@ -314,7 +315,7 @@ public CursorIterable<T> iterate(final Txn<T> txn) {
   /**
    * Iterate the database in accordance with the provided {@link KeyRange}.
    *
-   * @param txn   transaction handle (not null; not committed)
+   * @param txn transaction handle (not null; not committed)
    * @param range range of acceptable keys (not null)
    * @return iterator (never null)
    */
@@ -395,21 +396,18 @@ public void put(final T key, final T val) {
   }
 
   /**
-   * @param txn   transaction handle (not null; not committed; must be R-W)
-   * @param key   key to store in the database (not null)
-   * @param val   value to store in the database (not null)
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
    * @param flags Special options for this operation
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
-   * key/value existed already.
+   *     key/value existed already.
    * @deprecated Use {@link Dbi#put(Txn, Object, Object, PutFlagSet)} instead, with a statically
-   * held {@link PutFlagSet}.
-   * <hr>
-   * <p>
-   * Store a key/value pair in the database.
-   * </p>
-   * <p>This function stores key/data pairs in the database. The default behavior is to enter the
-   * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
-   * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
+   *     held {@link PutFlagSet}. <hr>
+   *     <p>Store a key/value pair in the database.
+   *     <p>This function stores key/data pairs in the database. The default behavior is to enter
+   *     the new key/data pair, replacing any previously existing key if duplicates are disallowed,
+   *     or adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
    */
   @Deprecated
   public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags... flags) {
@@ -423,7 +421,7 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
-   * key/value existed already.
+   *     key/value existed already.
    * @see #put(Txn, Object, Object, PutFlagSet)
    */
   public boolean put(final Txn<T> txn, final T key, final T val) {
@@ -437,12 +435,12 @@ public boolean put(final Txn<T> txn, final T key, final T val) {
    * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
    * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
    *
-   * @param txn   transaction handle (not null; not committed; must be R-W)
-   * @param key   key to store in the database (not null)
-   * @param val   value to store in the database (not null)
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
    * @param flags Special options for this operation.
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
-   * key/value existed already.
+   *     key/value existed already.
    */
   public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
@@ -456,7 +454,9 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet
     final PutFlagSet flagSet = flags != null ? flags : PutFlagSet.empty();
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(val);
-    final int rc = LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flagSet.getMask());
+    final int rc =
+        LIB.mdb_put(
+            txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flagSet.getMask());
     if (rc == MDB_KEYEXIST) {
       if (flagSet.isSet(MDB_NOOVERWRITE)) {
         txn.kv().valOut(); // marked as in,out in LMDB C docs
@@ -482,10 +482,10 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet
    *
    * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    *
-   * @param txn  transaction handle (not null; not committed; must be R-W)
-   * @param key  key to store in the database (not null)
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
    * @param size size of the value to be stored in the database
-   * @param op   options for this operation
+   * @param op options for this operation
    * @return a buffer that can be used to modify the value
    */
   public T reserve(final Txn<T> txn, final T key, final int size, final PutFlags... op) {
@@ -545,15 +545,10 @@ public String toString() {
     } catch (Exception e) {
       name = "?";
     }
-    return "Dbi{" +
-        "name='" + name +
-        "', dbiFlagSet=" + dbiFlagSet +
-        '}';
+    return "Dbi{" + "name='" + name + "', dbiFlagSet=" + dbiFlagSet + '}';
   }
 
-  /**
-   * The specified DBI was changed unexpectedly.
-   */
+  /** The specified DBI was changed unexpectedly. */
   public static final class BadDbiException extends LmdbNativeException {
 
     static final int MDB_BAD_DBI = -30_780;
@@ -564,9 +559,7 @@ public static final class BadDbiException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Unsupported size of key/DB name/data, or wrong DUPFIXED size.
-   */
+  /** Unsupported size of key/DB name/data, or wrong DUPFIXED size. */
   public static final class BadValueSizeException extends LmdbNativeException {
 
     static final int MDB_BAD_VALSIZE = -30_781;
@@ -577,9 +570,7 @@ public static final class BadValueSizeException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Environment maxdbs reached.
-   */
+  /** Environment maxdbs reached. */
   public static final class DbFullException extends LmdbNativeException {
 
     static final int MDB_DBS_FULL = -30_791;
@@ -612,9 +603,7 @@ public static final class IncompatibleException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Key/data pair already exists.
-   */
+  /** Key/data pair already exists. */
   public static final class KeyExistsException extends LmdbNativeException {
 
     static final int MDB_KEYEXIST = -30_799;
@@ -625,9 +614,7 @@ public static final class KeyExistsException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Key/data pair not found (EOF).
-   */
+  /** Key/data pair not found (EOF). */
   public static final class KeyNotFoundException extends LmdbNativeException {
 
     static final int MDB_NOTFOUND = -30_798;
@@ -638,9 +625,7 @@ public static final class KeyNotFoundException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Database contents grew beyond environment mapsize.
-   */
+  /** Database contents grew beyond environment mapsize. */
   public static final class MapResizedException extends LmdbNativeException {
 
     static final int MDB_MAP_RESIZED = -30_785;
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 7824458b..d5d1af8c 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -28,37 +28,29 @@
  */
 public class DbiBuilder<T> {
 
-
   private final Env<T> env;
   private final BufferProxy<T> proxy;
   private final boolean readOnly;
   private byte[] name;
 
-  DbiBuilder(final Env<T> env,
-             final BufferProxy<T> proxy,
-             final boolean readOnly) {
+  DbiBuilder(final Env<T> env, final BufferProxy<T> proxy, final boolean readOnly) {
     this.env = Objects.requireNonNull(env);
     this.proxy = Objects.requireNonNull(proxy);
     this.readOnly = readOnly;
   }
 
   /**
-   * <p>
    * Create the {@link Dbi} with the passed name.
-   * </p>
-   * <p>
-   * The name will be converted into bytes using {@link StandardCharsets#UTF_8}.
-   * </p>
    *
-   * @param name The name of the database or null for the unnamed database
-   *             (see also {@link DbiBuilder#withoutDbName()})
+   * <p>The name will be converted into bytes using {@link StandardCharsets#UTF_8}.
+   *
+   * @param name The name of the database or null for the unnamed database (see also {@link
+   *     DbiBuilder#withoutDbName()})
    * @return The next builder stage.
    */
   public DbiBuilderStage2<T> setDbName(final String name) {
     // Null name is allowed so no null check
-    final byte[] nameBytes = name == null
-        ? null
-        : name.getBytes(Env.DEFAULT_NAME_CHARSET);
+    final byte[] nameBytes = name == null ? null : name.getBytes(Env.DEFAULT_NAME_CHARSET);
     return setDbName(nameBytes);
   }
 
@@ -75,16 +67,14 @@ public DbiBuilderStage2<T> setDbName(final byte[] name) {
   }
 
   /**
-   * <p>
    * Create the {@link Dbi} without a name.
-   * </p>
-   * <p>
-   * Equivalent to passing null to
-   * {@link DbiBuilder#setDbName(String)} or {@link DbiBuilder#setDbName(byte[])}.
-   * </p>
-   * <p>Note: The 'unnamed database' is used by LMDB to store the names of named databases, with
-   * the database name being the key. Use of the unnamed database is intended for simple applications
-   * with only one database.</p>
+   *
+   * <p>Equivalent to passing null to {@link DbiBuilder#setDbName(String)} or {@link
+   * DbiBuilder#setDbName(byte[])}.
+   *
+   * <p>Note: The 'unnamed database' is used by LMDB to store the names of named databases, with the
+   * database name being the key. Use of the unnamed database is intended for simple applications
+   * with only one database.
    *
    * @return The next builder stage.
    */
@@ -92,10 +82,8 @@ public DbiBuilderStage2<T> withoutDbName() {
     return setDbName((byte[]) null);
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * Intermediate builder stage for constructing a {@link Dbi}.
    *
@@ -113,29 +101,24 @@ private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
     }
 
     /**
-     * <p>
-     * This is the <strong>default</strong> choice when it comes to choosing a comparator.
-     * If you are not sure of the implications of the other methods then use this one as it
-     * is likely what you want and also probably the most performant.
-     * </p>
-     * <p>
-     * With this option, {@link CursorIterable} will make use of the LmdbJava's default
-     * Java-side comparators when comparing iteration keys to the start/stop keys.
-     * LMDB will use its own comparator for controlling insertion order in the database.
-     * The two comparators are functionally identical.
-     * </p>
-     * <p>
-     * This option may be slightly more performant than when using
-     * {@link DbiBuilderStage2#withNativeComparator()} which calls down to LMDB for ALL
-     * comparison operations.
-     * </p>
-     * <p>
-     * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
-     * you choose {@link DbiBuilderStage2#withNativeComparator()},
-     * {@link DbiBuilderStage2#withDefaultComparator()} or
-     * {@link DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will
-     * never be used.
-     * </p>
+     * This is the <strong>default</strong> choice when it comes to choosing a comparator. If you
+     * are not sure of the implications of the other methods then use this one as it is likely what
+     * you want and also probably the most performant.
+     *
+     * <p>With this option, {@link CursorIterable} will make use of the LmdbJava's default Java-side
+     * comparators when comparing iteration keys to the start/stop keys. LMDB will use its own
+     * comparator for controlling insertion order in the database. The two comparators are
+     * functionally identical.
+     *
+     * <p>This option may be slightly more performant than when using {@link
+     * DbiBuilderStage2#withNativeComparator()} which calls down to LMDB for ALL comparison
+     * operations.
+     *
+     * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
+     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
+     * DbiBuilderStage2#withDefaultComparator()} or {@link
+     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * be used.
      *
      * @return The next builder stage.
      */
@@ -145,24 +128,20 @@ public DbiBuilderStage3<T> withDefaultComparator() {
     }
 
     /**
-     * <p>
      * With this option, {@link CursorIterable} will call down to LMDB's {@code mdb_cmp} method when
      * comparing iteration keys to start/stop keys. This ensures LmdbJava is comparing start/stop
      * keys using the same comparator that is used for insertion order into the db.
-     * </p>
-     * <p>
-     * This option may be slightly less performant than when using
-     * {@link DbiBuilderStage2#withDefaultComparator()} as it needs to call down
-     * to LMDB to perform the comparisons, however it guarantees that {@link CursorIterable}
-     * key comparison matches LMDB key comparison.
-     * </p>
-     * <p>
-     * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
-     * you choose {@link DbiBuilderStage2#withNativeComparator()},
-     * {@link DbiBuilderStage2#withDefaultComparator()} or
-     * {@link DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will
-     * never be used.
-     * </p>
+     *
+     * <p>This option may be slightly less performant than when using {@link
+     * DbiBuilderStage2#withDefaultComparator()} as it needs to call down to LMDB to perform the
+     * comparisons, however it guarantees that {@link CursorIterable} key comparison matches LMDB
+     * key comparison.
+     *
+     * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
+     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
+     * DbiBuilderStage2#withDefaultComparator()} or {@link
+     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * be used.
      *
      * @return The next builder stage.
      */
@@ -171,30 +150,27 @@ public DbiBuilderStage3<T> withNativeComparator() {
       return new DbiBuilderStage3<>(this);
     }
 
-
     /**
      * Provide a java-side {@link Comparator} that LMDB will call back to for <strong>all</strong>
-     * comparison operations.
-     * Therefore, it will be called by LMDB to manage database insertion/iteration order.
-     * It will also be used for {@link CursorIterable} start/stop key comparisons.
-     * <p>
-     * It can be useful if you need to sort your database using some other method,
-     * e.g. signed keys or case-insensitive order.
-     * Note, if you need keys stored in reverse order, see {@link DbiFlags#MDB_REVERSEKEY}
-     * and {@link DbiFlags#MDB_REVERSEDUP}.
-     * </p>
-     * <p>
-     * As this requires LMDB to call back to java, this will be less performant than using LMDB's
-     * default comparators, but allows for total control over the order in which entries
-     * are stored in the database.
-     * </p>
+     * comparison operations. Therefore, it will be called by LMDB to manage database
+     * insertion/iteration order. It will also be used for {@link CursorIterable} start/stop key
+     * comparisons.
+     *
+     * <p>It can be useful if you need to sort your database using some other method, e.g. signed
+     * keys or case-insensitive order. Note, if you need keys stored in reverse order, see {@link
+     * DbiFlags#MDB_REVERSEKEY} and {@link DbiFlags#MDB_REVERSEDUP}.
      *
-     * @param comparatorFactory A factory to create a comparator. {@link ComparatorFactory#create(DbiFlagSet)}
-     *                          will be called once during the initialisation of the {@link Dbi}. It must
-     *                          not return null.
+     * <p>As this requires LMDB to call back to java, this will be less performant than using LMDB's
+     * default comparators, but allows for total control over the order in which entries are stored
+     * in the database.
+     *
+     * @param comparatorFactory A factory to create a comparator. {@link
+     *     ComparatorFactory#create(DbiFlagSet)} will be called once during the initialisation of
+     *     the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withCallbackComparator(final ComparatorFactory<T> comparatorFactory) {
+    public DbiBuilderStage3<T> withCallbackComparator(
+        final ComparatorFactory<T> comparatorFactory) {
       this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.CALLBACK;
       return new DbiBuilderStage3<>(this);
@@ -202,44 +178,39 @@ public DbiBuilderStage3<T> withCallbackComparator(final ComparatorFactory<T> com
 
     /**
      * <hr>
-     * <p>
-     * <strong>WARNING</strong>: Only use this if you fully understand the risks and implications.
-     * </p>
-     * <hr>
-     * <p>
-     * With this option, {@link CursorIterable} will make use of the passed comparator for
+     *
+     * <p><strong>WARNING</strong>: Only use this if you fully understand the risks and
+     * implications. <hr>
+     *
+     * <p>With this option, {@link CursorIterable} will make use of the passed comparator for
      * comparing iteration keys to start/stop keys. It has <strong>NO</strong> bearing on the
      * insert/iteration order of the database (which is controlled by LMDB's own comparators).
-     * </p>
-     * <p>
-     * It is <strong>vital</strong> that this comparator is functionally identical to the one
+     *
+     * <p>It is <strong>vital</strong> that this comparator is functionally identical to the one
      * used internally in LMDB for insertion/iteration order, else you will see unexpected behaviour
      * when using {@link CursorIterable}.
-     * </p>
-     * <p>
-     * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
-     * you choose {@link DbiBuilderStage2#withNativeComparator()},
-     * {@link DbiBuilderStage2#withDefaultComparator()} or
-     * {@link DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will
-     * never be used.
-     * </p>
      *
-     * @param comparatorFactory The comparator to use with {@link CursorIterable}.
-     *                          {@link ComparatorFactory#create(DbiFlagSet)} will be called once during the
-     *                          initialisation of the {@link Dbi}. It must not return null.
+     * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
+     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
+     * DbiBuilderStage2#withDefaultComparator()} or {@link
+     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * be used.
+     *
+     * @param comparatorFactory The comparator to use with {@link CursorIterable}. {@link
+     *     ComparatorFactory#create(DbiFlagSet)} will be called once during the initialisation of
+     *     the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withIteratorComparator(final ComparatorFactory<T> comparatorFactory) {
+    public DbiBuilderStage3<T> withIteratorComparator(
+        final ComparatorFactory<T> comparatorFactory) {
       this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.ITERATOR;
       return new DbiBuilderStage3<>(this);
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * Final stage builder for constructing a {@link Dbi}.
    *
@@ -248,7 +219,8 @@ public DbiBuilderStage3<T> withIteratorComparator(final ComparatorFactory<T> com
   public static class DbiBuilderStage3<T> {
 
     private final DbiBuilderStage2<T> dbiBuilderStage2;
-    private final AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder = DbiFlagSet.builder();
+    private final AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder =
+        DbiFlagSet.builder();
     private Txn<T> txn = null;
 
     private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
@@ -256,68 +228,49 @@ private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
     }
 
     /**
-     * <p>
      * Apply all the dbi flags supplied in dbiFlags.
-     * </p>
-     * <p>
-     * Clears all flags currently set by previous calls to
-     * {@link DbiBuilderStage3#setDbiFlags(Collection)},
-     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
+     *
+     * <p>Clears all flags currently set by previous calls to {@link
+     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
-     * </p>
      *
-     * @param dbiFlags to open the database with.
-     *                 A null {@link Collection} will just clear all set flags.
-     *                 Null items are ignored.
+     * @param dbiFlags to open the database with. A null {@link Collection} will just clear all set
+     *     flags. Null items are ignored.
      */
     public DbiBuilderStage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
-        dbiFlags.stream()
-            .filter(Objects::nonNull)
-            .forEach(dbiFlags::add);
+        dbiFlags.stream().filter(Objects::nonNull).forEach(dbiFlags::add);
       }
       return this;
     }
 
     /**
-     * <p>
      * Apply all the dbi flags supplied in dbiFlags.
-     * </p>
-     * <p>
-     * Clears all flags currently set by previous calls to
-     * {@link DbiBuilderStage3#setDbiFlags(Collection)},
-     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
+     *
+     * <p>Clears all flags currently set by previous calls to {@link
+     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
-     * </p>
      *
-     * @param dbiFlags to open the database with.
-     *                 A null array will just clear all set flags.
-     *                 Null items are ignored.
+     * @param dbiFlags to open the database with. A null array will just clear all set flags. Null
+     *     items are ignored.
      */
     public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
-        Arrays.stream(dbiFlags)
-            .filter(Objects::nonNull)
-            .forEach(this.flagSetBuilder::addFlag);
+        Arrays.stream(dbiFlags).filter(Objects::nonNull).forEach(this.flagSetBuilder::addFlag);
       }
       return this;
     }
 
     /**
-     * <p>
      * Apply all the dbi flags supplied in dbiFlags.
-     * </p>
-     * <p>
-     * Clears all flags currently set by previous calls to
-     * {@link DbiBuilderStage3#setDbiFlags(Collection)},
-     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
+     *
+     * <p>Clears all flags currently set by previous calls to {@link
+     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
-     * </p>
      *
-     * @param dbiFlagSet to open the database with.
-     *                   A null value will just clear all set flags.
+     * @param dbiFlagSet to open the database with. A null value will just clear all set flags.
      */
     public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
       flagSetBuilder.clear();
@@ -328,9 +281,8 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
     }
 
     /**
-     * Adds a dbiFlag to those flags already added to this builder by
-     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)},
-     * {@link DbiBuilderStage3#setDbiFlags(Collection)}
+     * Adds a dbiFlag to those flags already added to this builder by {@link
+     * DbiBuilderStage3#setDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#setDbiFlags(Collection)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlag to add to any existing flags. A null value is a no-op.
@@ -342,9 +294,8 @@ public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
     }
 
     /**
-     * Adds a dbiFlag to those flags already added to this builder by
-     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)},
-     * {@link DbiBuilderStage3#setDbiFlags(Collection)}
+     * Adds a dbiFlag to those flags already added to this builder by {@link
+     * DbiBuilderStage3#setDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#setDbiFlags(Collection)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlagSet to add to any existing flags. A null value is a no-op.
@@ -359,19 +310,17 @@ public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
 
     /**
      * Use the supplied transaction to open the {@link Dbi}.
-     * <p>
-     * The caller MUST commit the transaction after calling {@link DbiBuilderStage3#open()},
-     * in order to retain the <code>Dbi</code> in the <code>Env</code>.
-     * </p>
-     * <p>
-     * If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for the purpose
-     * of creating and opening the {@link Dbi}, then closed. Therefore, if you already have a transaction
-     * open, you should supply that to avoid one blocking the other.
-     * </p>
      *
-     * @param txn transaction to use (required; not closed). If the {@link Env} was opened
-     *            with the {@link EnvFlags#MDB_RDONLY_ENV} flag, the {@link Txn} can be read-only,
-     *            else it needs to be a read/write {@link Txn}.
+     * <p>The caller MUST commit the transaction after calling {@link DbiBuilderStage3#open()}, in
+     * order to retain the <code>Dbi</code> in the <code>Env</code>.
+     *
+     * <p>If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for
+     * the purpose of creating and opening the {@link Dbi}, then closed. Therefore, if you already
+     * have a transaction open, you should supply that to avoid one blocking the other.
+     *
+     * @param txn transaction to use (required; not closed). If the {@link Env} was opened with the
+     *     {@link EnvFlags#MDB_RDONLY_ENV} flag, the {@link Txn} can be read-only, else it needs to
+     *     be a read/write {@link Txn}.
      * @return this builder instance.
      */
     public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
@@ -381,10 +330,9 @@ public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
 
     /**
      * Construct and open the {@link Dbi}.
-     * <p>
-     * If a {@link Txn} was supplied to the builder, it is the callers responsibility to
-     * commit and close the txn upon return from this method, else the created DB won't be retained.
-     * </p>
+     *
+     * <p>If a {@link Txn} was supplied to the builder, it is the callers responsibility to commit
+     * and close the txn upon return from this method, else the created DB won't be retained.
      *
      * @return A newly constructed and opened {@link Dbi}.
      */
@@ -403,14 +351,13 @@ public Dbi<T> open() {
     }
 
     private Txn<T> getTxn(final DbiBuilder<T> dbiBuilder) {
-      return dbiBuilder.readOnly
-          ? dbiBuilder.env.txnRead()
-          : dbiBuilder.env.txnWrite();
+      return dbiBuilder.readOnly ? dbiBuilder.env.txnRead() : dbiBuilder.env.txnWrite();
     }
 
-    private Comparator<T> getComparator(final DbiBuilder<T> dbiBuilder,
-                                        final ComparatorType comparatorType,
-                                        final DbiFlagSet dbiFlagSet) {
+    private Comparator<T> getComparator(
+        final DbiBuilder<T> dbiBuilder,
+        final ComparatorType comparatorType,
+        final DbiFlagSet dbiFlagSet) {
       Comparator<T> comparator = null;
       switch (comparatorType) {
         case DEFAULT:
@@ -431,8 +378,7 @@ private Comparator<T> getComparator(final DbiBuilder<T> dbiBuilder,
       return comparator;
     }
 
-    private Dbi<T> openDbi(final Txn<T> txn,
-                           final DbiBuilder<T> dbiBuilder) {
+    private Dbi<T> openDbi(final Txn<T> txn, final DbiBuilder<T> dbiBuilder) {
       final DbiFlagSet dbiFlagSet = flagSetBuilder.build();
       final ComparatorType comparatorType = dbiBuilderStage2.comparatorType;
       final Comparator<T> comparator = getComparator(dbiBuilder, comparatorType, dbiFlagSet);
@@ -448,23 +394,17 @@ private Dbi<T> openDbi(final Txn<T> txn,
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   private enum ComparatorType {
     /**
-     * Default Java comparator for {@link CursorIterable} KeyRange testing,
-     * LMDB comparator for insertion/iteration order.
+     * Default Java comparator for {@link CursorIterable} KeyRange testing, LMDB comparator for
+     * insertion/iteration order.
      */
     DEFAULT,
-    /**
-     * Use LMDB native comparator for everything.
-     */
+    /** Use LMDB native comparator for everything. */
     NATIVE,
-    /**
-     * Use the supplied custom Java-side comparator for everything.
-     */
+    /** Use the supplied custom Java-side comparator for everything. */
     CALLBACK,
     /**
      * Use the supplied custom Java-side comparator for {@link CursorIterable} KeyRange testing,
@@ -474,14 +414,11 @@ private enum ComparatorType {
     ;
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   @FunctionalInterface
   public interface ComparatorFactory<T> {
 
     Comparator<T> create(final DbiFlagSet dbiFlagSet);
-
   }
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 8ffd2499..6f2d3c81 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -25,9 +25,7 @@ public interface DbiFlagSet extends FlagSet<DbiFlags> {
   DbiFlagSet EMPTY = DbiFlagSetImpl.EMPTY;
 
   /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
-  DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(
-      DbiFlags.MDB_INTEGERKEY,
-      DbiFlags.MDB_INTEGERDUP);
+  DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_INTEGERDUP);
 
   static DbiFlagSet empty() {
     return DbiFlagSetImpl.EMPTY;
@@ -39,29 +37,20 @@ static DbiFlagSet of(final DbiFlags dbiFlag) {
   }
 
   static DbiFlagSet of(final DbiFlags... DbiFlags) {
-    return builder()
-        .setFlags(DbiFlags)
-        .build();
+    return builder().setFlags(DbiFlags).build();
   }
 
   static DbiFlagSet of(final Collection<DbiFlags> DbiFlags) {
-    return builder()
-        .setFlags(DbiFlags)
-        .build();
+    return builder().setFlags(DbiFlags).build();
   }
 
   static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
-        DbiFlags.class,
-        DbiFlagSetImpl::new,
-        dbiFlag -> dbiFlag,
-        () -> DbiFlagSetImpl.EMPTY);
+        DbiFlags.class, DbiFlagSetImpl::new, dbiFlag -> dbiFlag, () -> DbiFlagSetImpl.EMPTY);
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
 
     static final DbiFlagSet EMPTY = new EmptyDbiFlagSet();
@@ -71,10 +60,8 @@ private DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags> implements DbiFlagSet {
-  }
+  class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
+      implements DbiFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 7c4b6794..f8ccbe20 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -32,30 +32,26 @@ public enum DbiFlags implements MaskedFlag, DbiFlagSet {
    * Use sorted duplicates.
    *
    * <p>Duplicate keys may be used in the database. Or, from another perspective, keys may have
-   * multiple data items, stored in sorted order. By default, keys must be unique and may have only a
-   * single data item.
-   * <p>
+   * multiple data items, stored in sorted order. By default, keys must be unique and may have only
+   * a single data item.
    *
-   * </p>
+   * <p>
    */
   MDB_DUPSORT(0x04),
   /**
-   * Numeric keys in native byte order: either unsigned int or size_t.
-   * <strong>The keys must all be of the same size.</strong>
-   * <p>
-   * This is an optimisation that is available when your keys are 4 or 8 byte unsigned numeric values.
-   * There are performance benefits for both ordered and un-ordered puts as compared to not using
-   * this flag.
-   * </p>
-   * <p>
-   * When writing the key to the buffer you must write it in native order and subsequently read any
-   * keys retrieved from LMDB (via cursor or get method) also using native order.
-   * </p>
-   * <p>
-   * For more information, see
-   * <a href="https://github.com/lmdbjava/lmdbjava/wiki/Keys#numeric-keys">Numeric Keys</a>
-   * in the LmdbJava wiki.
-   * </p>
+   * Numeric keys in native byte order: either unsigned int or size_t. <strong>The keys must all be
+   * of the same size.</strong>
+   *
+   * <p>This is an optimisation that is available when your keys are 4 or 8 byte unsigned numeric
+   * values. There are performance benefits for both ordered and un-ordered puts as compared to not
+   * using this flag.
+   *
+   * <p>When writing the key to the buffer you must write it in native order and subsequently read
+   * any keys retrieved from LMDB (via cursor or get method) also using native order.
+   *
+   * <p>For more information, see <a
+   * href="https://github.com/lmdbjava/lmdbjava/wiki/Keys#numeric-keys">Numeric Keys</a> in the
+   * LmdbJava wiki.
    */
   MDB_INTEGERKEY(0x08),
   /**
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 3ddda467..af918943 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -91,11 +91,11 @@ public static int compareLexicographically(final DirectBuffer o1, final DirectBu
   }
 
   /**
-   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
-   * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
-   * <p>
-   * Both buffer must have 4 or 8 bytes remaining
-   * </p>
+   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs, i.e. when using
+   * MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+   *
+   * <p>Both buffer must have 4 or 8 bytes remaining
+   *
    * @param o1 left operand (required)
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
@@ -107,8 +107,12 @@ public static int compareAsIntegerKeys(final DirectBuffer o1, final DirectBuffer
     final int len1 = o1.capacity();
     final int len2 = o2.capacity();
     if (len1 != len2) {
-      throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
-          + ". Lengths must be identical and either 4 or 8 bytes.");
+      throw new RuntimeException(
+          "Length mismatch, len1: "
+              + len1
+              + ", len2: "
+              + len2
+              + ". Lengths must be identical and either 4 or 8 bytes.");
     }
     if (len1 == 8) {
       final long lw = o1.getLong(0, NATIVE_ORDER);
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 9b2a4360..54115b33 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -50,10 +50,9 @@
  */
 public final class Env<T> implements AutoCloseable {
 
-  /**
-   * Java system property name that can be set to disable optional checks.
-   */
+  /** Java system property name that can be set to disable optional checks. */
   public static final String DISABLE_CHECKS_PROP = "lmdbjava.disable.checks";
+
   public static final Charset DEFAULT_NAME_CHARSET = StandardCharsets.UTF_8;
 
   /**
@@ -95,7 +94,7 @@ public static Builder<ByteBuffer> create() {
   /**
    * Create an {@link Env} using the passed {@link BufferProxy}.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param proxy the proxy to use (required)
    * @return the environment (never null)
    */
@@ -104,20 +103,17 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
   }
 
   /**
-   * @param path  file system destination
-   * @param size  size in megabytes
+   * @param path file system destination
+   * @param size size in megabytes
    * @param flags the flags for this new environment
    * @return env the environment (never null)
    * @deprecated Instead use {@link Env#create()} or {@link Env#create(BufferProxy)}
-   * <p>
-   * Opens an environment with a single default database in 0664 mode using the {@link
-   * ByteBufferProxy#PROXY_OPTIMAL}.
+   *     <p>Opens an environment with a single default database in 0664 mode using the {@link
+   *     ByteBufferProxy#PROXY_OPTIMAL}.
    */
   @Deprecated
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
-    return new Builder<>(PROXY_OPTIMAL)
-        .setMapSize(size, ByteUnit.MEBIBYTES)
-        .open(path, flags);
+    return new Builder<>(PROXY_OPTIMAL).setMapSize(size, ByteUnit.MEBIBYTES).open(path, flags);
   }
 
   /**
@@ -170,7 +166,7 @@ public void copy(final File path) {
    * transactions, because it employs a read-only transaction. See long-lived transactions under
    * "Caveats" in the LMDB native documentation.
    *
-   * @param path  writable destination path as described above
+   * @param path writable destination path as described above
    * @param flags special options for this copy
    */
   public void copy(final File path, final CopyFlagSet flags) {
@@ -195,7 +191,7 @@ public List<byte[]> getDbiNames() {
     // The unnamed DB is special so the names of the named DBs are held as keys in it.
     final Dbi<T> unnamedDb = openDbi((byte[]) null, DbiFlagSet.EMPTY);
     try (final Txn<T> txn = txnRead();
-         final Cursor<T> cursor = unnamedDb.openCursor(txn)) {
+        final Cursor<T> cursor = unnamedDb.openCursor(txn)) {
       if (!cursor.first()) {
         return Collections.emptyList();
       }
@@ -285,8 +281,8 @@ public boolean isReadOnly() {
   }
 
   /**
-   * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set)
-   * a {@link Dbi} using a builder.
+   * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set) a {@link Dbi} using a
+   * builder.
    *
    * @return A new builder instance for creating/opening a {@link Dbi}.
    */
@@ -295,12 +291,12 @@ public DbiBuilder<T> createDbi() {
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default
-   * {@link Comparator} that is not invoked from native code.
-   * <p>
-   * For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
-   * </p>
-   * @param name       name of the database (or null if no name is required)
+   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
+   * Comparator} that is not invoked from native code.
+   *
+   * <p>For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
+   *
+   * @param name name of the database (or null if no name is required)
    * @param dbiFlagSet Flags to open the database with
    * @return a database that is ready to use
    */
@@ -314,17 +310,16 @@ public Dbi<T> openDbi(final String name, final DbiFlagSet dbiFlagSet) {
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a default
-   * {@link Comparator} that is not invoked from native code.
-   * <p>
-   * For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
-   * </p>
-   * @param name       name of the database (or null if no name is required)
+   * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
+   * invoked from native code.
+   *
+   * <p>For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
+   *
+   * @param name name of the database (or null if no name is required)
    * @param dbiFlagSet Flags to open the database with
    * @return a database that is ready to use
    */
-  public Dbi<T> openDbi(final byte[] name,
-                        final DbiFlagSet dbiFlagSet) {
+  public Dbi<T> openDbi(final byte[] name, final DbiFlagSet dbiFlagSet) {
     try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
       final Dbi<T> dbi = new Dbi<>(this, txn, name, proxy, dbiFlagSet);
       txn.commit(); // even RO Txns require a commit to retain Dbi in Env
@@ -333,12 +328,12 @@ public Dbi<T> openDbi(final byte[] name,
   }
 
   /**
-   * @param name  name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
    * @deprecated Instead use {@link Env#createDbi()} or {@link Env#openDbi(String, DbiFlagSet)}
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
-   * Comparator} that is not invoked from native code.
+   *     Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
+   *     Comparator} that is not invoked from native code.
    */
   @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
@@ -347,84 +342,73 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   }
 
   /**
-   * @param name       name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator for cursor start/stop key comparisons. If null, LMDB's
-   *                   comparator will be used.
-   * @param flags      to open the database with
+   *     comparator will be used.
+   * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()}
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
-   *
-   * <p>It is very important that the passed comparator behaves in the same way as the comparator
-   * LMDB uses for its insertion order (for the type of data that will be stored in the database),
-   * or you fully understand the implications of them behaving differently. LMDB's comparator is
-   * unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is used.
+   * @deprecated Instead use {@link Env#createDbi()} Convenience method that opens a {@link Dbi}
+   *     with a UTF-8 database name and associated {@link Comparator} for use by {@link
+   *     CursorIterable} when comparing start/stop keys.
+   *     <p>It is very important that the passed comparator behaves in the same way as the
+   *     comparator LMDB uses for its insertion order (for the type of data that will be stored in
+   *     the database), or you fully understand the implications of them behaving differently.
+   *     LMDB's comparator is unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is
+   *     used.
    */
   @Deprecated()
-  public Dbi<T> openDbi(final String name,
-                        final Comparator<T> comparator,
-                        final DbiFlags... flags) {
+  public Dbi<T> openDbi(
+      final String name, final Comparator<T> comparator, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
     return openDbi(nameBytes, comparator, false, flags);
   }
 
   /**
-   * @param name       name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator for cursor start/stop key comparisons and optionally for
-   *                   LMDB to call back to. If null, LMDB's comparator will be used.
-   * @param nativeCb   whether LMDB native code calls back to the Java comparator
-   * @param flags      to open the database with
+   *     LMDB to call back to. If null, LMDB's comparator will be used.
+   * @param nativeCb whether LMDB native code calls back to the Java comparator
+   * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()}
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop
-   * keys as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to
-   * determine insertion/iteration order. Calling back to a java comparator may significantly impact
-   * performance.
+   * @deprecated Instead use {@link Env#createDbi()} Convenience method that opens a {@link Dbi}
+   *     with a UTF-8 database name and associated {@link Comparator}. The comparator will be used
+   *     by {@link CursorIterable} when comparing start/stop keys as a minimum. If nativeCb is
+   *     {@code true}, this comparator will also be called by LMDB to determine insertion/iteration
+   *     order. Calling back to a java comparator may significantly impact performance.
    */
   @Deprecated()
-  public Dbi<T> openDbi(final String name,
-                        final Comparator<T> comparator,
-                        final boolean nativeCb,
-                        final DbiFlags... flags) {
+  public Dbi<T> openDbi(
+      final String name,
+      final Comparator<T> comparator,
+      final boolean nativeCb,
+      final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
     return openDbi(nameBytes, comparator, nativeCb, flags);
   }
 
   /**
-   * @param name  name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()}
-   * <hr>
-   * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
-   * invoked from native code.
+   * @deprecated Instead use {@link Env#createDbi()} <hr> Convenience method that opens a {@link
+   *     Dbi} with a default {@link Comparator} that is not invoked from native code.
    */
   @Deprecated()
-  public Dbi<T> openDbi(final byte[] name,
-                        final DbiFlags... flags) {
-    return createDbi()
-        .setDbName(name)
-        .withDefaultComparator()
-        .setDbiFlags(flags)
-        .open();
+  public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
+    return createDbi().setDbName(name).withDefaultComparator().setDbiFlags(flags).open();
   }
 
   /**
-   * @param name       name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param flags      to open the database with
+   * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()}
-   * <hr>
-   * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that is not
-   * invoked from native code.
+   * @deprecated Instead use {@link Env#createDbi()} <hr> Convenience method that opens a {@link
+   *     Dbi} with an associated {@link Comparator} that is not invoked from native code.
    */
   @Deprecated()
-  public Dbi<T> openDbi(final byte[] name,
-                        final Comparator<T> comparator,
-                        final DbiFlags... flags) {
+  public Dbi<T> openDbi(
+      final byte[] name, final Comparator<T> comparator, final DbiFlags... flags) {
     requireNonNull(comparator);
     return createDbi()
         .setDbName(name)
@@ -434,18 +418,16 @@ public Dbi<T> openDbi(final byte[] name,
   }
 
   /**
-   * @param name       name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb   whether native code calls back to the Java comparator
-   * @param flags      to open the database with
+   * @param nativeCb whether native code calls back to the Java comparator
+   * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()}
-   * <hr>
-   * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that may be
-   * invoked from native code if specified.
-   *
-   * <p>This method will automatically commit the private transaction before returning. This ensures
-   * the <code>Dbi</code> is available in the <code>Env</code>.
+   * @deprecated Instead use {@link Env#createDbi()} <hr> Convenience method that opens a {@link
+   *     Dbi} with an associated {@link Comparator} that may be invoked from native code if
+   *     specified.
+   *     <p>This method will automatically commit the private transaction before returning. This
+   *     ensures the <code>Dbi</code> is available in the <code>Env</code>.
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -461,31 +443,27 @@ public Dbi<T> openDbi(
   }
 
   /**
-   * @param txn        transaction to use (required; not closed)
-   * @param name       name of the database (or null if no name is required)
+   * @param txn transaction to use (required; not closed)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb   whether native LMDB code should call back to the Java comparator
-   * @param flags      to open the database with
+   * @param nativeCb whether native LMDB code should call back to the Java comparator
+   * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()}
-   * Open the {@link Dbi} using the passed {@link Txn}.
-   *
-   * <p>The caller must commit the transaction after this method returns in order to retain the
-   * <code>Dbi</code> in the <code>Env</code>.
-   *
-   * <p>A {@link Comparator} may be provided when calling this method. Such comparator is primarily
-   * used by {@link CursorIterable} instances. A secondary (but uncommon) use of the comparator is
-   * to act as a callback from the native library if <code>nativeCb</code> is <code>true</code>.
-   * This is usually avoided due to the overhead of native code calling back into Java. It is
-   * instead highly recommended to set the correct {@link DbiFlags} to allow the native library to
-   * correctly order the intended keys.
-   *
-   * <p>A default comparator will be provided if <code>null</code> is passed as the comparator. If a
-   * custom comparator is provided, it must strictly match the lexicographical order of keys in the
-   * native LMDB database.
-   *
-   * <p>This method (and its overloaded convenience variants) must not be called from concurrent
-   * threads.
+   * @deprecated Instead use {@link Env#createDbi()} Open the {@link Dbi} using the passed {@link
+   *     Txn}.
+   *     <p>The caller must commit the transaction after this method returns in order to retain the
+   *     <code>Dbi</code> in the <code>Env</code>.
+   *     <p>A {@link Comparator} may be provided when calling this method. Such comparator is
+   *     primarily used by {@link CursorIterable} instances. A secondary (but uncommon) use of the
+   *     comparator is to act as a callback from the native library if <code>nativeCb</code> is
+   *     <code>true</code>. This is usually avoided due to the overhead of native code calling back
+   *     into Java. It is instead highly recommended to set the correct {@link DbiFlags} to allow
+   *     the native library to correctly order the intended keys.
+   *     <p>A default comparator will be provided if <code>null</code> is passed as the comparator.
+   *     If a custom comparator is provided, it must strictly match the lexicographical order of
+   *     keys in the native LMDB database.
+   *     <p>This method (and its overloaded convenience variants) must not be called from concurrent
+   *     threads.
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -521,7 +499,7 @@ public Stat stat() {
    * Flushes the data buffers to disk.
    *
    * @param force force a synchronous flush (otherwise if the environment has the MDB_NOSYNC flag
-   *              set the flushes will be omitted, and with MDB_MAPASYNC they will be asynchronous)
+   *     set the flushes will be omitted, and with MDB_MAPASYNC they will be asynchronous)
    */
   public void sync(final boolean force) {
     if (closed) {
@@ -533,11 +511,10 @@ public void sync(final boolean force) {
 
   /**
    * @param parent parent transaction (may be null if no parent)
-   * @param flags  applicable flags (eg for a reusable, read-only transaction)
+   * @param flags applicable flags (eg for a reusable, read-only transaction)
    * @return a transaction (never null)
    * @deprecated Instead use {@link Env#txn(Txn, TxnFlagSet)}
-   * <p>
-   * Obtain a transaction with the requested parent and flags.
+   *     <p>Obtain a transaction with the requested parent and flags.
    */
   @Deprecated
   public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
@@ -560,9 +537,9 @@ public Txn<T> txn(final Txn<T> parent) {
    * Obtain a transaction with the requested parent and flags.
    *
    * @param parent parent transaction (may be null if no parent)
-   * @param flags  applicable flags (e.g. for a reusable, read-only transaction).
-   *               If the set of flags is used frequently it is recommended to hold
-   *               a static instance of the {@link TxnFlagSet} for re-use.
+   * @param flags applicable flags (e.g. for a reusable, read-only transaction). If the set of flags
+   *     is used frequently it is recommended to hold a static instance of the {@link TxnFlagSet}
+   *     for re-use.
    * @return a transaction (never null)
    */
   public Txn<T> txn(final Txn<T> parent, final TxnFlagSet flags) {
@@ -634,40 +611,30 @@ public int readerCheck() {
     return resultPtr.intValue();
   }
 
-  /**
-   * Object has already been closed and the operation is therefore prohibited.
-   */
+  /** Object has already been closed and the operation is therefore prohibited. */
   public static final class AlreadyClosedException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public AlreadyClosedException() {
       super("Environment has already been closed");
     }
   }
 
-  /**
-   * Object has already been opened and the operation is therefore prohibited.
-   */
+  /** Object has already been opened and the operation is therefore prohibited. */
   public static final class AlreadyOpenException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public AlreadyOpenException() {
       super("Environment has already been opened");
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * Builder for configuring and opening Env.
    *
@@ -685,7 +652,8 @@ public static final class Builder<T> {
     private boolean opened;
     private final BufferProxy<T> proxy;
     private int mode = POSIX_MODE_DEFAULT;
-    private final AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> flagSetBuilder = EnvFlagSet.builder();
+    private final AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> flagSetBuilder =
+        EnvFlagSet.builder();
 
     Builder(final BufferProxy<T> proxy) {
       requireNonNull(proxy);
@@ -695,12 +663,12 @@ public static final class Builder<T> {
     /**
      * Opens the environment.
      *
-     * @param path  file system destination
-     * @param mode  Unix permissions to set on created files and semaphores
+     * @param path file system destination
+     * @param mode Unix permissions to set on created files and semaphores
      * @param flags the flags for this new environment
      * @return an environment ready for use
      * @deprecated Instead use {@link Builder#open(Path)}, {@link Builder#setFilePermissions(int)}
-     * and {@link Builder#setEnvFlags(EnvFlags...)}.
+     *     and {@link Builder#setEnvFlags(EnvFlags...)}.
      */
     @Deprecated
     public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
@@ -724,10 +692,11 @@ public Env<T> open(final File path) {
     /**
      * Opens the environment with 0664 mode.
      *
-     * @param path  file system destination
+     * @param path file system destination
      * @param flags the flags for this new environment
      * @return an environment ready for use
-     * @deprecated Instead use {@link Builder#open(Path)} and {@link Builder#setEnvFlags(EnvFlags...)}.
+     * @deprecated Instead use {@link Builder#open(Path)} and {@link
+     *     Builder#setEnvFlags(EnvFlags...)}.
      */
     @Deprecated
     public Env<T> open(final File path, final EnvFlags... flags) {
@@ -825,8 +794,8 @@ public Builder<T> setMaxReaders(final int readers) {
     }
 
     /**
-     * Sets the Unix file permissions to use on created files and semaphores, e.g. {@code 0664}.
-     * If this method is not called, the default of {@code 0664} will be used.
+     * Sets the Unix file permissions to use on created files and semaphores, e.g. {@code 0664}. If
+     * this method is not called, the default of {@code 0664} will be used.
      *
      * @param mode Unix permissions to set on created files and semaphores
      * @return the builder
@@ -842,17 +811,14 @@ public Builder<T> setFilePermissions(final int mode) {
     /**
      * Sets all the flags used to open this {@link Env}.
      *
-     * @param envFlags The flags to use.
-     *                 Clears any existing flags.
-     *                 A null value results in no flags being set.
+     * @param envFlags The flags to use. Clears any existing flags. A null value results in no flags
+     *     being set.
      * @return this builder instance.
      */
     public Builder<T> setEnvFlags(final Collection<EnvFlags> envFlags) {
       flagSetBuilder.clear();
       if (envFlags != null) {
-        envFlags.stream()
-            .filter(Objects::nonNull)
-            .forEach(envFlags::add);
+        envFlags.stream().filter(Objects::nonNull).forEach(envFlags::add);
       }
       return this;
     }
@@ -860,17 +826,14 @@ public Builder<T> setEnvFlags(final Collection<EnvFlags> envFlags) {
     /**
      * Sets all the flags used to open this {@link Env}.
      *
-     * @param envFlags The flags to use.
-     *                 Clears any existing flags.
-     *                 A null value results in no flags being set.
+     * @param envFlags The flags to use. Clears any existing flags. A null value results in no flags
+     *     being set.
      * @return this builder instance.
      */
     public Builder<T> setEnvFlags(final EnvFlags... envFlags) {
       flagSetBuilder.clear();
       if (envFlags != null) {
-        Arrays.stream(envFlags)
-            .filter(Objects::nonNull)
-            .forEach(this.flagSetBuilder::addFlag);
+        Arrays.stream(envFlags).filter(Objects::nonNull).forEach(this.flagSetBuilder::addFlag);
       }
       return this;
     }
@@ -878,9 +841,8 @@ public Builder<T> setEnvFlags(final EnvFlags... envFlags) {
     /**
      * Sets all the flags used to open this {@link Env}.
      *
-     * @param envFlagSet The flags to use.
-     *                   Clears any existing flags.
-     *                   A null value results in no flags being set.
+     * @param envFlagSet The flags to use. Clears any existing flags. A null value results in no
+     *     flags being set.
      * @return this builder instance.
      */
     public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
@@ -894,8 +856,7 @@ public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
     /**
      * Adds a single {@link EnvFlags} to any existing flags.
      *
-     * @param dbiFlag The flag to add to any existing flags.
-     *                A null value is a no-op.
+     * @param dbiFlag The flag to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
      */
     public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
@@ -906,8 +867,7 @@ public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
     /**
      * Adds a set of {@link EnvFlags} to any existing flags.
      *
-     * @param dbiFlagSet The set of flags to add to any existing flags.
-     *                   A null value is a no-op.
+     * @param dbiFlagSet The set of flags to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
      */
     public Builder<T> addEnvFlags(final EnvFlagSet dbiFlagSet) {
@@ -918,9 +878,7 @@ public Builder<T> addEnvFlags(final EnvFlagSet dbiFlagSet) {
     }
   }
 
-  /**
-   * File is not a valid LMDB file.
-   */
+  /** File is not a valid LMDB file. */
   public static final class FileInvalidException extends LmdbNativeException {
 
     static final int MDB_INVALID = -30_793;
@@ -931,9 +889,7 @@ public static final class FileInvalidException extends LmdbNativeException {
     }
   }
 
-  /**
-   * The specified copy destination is invalid.
-   */
+  /** The specified copy destination is invalid. */
   public static final class InvalidCopyDestination extends LmdbException {
 
     private static final long serialVersionUID = 1L;
@@ -948,9 +904,7 @@ public InvalidCopyDestination(final String message) {
     }
   }
 
-  /**
-   * Environment mapsize reached.
-   */
+  /** Environment mapsize reached. */
   public static final class MapFullException extends LmdbNativeException {
 
     static final int MDB_MAP_FULL = -30_792;
@@ -961,9 +915,7 @@ public static final class MapFullException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Environment maxreaders reached.
-   */
+  /** Environment maxreaders reached. */
   public static final class ReadersFullException extends LmdbNativeException {
 
     static final int MDB_READERS_FULL = -30_790;
@@ -974,9 +926,7 @@ public static final class ReadersFullException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Environment version mismatch.
-   */
+  /** Environment version mismatch. */
   public static final class VersionMismatchException extends LmdbNativeException {
 
     static final int MDB_VERSION_MISMATCH = -30_794;
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index c104edd9..771f5e2c 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -33,29 +33,20 @@ static EnvFlagSet of(final EnvFlags envFlag) {
   }
 
   static EnvFlagSet of(final EnvFlags... EnvFlags) {
-    return builder()
-        .setFlags(EnvFlags)
-        .build();
+    return builder().setFlags(EnvFlags).build();
   }
 
   static EnvFlagSet of(final Collection<EnvFlags> EnvFlags) {
-    return builder()
-        .setFlags(EnvFlags)
-        .build();
+    return builder().setFlags(EnvFlags).build();
   }
 
   static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
-        EnvFlags.class,
-        EnvFlagSetImpl::new,
-        envFlag -> envFlag,
-        () -> EnvFlagSetImpl.EMPTY);
+        EnvFlags.class, EnvFlagSetImpl::new, envFlag -> envFlag, () -> EnvFlagSetImpl.EMPTY);
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
 
     static final EnvFlagSet EMPTY = new EmptyEnvFlagSet();
@@ -65,10 +56,8 @@ private EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags> implements EnvFlagSet {
-  }
+  class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
+      implements EnvFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index 94cb3dca..e5e1c6a4 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -22,8 +22,9 @@
 import java.util.stream.Collectors;
 
 /**
- * A set of flags, each with a bit mask value.
- * Flags can be combined in a set such that the set has a combined bit mask value.
+ * A set of flags, each with a bit mask value. Flags can be combined in a set such that the set has
+ * a combined bit mask value.
+ *
  * @param <T>
  */
 public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
@@ -34,8 +35,8 @@ public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
   int getMask();
 
   /**
-   * @return The result of combining the mask of this {@link FlagSet}
-   * with the mask of the other {@link FlagSet}.
+   * @return The result of combining the mask of this {@link FlagSet} with the mask of the other
+   *     {@link FlagSet}.
    */
   default int getMaskWith(final FlagSet<T> other) {
     if (other != null) {
@@ -76,7 +77,6 @@ default boolean areAnySet(final FlagSet<T> flags) {
     return false;
   }
 
-
   /**
    * @return True if this {@link FlagSet} is empty.
    */
@@ -90,24 +90,18 @@ default Iterator<T> iterator() {
     return getFlags().iterator();
   }
 
-  /**
-   * Convert this {@link FlagSet} to a string for use in toString methods.
-   */
+  /** Convert this {@link FlagSet} to a string for use in toString methods. */
   static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
     Objects.requireNonNull(flagSet);
-    final String flagsStr = flagSet.getFlags()
-        .stream()
-        .sorted(Comparator.comparing(MaskedFlag::getMask))
-        .map(MaskedFlag::name)
-        .collect(Collectors.joining(", "));
-    return "FlagSet{" +
-        "flags=[" + flagsStr +
-        "], mask=" + flagSet.getMask() +
-        '}';
+    final String flagsStr =
+        flagSet.getFlags().stream()
+            .sorted(Comparator.comparing(MaskedFlag::getMask))
+            .map(MaskedFlag::name)
+            .collect(Collectors.joining(", "));
+    return "FlagSet{" + "flags=[" + flagsStr + "], mask=" + flagSet.getMask() + '}';
   }
 
-  static boolean equals(final FlagSet<?> flagSet,
-                        final Object other) {
+  static boolean equals(final FlagSet<?> flagSet, final Object other) {
     if (other instanceof FlagSet) {
       final FlagSet<?> flagSet2 = (FlagSet<?>) other;
       if (flagSet == flagSet2) {
@@ -122,5 +116,4 @@ static boolean equals(final FlagSet<?> flagSet,
       return false;
     }
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 1c531ac8..400f2f30 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -59,9 +59,7 @@ static <M extends MaskedFlag> int mask(final M... flags) {
     }
   }
 
-  /**
-   * Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s.
-   */
+  /** Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s. */
   static <M extends MaskedFlag> int mask(final int mask1, final int mask2) {
     return mask1 | mask2;
   }
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index aaba7cb7..ee2a9826 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -21,54 +21,43 @@
 
 public interface PutFlagSet extends FlagSet<PutFlags> {
 
-    PutFlagSet EMPTY = PutFlagSetImpl.EMPTY;
+  PutFlagSet EMPTY = PutFlagSetImpl.EMPTY;
 
-    static PutFlagSet empty() {
-        return PutFlagSetImpl.EMPTY;
-    }
-
-    static PutFlagSet of(final PutFlags putFlag) {
-        Objects.requireNonNull(putFlag);
-        return putFlag;
-    }
-
-    static PutFlagSet of(final PutFlags... putFlags) {
-        return builder()
-                .setFlags(putFlags)
-                .build();
-    }
+  static PutFlagSet empty() {
+    return PutFlagSetImpl.EMPTY;
+  }
 
-    static PutFlagSet of(final Collection<PutFlags> putFlags) {
-        return builder()
-            .setFlags(putFlags)
-            .build();
-    }
+  static PutFlagSet of(final PutFlags putFlag) {
+    Objects.requireNonNull(putFlag);
+    return putFlag;
+  }
 
-    static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
-        return new AbstractFlagSet.Builder<>(
-            PutFlags.class,
-            PutFlagSetImpl::new,
-            putFlag -> putFlag,
-            EmptyPutFlagSet::new);
-    }
+  static PutFlagSet of(final PutFlags... putFlags) {
+    return builder().setFlags(putFlags).build();
+  }
 
+  static PutFlagSet of(final Collection<PutFlags> putFlags) {
+    return builder().setFlags(putFlags).build();
+  }
 
-    // --------------------------------------------------------------------------------
+  static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, EmptyPutFlagSet::new);
+  }
 
+  // --------------------------------------------------------------------------------
 
-    class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
+  class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
 
-        public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
+    public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
 
-        private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
-            super(flags);
-        }
+    private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
+      super(flags);
     }
+  }
 
+  // --------------------------------------------------------------------------------
 
-    // --------------------------------------------------------------------------------
-
-
-    class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags> implements PutFlagSet {
-    }
+  class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
+      implements PutFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 99439bf7..432b47a8 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -46,9 +46,7 @@ public final class Txn<T> implements AutoCloseable {
   private State state;
 
   Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlagSet flags) {
-    this.flags = flags != null
-        ? flags
-        : TxnFlagSet.EMPTY;
+    this.flags = flags != null ? flags : TxnFlagSet.EMPTY;
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
     this.readOnly = this.flags.isSet(MDB_RDONLY_TXN);
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index 0943b362..1fa34d32 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -33,29 +33,20 @@ static TxnFlagSet of(final TxnFlags putflag) {
   }
 
   static TxnFlagSet of(final TxnFlags... TxnFlags) {
-    return builder()
-        .setFlags(TxnFlags)
-        .build();
+    return builder().setFlags(TxnFlags).build();
   }
 
   static TxnFlagSet of(final Collection<TxnFlags> txnFlags) {
-    return builder()
-        .setFlags(txnFlags)
-        .build();
+    return builder().setFlags(txnFlags).build();
   }
 
   static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
-        TxnFlags.class,
-        TxnFlagSetImpl::new,
-        SingleTxnFlagSet::new,
-        () -> TxnFlagSetImpl.EMPTY);
+        TxnFlags.class, TxnFlagSetImpl::new, SingleTxnFlagSet::new, () -> TxnFlagSetImpl.EMPTY);
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
 
     static final TxnFlagSet EMPTY = new EmptyTxnFlagSet();
@@ -65,21 +56,18 @@ private TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags> implements TxnFlagSet {
+  class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
+      implements TxnFlagSet {
 
     SingleTxnFlagSet(final TxnFlags flag) {
       super(flag);
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags> implements TxnFlagSet {
-  }
+  class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
+      implements TxnFlagSet {}
 }
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index 7358416b..dbe32e14 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -25,7 +25,8 @@
 import java.util.Set;
 import org.junit.jupiter.api.Test;
 
-public abstract class AbstractFlagSetTest<T extends Enum<T> & MaskedFlag & FlagSet<T>, F extends FlagSet<T>> {
+public abstract class AbstractFlagSetTest<
+    T extends Enum<T> & MaskedFlag & FlagSet<T>, F extends FlagSet<T>> {
 
   abstract List<T> getAllFlags();
 
@@ -48,70 +49,42 @@ T getFirst() {
   @Test
   void testEmpty() {
     final F emptyFlagSet = getEmptyFlagSet();
-    assertThat(emptyFlagSet.getMask())
-        .isEqualTo(0);
-    assertThat(emptyFlagSet.getFlags())
-        .isEmpty();
-    assertThat(emptyFlagSet.isEmpty())
-        .isTrue();
-    assertThat(emptyFlagSet.size())
-        .isEqualTo(0);
-    assertThat(emptyFlagSet.isSet(getFirst()))
-        .isFalse();
-    assertThat(getBuilder().build().getFlags())
-        .isEqualTo(emptyFlagSet.getFlags());
+    assertThat(emptyFlagSet.getMask()).isEqualTo(0);
+    assertThat(emptyFlagSet.getFlags()).isEmpty();
+    assertThat(emptyFlagSet.isEmpty()).isTrue();
+    assertThat(emptyFlagSet.size()).isEqualTo(0);
+    assertThat(emptyFlagSet.isSet(getFirst())).isFalse();
+    assertThat(getBuilder().build().getFlags()).isEqualTo(emptyFlagSet.getFlags());
   }
 
   @Test
   void testSingleFlagSet() {
     final List<T> allFlags = getAllFlags();
     for (T flag : allFlags) {
-      final F flagSet = getBuilder()
-          .addFlag(flag)
-          .build();
-      assertThat(flagSet.getMask())
-          .isEqualTo(flag.getMask());
-      assertThat(flagSet.getMask())
-          .isEqualTo(MaskedFlag.mask(flag));
-      assertThat(flagSet.getFlags())
-          .containsExactly(flag);
-      assertThat(flagSet.size())
-          .isEqualTo(1);
-      assertThat(FlagSet.equals(flagSet, new Object()))
-          .isFalse();
-      assertThat(FlagSet.equals(flagSet, null))
-          .isFalse();
-      assertThat(FlagSet.equals(flag, flag))
-          .isTrue();
-      assertThat(FlagSet.equals(flagSet, flag))
-          .isTrue();
-      assertThat(FlagSet.equals(flagSet, getFlagSet(flag)))
-          .isTrue();
-      assertThat(FlagSet.equals(flagSet, getFlagSet(flagSet.getFlags())))
-          .isTrue();
-      assertThat(flagSet.areAnySet(flag))
-          .isTrue();
-      assertThat(flagSet.areAnySet(null))
-          .isFalse();
-      assertThat(flagSet.areAnySet(getEmptyFlagSet()))
-          .isFalse();
-      assertThat(flagSet.isSet(getFirst()))
-          .isEqualTo(getFirst() == flag);
+      final F flagSet = getBuilder().addFlag(flag).build();
+      assertThat(flagSet.getMask()).isEqualTo(flag.getMask());
+      assertThat(flagSet.getMask()).isEqualTo(MaskedFlag.mask(flag));
+      assertThat(flagSet.getFlags()).containsExactly(flag);
+      assertThat(flagSet.size()).isEqualTo(1);
+      assertThat(FlagSet.equals(flagSet, new Object())).isFalse();
+      assertThat(FlagSet.equals(flagSet, null)).isFalse();
+      assertThat(FlagSet.equals(flag, flag)).isTrue();
+      assertThat(FlagSet.equals(flagSet, flag)).isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flag))).isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flagSet.getFlags()))).isTrue();
+      assertThat(flagSet.areAnySet(flag)).isTrue();
+      assertThat(flagSet.areAnySet(null)).isFalse();
+      assertThat(flagSet.areAnySet(getEmptyFlagSet())).isFalse();
+      assertThat(flagSet.isSet(getFirst())).isEqualTo(getFirst() == flag);
       if (getFirst() == flag) {
-        assertThat(flagSet.getMask())
-            .isEqualTo(MaskedFlag.mask(getFirst()));
+        assertThat(flagSet.getMask()).isEqualTo(MaskedFlag.mask(getFirst()));
       } else {
-        assertThat(flagSet.getMask())
-            .isNotEqualTo(MaskedFlag.mask(getFirst()));
-        assertThat(flagSet.getMaskWith(getFirst()))
-            .isEqualTo(MaskedFlag.mask(flag, getFirst()));
+        assertThat(flagSet.getMask()).isNotEqualTo(MaskedFlag.mask(getFirst()));
+        assertThat(flagSet.getMaskWith(getFirst())).isEqualTo(MaskedFlag.mask(flag, getFirst()));
       }
-      assertThat(flagSet.toString())
-          .isNotNull();
-      assertThat(flag.name())
-          .isNotNull();
-      assertThat(flagSet.getMaskWith(null))
-          .isEqualTo(flagSet.getMask());
+      assertThat(flagSet.toString()).isNotNull();
+      assertThat(flag.name()).isNotNull();
+      assertThat(flagSet.getMaskWith(null)).isEqualTo(flagSet.getMask());
     }
   }
 
@@ -123,72 +96,47 @@ void testAllFlags() {
     final T firstFlag = getFirst();
     for (T flag : allFlags) {
       flags.add(flag);
-      final F flagSet = getBuilder()
-          .setFlags(flags)
-          .build();
+      final F flagSet = getBuilder().setFlags(flags).build();
       final int flagSetMask = flagSet.getMask();
 
-      assertThat(masks)
-          .doesNotContain(flagSetMask);
+      assertThat(masks).doesNotContain(flagSetMask);
       masks.add(flagSetMask);
-      assertThat(flagSetMask)
-          .isEqualTo(MaskedFlag.mask(flags));
+      assertThat(flagSetMask).isEqualTo(MaskedFlag.mask(flags));
       final T[] flagsArr = flags.stream().toArray(this::toArray);
-      assertThat(flagSetMask)
-          .isEqualTo(MaskedFlag.mask(flagsArr));
-      assertThat(flagSet.getFlags())
-          .containsExactlyElementsOf(flags);
-      assertThat(flagSet)
-          .isNotEmpty();
-      assertThat(FlagSet.equals(flagSet, getBuilder().setFlags(flagsArr).build()))
-          .isTrue();
-      assertThat(FlagSet.equals(flagSet, getFlagSet(flags)))
-          .isTrue();
-      assertThat(FlagSet.equals(flagSet, getFlagSet(flagsArr)))
-          .isTrue();
-      assertThat(flagSet.size())
-          .isEqualTo(flags.size());
-      assertThat(flagSet.isSet(getFirst()))
-          .isEqualTo(true);
+      assertThat(flagSetMask).isEqualTo(MaskedFlag.mask(flagsArr));
+      assertThat(flagSet.getFlags()).containsExactlyElementsOf(flags);
+      assertThat(flagSet).isNotEmpty();
+      assertThat(FlagSet.equals(flagSet, getBuilder().setFlags(flagsArr).build())).isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flags))).isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flagsArr))).isTrue();
+      assertThat(flagSet.size()).isEqualTo(flags.size());
+      assertThat(flagSet.isSet(getFirst())).isEqualTo(true);
 
       final int maskWith = flagSet.getMaskWith(firstFlag);
       final List<T> combinedList = new ArrayList<>(flags);
       combinedList.add(firstFlag);
-      assertThat(maskWith)
-          .isEqualTo(MaskedFlag.mask(combinedList));
+      assertThat(maskWith).isEqualTo(MaskedFlag.mask(combinedList));
     }
   }
 
-  /**
-   * Test as an enum instance rather than a {@link FlagSet}
-   */
+  /** Test as an enum instance rather than a {@link FlagSet} */
   @Test
   void testAsFlag() {
     final T flag = getFirst();
-    assertThat(flag.size())
-        .isEqualTo(1);
-    assertThat(flag.getFlags())
-        .hasSize(1);
+    assertThat(flag.size()).isEqualTo(1);
+    assertThat(flag.getFlags()).hasSize(1);
     final T flag2 = flag.getFlags().iterator().next();
-    assertThat(flag2 == flag)
-        .isTrue();
-    assertThat(flag.getMask())
-        .isEqualTo(MaskedFlag.mask(flag));
-    assertThat(flag.isEmpty())
-        .isFalse();
-    assertThat(flag.toString())
-        .isNotNull();
-    assertThat(flag.isSet(flag))
-        .isTrue();
-    assertThat(flag.isSet(flag2))
-        .isTrue();
-    assertThat(flag.isSet(null))
-        .isFalse();
+    assertThat(flag2 == flag).isTrue();
+    assertThat(flag.getMask()).isEqualTo(MaskedFlag.mask(flag));
+    assertThat(flag.isEmpty()).isFalse();
+    assertThat(flag.toString()).isNotNull();
+    assertThat(flag.isSet(flag)).isTrue();
+    assertThat(flag.isSet(flag2)).isTrue();
+    assertThat(flag.isSet(null)).isFalse();
     final List<T> allFlags = getAllFlags();
     if (allFlags.size() > 1) {
       T secondFlag = allFlags.get(1);
-      assertThat(flag.isSet(secondFlag))
-          .isFalse();
+      assertThat(flag.isSet(secondFlag)).isFalse();
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index d9312cce..6ee8f874 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -51,9 +51,7 @@
 import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
 import org.lmdbjava.Env.ReadersFullException;
 
-/**
- * Test {@link ByteBufferProxy}.
- */
+/** Test {@link ByteBufferProxy}. */
 public final class ByteBufferProxyTest {
 
   static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
@@ -61,25 +59,24 @@ public final class ByteBufferProxyTest {
   @Test
   void buffersMustBeDirect() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempDir(
-              dir -> {
-                try (Env<ByteBuffer> env = create()
-                    .setMaxReaders(1)
-                    .open(dir)) {
-                  final Dbi<ByteBuffer> db = env.createDbi()
-                      .setDbName(DB_1)
-                      .withDefaultComparator()
-                      .setDbiFlags(MDB_CREATE)
-                      .open();
-                  final ByteBuffer key = allocate(100);
-                  key.putInt(1).flip();
-                  final ByteBuffer val = allocate(100);
-                  val.putInt(1).flip();
-                  db.put(key, val); // error
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempDir(
+                  dir -> {
+                    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(dir)) {
+                      final Dbi<ByteBuffer> db =
+                          env.createDbi()
+                              .setDbName(DB_1)
+                              .withDefaultComparator()
+                              .setDbiFlags(MDB_CREATE)
+                              .open();
+                      final ByteBuffer key = allocate(100);
+                      key.putInt(1).flip();
+                      final ByteBuffer val = allocate(100);
+                      val.putInt(1).flip();
+                      db.put(key, val); // error
+                    }
+                  });
+            })
         .isInstanceOf(BufferMustBeDirectException.class);
   }
 
@@ -104,9 +101,9 @@ void coverPrivateConstructor() {
   @Test
   void fieldNeverFound() {
     assertThatThrownBy(
-        () -> {
-          findField(Exception.class, "notARealField");
-        })
+            () -> {
+              findField(Exception.class, "notARealField");
+            })
         .isInstanceOf(LmdbException.class);
   }
 
@@ -164,29 +161,29 @@ public void comparatorPerformance() {
       int x = 0;
       for (int round = 0; round < rounds; round++) {
         for (int i = 1; i < values.length; i++) {
-          buffer1.order(ByteOrder.nativeOrder())
-              .putLong(0, values[i - 1]);
-          buffer2.order(ByteOrder.nativeOrder())
-              .putLong(0, values[i]);
-          final int result = ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
+          buffer1.order(ByteOrder.nativeOrder()).putLong(0, values[i - 1]);
+          buffer2.order(ByteOrder.nativeOrder()).putLong(0, values[i]);
+          final int result =
+              ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
           x += result;
         }
       }
-      System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()) + ", x: " + x);
+      System.out.println(
+          "compareAsIntegerKeys: " + Duration.between(time, Instant.now()) + ", x: " + x);
 
       time = Instant.now();
       int y = 0;
       for (int round = 0; round < rounds; round++) {
         for (int i = 1; i < values.length; i++) {
-          buffer1.order(BIG_ENDIAN)
-              .putLong(0, values[i - 1]);
-          buffer2.order(BIG_ENDIAN)
-              .putLong(0, values[i]);
-          final int result = ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
+          buffer1.order(BIG_ENDIAN).putLong(0, values[i - 1]);
+          buffer2.order(BIG_ENDIAN).putLong(0, values[i]);
+          final int result =
+              ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
           y += result;
         }
       }
-      System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()) + ", y: " + y);
+      System.out.println(
+          "compareLexicographically: " + Duration.between(time, Instant.now()) + ", y: " + y);
 
       assertThat(y).isEqualTo(x);
     }
@@ -195,25 +192,27 @@ public void comparatorPerformance() {
   @Test
   public void verifyComparators() {
     final Random random = new Random(203948);
-    final ByteBuffer buffer1native = ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
-    final ByteBuffer buffer2native = ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer1native =
+        ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer2native =
+        ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
     final ByteBuffer buffer1be = ByteBuffer.allocateDirect(Long.BYTES).order(BIG_ENDIAN);
     final ByteBuffer buffer2be = ByteBuffer.allocateDirect(Long.BYTES).order(BIG_ENDIAN);
     buffer1native.limit(Long.BYTES);
     buffer2native.limit(Long.BYTES);
     buffer1be.limit(Long.BYTES);
     buffer2be.limit(Long.BYTES);
-    final long[] values = random.longs()
-        .filter(i -> i >= 0)
-        .limit(5_000_000)
-        .toArray();
-//    System.out.println("stats: " + Arrays.stream(values)
-//        .summaryStatistics()
-//        .toString());
+    final long[] values = random.longs().filter(i -> i >= 0).limit(5_000_000).toArray();
+    //    System.out.println("stats: " + Arrays.stream(values)
+    //        .summaryStatistics()
+    //        .toString());
 
     final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
-    comparators.put("compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
-    comparators.put("compareLexicographically", ByteBufferProxy.AbstractByteBufferProxy::compareLexicographically);
+    comparators.put(
+        "compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
+    comparators.put(
+        "compareLexicographically",
+        ByteBufferProxy.AbstractByteBufferProxy::compareLexicographically);
 
     final LinkedHashMap<String, Integer> results = new LinkedHashMap<>(comparators.size());
     final Set<Integer> uniqueResults = new HashSet<>(comparators.size());
@@ -228,22 +227,23 @@ public void verifyComparators() {
       uniqueResults.clear();
 
       // Make sure all comparators give the same result for the same inputs
-      comparators.forEach((name, comparator) -> {
-        final int result;
-        // IntegerKey comparator expects keys to have been written in native order so need different buffers.
-        if (name.equals("compareAsIntegerKeys")) {
-          result = comparator.compare(buffer1native, buffer2native);
-        } else {
-          result = comparator.compare(buffer1be, buffer2be);
-        }
-        results.put(name, result);
-        uniqueResults.add(result);
-      });
+      comparators.forEach(
+          (name, comparator) -> {
+            final int result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (name.equals("compareAsIntegerKeys")) {
+              result = comparator.compare(buffer1native, buffer2native);
+            } else {
+              result = comparator.compare(buffer1be, buffer2be);
+            }
+            results.put(name, result);
+            uniqueResults.add(result);
+          });
 
       if (uniqueResults.size() != 1) {
-        Assertions.fail("Comparator mismatch for values: "
-            + val1 + " and "
-            + val2 + ". Results: " + results);
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
       }
     }
   }
diff --git a/src/test/java/org/lmdbjava/ByteUnitTest.java b/src/test/java/org/lmdbjava/ByteUnitTest.java
index a899cbc3..5724429d 100644
--- a/src/test/java/org/lmdbjava/ByteUnitTest.java
+++ b/src/test/java/org/lmdbjava/ByteUnitTest.java
@@ -59,6 +59,5 @@ void test() {
 
     Assertions.assertThat(ByteUnit.PETABYTES.toBytes(1)).isEqualTo(1000000000000000L);
     Assertions.assertThat(ByteUnit.PETABYTES.toBytes(2)).isEqualTo(2000000000000000L);
-
   }
 }
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
index 32e0c8c5..00c0ce28 100644
--- a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -38,9 +38,7 @@
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-/**
- * Tests comparator functions are consistent across buffers.
- */
+/** Tests comparator functions are consistent across buffers. */
 public final class ComparatorIntegerKeyTest {
 
   static Stream<Arguments> comparatorProvider() {
@@ -101,10 +99,7 @@ void testRandomLong(final ComparatorRunner runner) {
     final Random random = new Random(3239480);
 
     // 5mil random longs to compare
-    final long[] values = random.longs()
-        .filter(i -> i >= 0)
-        .limit(5_000_000)
-        .toArray();
+    final long[] values = random.longs().filter(i -> i >= 0).limit(5_000_000).toArray();
 
     for (int i = 1; i < values.length; i++) {
       final long long1 = values[i - 1];
@@ -114,20 +109,32 @@ void testRandomLong(final ComparatorRunner runner) {
       final ComparatorTest.ComparatorResult expectedResult = get(Long.compare(long1, long2));
 
       assertThat(result)
-          .withFailMessage(() -> "Compare mismatch - long1: " + long1
-              + ", long2: " + long2
-              + ", expected: " + expectedResult
-              + ", actual: " + result)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch - long1: "
+                      + long1
+                      + ", long2: "
+                      + long2
+                      + ", expected: "
+                      + expectedResult
+                      + ", actual: "
+                      + result)
           .isEqualTo(expectedResult);
 
       final ComparatorTest.ComparatorResult result2 = get(runner.compare(long2, long1));
       final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
 
       assertThat(result)
-          .withFailMessage(() -> "Compare mismatch for - long2: " + long2
-              + ", long1: " + long1
-              + ", expected2: " + expectedResult2
-              + ", actual2: " + result2)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch for - long2: "
+                      + long2
+                      + ", long1: "
+                      + long1
+                      + ", expected2: "
+                      + expectedResult2
+                      + ", actual2: "
+                      + result2)
           .isEqualTo(expectedResult);
     }
   }
@@ -138,10 +145,7 @@ void testRandomInt(final ComparatorRunner runner) {
     final Random random = new Random(3239480);
 
     // 5mil random ints to compare
-    final int[] values = random.ints()
-        .filter(i -> i >= 0)
-        .limit(5_000_000)
-        .toArray();
+    final int[] values = random.ints().filter(i -> i >= 0).limit(5_000_000).toArray();
 
     for (int i = 1; i < values.length; i++) {
       final int int1 = values[i - 1];
@@ -151,34 +155,43 @@ void testRandomInt(final ComparatorRunner runner) {
       final ComparatorTest.ComparatorResult expectedResult = get(Integer.compare(int1, int2));
 
       assertThat(result)
-          .withFailMessage(() -> "Compare mismatch for - int1: " + int1
-              + ", int2: " + int2
-              + ", expected: " + expectedResult
-              + ", actual: " + result)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch for - int1: "
+                      + int1
+                      + ", int2: "
+                      + int2
+                      + ", expected: "
+                      + expectedResult
+                      + ", actual: "
+                      + result)
           .isEqualTo(expectedResult);
 
       final ComparatorTest.ComparatorResult result2 = get(runner.compare(int2, int1));
       final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
 
       assertThat(result)
-          .withFailMessage(() -> "Compare mismatch for - int2: " + int2
-              + ", int1: " + int1
-              + ", expected2: " + expectedResult2
-              + ", actual2: " + result2)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch for - int2: "
+                      + int2
+                      + ", int1: "
+                      + int1
+                      + ", expected2: "
+                      + expectedResult2
+                      + ", actual2: "
+                      + result2)
           .isEqualTo(expectedResult);
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  /**
-   * Tests {@link ByteBufferProxy}.
-   */
+  /** Tests {@link ByteBufferProxy}. */
   private static final class ByteBufferRunner implements ComparatorRunner {
 
-    private static final Comparator<ByteBuffer> COMPARATOR = PROXY_OPTIMAL.getComparator(DbiFlags.MDB_INTEGERKEY);
+    private static final Comparator<ByteBuffer> COMPARATOR =
+        PROXY_OPTIMAL.getComparator(DbiFlags.MDB_INTEGERKEY);
 
     @Override
     public int compare(long long1, long long2) {
@@ -247,15 +260,12 @@ private ByteBuffer intToBuffer(final int val, final int bufferCapacity) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  /**
-   * Tests {@link DirectBufferProxy}.
-   */
+  /** Tests {@link DirectBufferProxy}. */
   private static final class DirectBufferRunner implements ComparatorRunner {
-    private static final Comparator<DirectBuffer> COMPARATOR = PROXY_DB.getComparator(DbiFlags.MDB_INTEGERKEY);
+    private static final Comparator<DirectBuffer> COMPARATOR =
+        PROXY_DB.getComparator(DbiFlags.MDB_INTEGERKEY);
 
     @Override
     public int compare(long long1, long long2) {
@@ -276,12 +286,11 @@ public int compare(int int1, int int2) {
     }
   }
 
-  /**
-   * Tests {@link ByteBufProxy}.
-   */
+  /** Tests {@link ByteBufProxy}. */
   private static final class NettyRunner implements ComparatorRunner {
 
-    private static final Comparator<ByteBuf> COMPARATOR = PROXY_NETTY.getComparator(DbiFlags.MDB_INTEGERKEY);
+    private static final Comparator<ByteBuf> COMPARATOR =
+        PROXY_NETTY.getComparator(DbiFlags.MDB_INTEGERKEY);
 
     @Override
     public int compare(long long1, long long2) {
@@ -322,13 +331,9 @@ public int compare(int int1, int int2) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  /**
-   * Interface that can test a {@link BufferProxy} <code>compare</code> method.
-   */
+  /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
   private interface ComparatorRunner {
 
     /**
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index e53c7508..898da499 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -22,39 +22,38 @@
 
 public class CopyFlagSetTest extends AbstractFlagSetTest<CopyFlags, CopyFlagSet> {
 
-    @Override
-    List<CopyFlags> getAllFlags() {
-        return Arrays.stream(CopyFlags.values())
-            .collect(Collectors.toList());
-    }
-
-    @Override
-    CopyFlagSet getEmptyFlagSet() {
-        return CopyFlagSet.empty();
-    }
-
-    @Override
-    AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> getBuilder() {
-        return CopyFlagSet.builder();
-    }
-
-    @Override
-    CopyFlagSet getFlagSet(Collection<CopyFlags> flags) {
-        return CopyFlagSet.of(flags);
-    }
-
-    @Override
-    CopyFlagSet getFlagSet(CopyFlags[] flags) {
-        return CopyFlagSet.of(flags);
-    }
-
-    @Override
-    CopyFlagSet getFlagSet(CopyFlags flag) {
-        return CopyFlagSet.of(flag);
-    }
-
-    @Override
-    Class<CopyFlags> getFlagType() {
-        return CopyFlags.class;
-    }
+  @Override
+  List<CopyFlags> getAllFlags() {
+    return Arrays.stream(CopyFlags.values()).collect(Collectors.toList());
+  }
+
+  @Override
+  CopyFlagSet getEmptyFlagSet() {
+    return CopyFlagSet.empty();
+  }
+
+  @Override
+  AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> getBuilder() {
+    return CopyFlagSet.builder();
+  }
+
+  @Override
+  CopyFlagSet getFlagSet(Collection<CopyFlags> flags) {
+    return CopyFlagSet.of(flags);
+  }
+
+  @Override
+  CopyFlagSet getFlagSet(CopyFlags[] flags) {
+    return CopyFlagSet.of(flags);
+  }
+
+  @Override
+  CopyFlagSet getFlagSet(CopyFlags flag) {
+    return CopyFlagSet.of(flag);
+  }
+
+  @Override
+  Class<CopyFlags> getFlagType() {
+    return CopyFlags.class;
+  }
 }
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 0e3d4e3e..7a2515b2 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -79,18 +79,16 @@
 import org.lmdbjava.CursorIterable.KeyVal;
 
 /**
- * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that
- * comparators work with native order integer keys.
+ * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that comparators work
+ * with native order integer keys.
  */
 @Disabled // Waiting for the merge of stroomdev66's cursor tests
 @ParameterizedClass(name = "{index}: dbi: {0}")
 @ArgumentsSource(CursorIterableIntegerDupTest.MyArgumentProvider.class)
 public final class CursorIterableIntegerDupTest {
 
-  private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(
-      MDB_CREATE,
-      MDB_INTEGERDUP,
-      MDB_DUPSORT);
+  private static final DbiFlagSet DBI_FLAGS =
+      DbiFlagSet.of(MDB_CREATE, MDB_INTEGERDUP, MDB_DUPSORT);
   private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
   private static final List<Map.Entry<Integer, Integer>> INPUT_DATA;
 
@@ -113,8 +111,7 @@ public final class CursorIterableIntegerDupTest {
   private Env<ByteBuffer> env;
   private Deque<Map.Entry<Integer, Integer>> expectedEntriesDeque;
 
-  @Parameter
-  public DbiFactory dbiFactory;
+  @Parameter public DbiFactory dbiFactory;
 
   @BeforeEach
   public void before() throws IOException {
@@ -185,15 +182,15 @@ private void populateDatabase(final Dbi<ByteBuffer> dbi) {
       }
       txn.commit();
     }
-//    try (Txn<ByteBuffer> txn = env.txnRead();
-//         CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
-//
-//      for (final KeyVal<ByteBuffer> kv : c) {
-//        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
-//        System.out.print(", ");
-//      }
-//      System.out.println();
-//    }
+    //    try (Txn<ByteBuffer> txn = env.txnRead();
+    //         CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
+    //
+    //      for (final KeyVal<ByteBuffer> kv : c) {
+    //        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
+    //        System.out.print(", ");
+    //      }
+    //      System.out.println();
+    //    }
   }
 
   private int[] rangeInc(final int fromInc, final int toInc) {
@@ -256,14 +253,16 @@ public void greaterThanTest() {
   }
 
   public void iterableOnlyReturnedOnce() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        c.iterator(); // ok
-        c.iterator(); // fails
-      }
-    }).isInstanceOf(IllegalStateException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
   }
 
   @Test
@@ -271,12 +270,12 @@ public void iterate() {
     populateExpectedEntriesDeque();
     final Dbi<ByteBuffer> db = getDb();
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
 
       for (final KeyVal<ByteBuffer> kv : c) {
         final Map.Entry<Integer, Integer> entry = expectedEntriesDeque.pollFirst();
         assertThat(entry).isNotNull();
-//        System.out.println(entry.getKey() + " => " + entry.getValue());
+        //        System.out.println(entry.getKey() + " => " + entry.getValue());
         assertThat(getNativeInt(kv.key())).isEqualTo(entry.getKey());
         assertThat(kv.val().getInt()).isEqualTo(entry.getValue());
       }
@@ -284,14 +283,16 @@ public void iterate() {
   }
 
   public void iteratorOnlyReturnedOnce() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        c.iterator(); // ok
-        c.iterator(); // fails
-      }
-    }).isInstanceOf(IllegalStateException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
   }
 
   @Test
@@ -336,10 +337,12 @@ public void openClosedBackwardTestWithGuava() {
           return guava.compare(array1, array2);
         };
 
-    final Dbi<ByteBuffer> guavaDbi = env.createDbi()
-        .setDbName(DB_1).withIteratorComparator(ignored -> comparator)
-        .setDbiFlags(MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> guavaDbi =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withIteratorComparator(ignored -> comparator)
+            .setDbiFlags(MDB_CREATE)
+            .open();
 
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
@@ -380,61 +383,68 @@ public void removeOddElements() {
   }
 
   public void nextWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          env.close();
-          c.next();
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+                  env.close();
+                  c.next();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   public void removeWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnWrite()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-          final KeyVal<ByteBuffer> keyVal = c.next();
-          assertThat(keyVal).isNotNull();
-          env.close();
-          c.remove();
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+                  final KeyVal<ByteBuffer> keyVal = c.next();
+                  assertThat(keyVal).isNotNull();
+                  env.close();
+                  c.remove();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   public void hasNextWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-          env.close();
-          c.hasNext();
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.hasNext();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   public void forEachRemainingWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-          env.close();
-          c.forEachRemaining(keyVal -> {
-          });
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.forEachRemaining(keyVal -> {});
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expectedKeys) {
@@ -443,40 +453,39 @@ private void verify(final KeyRange<ByteBuffer> range, final int... expectedKeys)
     verify(range, db, expectedKeys);
   }
 
-  private void verify(final Dbi<ByteBuffer> dbi,
-                      final KeyRange<ByteBuffer> range,
-                      final int... expectedKeys) {
+  private void verify(
+      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expectedKeys) {
     verify(range, dbi, expectedKeys);
   }
 
-  private void verify(final KeyRange<ByteBuffer> range,
-                      final Dbi<ByteBuffer> dbi,
-                      final int... expectedKeys) {
+  private void verify(
+      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expectedKeys) {
     final boolean isForward = range.getType().isDirectionForward();
 
-    final List<Integer> expectedValues = Arrays.stream(expectedKeys)
-        .boxed()
-        .flatMap(key -> {
-          final int base = key * 10;
-          return isForward
-              ? Stream.of(base + 1, base + 2)
-              : Stream.of(base + 2, base + 1);
-        })
-        .collect(Collectors.toList());
+    final List<Integer> expectedValues =
+        Arrays.stream(expectedKeys)
+            .boxed()
+            .flatMap(
+                key -> {
+                  final int base = key * 10;
+                  return isForward ? Stream.of(base + 1, base + 2) : Stream.of(base + 2, base + 1);
+                })
+            .collect(Collectors.toList());
 
     final List<Integer> results = new ArrayList<>();
-//    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
+    //    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = getNativeInt(kv.key());
         final int val = kv.val().getInt();
-//        System.out.println(key + " => " + val);
+        //        System.out.println(key + " => " + val);
         results.add(val);
-        assertThat(val).satisfiesAnyOf(
-            v -> assertThat(v).isEqualTo((key * 10) + 1),
-              v -> assertThat(v).isEqualTo((key * 10) + 2));
+        assertThat(val)
+            .satisfiesAnyOf(
+                v -> assertThat(v).isEqualTo((key * 10) + 1),
+                v -> assertThat(v).isEqualTo((key * 10) + 2));
       }
     }
 
@@ -489,8 +498,11 @@ private void verify(final KeyRange<ByteBuffer> range,
   private String rangeToString(final KeyRange<ByteBuffer> range) {
     final ByteBuffer start = range.getStart();
     final ByteBuffer stop = range.getStop();
-    return range.getType() + " start: " + (start != null ? getNativeInt(start) : "")
-        + " stop: " + (stop != null ? getNativeInt(stop) : "");
+    return range.getType()
+        + " start: "
+        + (start != null ? getNativeInt(start) : "")
+        + " stop: "
+        + (stop != null ? getNativeInt(stop) : "");
   }
 
   private Dbi<ByteBuffer> getDb() {
@@ -499,10 +511,8 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -518,44 +528,51 @@ public String toString() {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
-    public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters,
-                                                        ExtensionContext context) throws Exception {
-      final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-          env.createDbi()
-              .setDbName(DB_1)
-              .withDefaultComparator()
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-          env.createDbi()
-              .setDbName(DB_2)
-              .withNativeComparator()
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-          env.createDbi()
-              .setDbName(DB_3)
-              .withCallbackComparator(MyArgumentProvider::buildComparator)
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-          env.createDbi()
-              .setDbName(DB_4)
-              .withIteratorComparator(MyArgumentProvider::buildComparator)
-              .setDbiFlags(DBI_FLAGS)
-              .open());
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
+      final DbiFactory defaultComparatorDb =
+          new DbiFactory(
+              "defaultComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory nativeComparatorDb =
+          new DbiFactory(
+              "nativeComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_2)
+                      .withNativeComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory callbackComparatorDb =
+          new DbiFactory(
+              "callbackComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_3)
+                      .withCallbackComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory iteratorComparatorDb =
+          new DbiFactory(
+              "iteratorComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_4)
+                      .withIteratorComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
       return Stream.of(
-              defaultComparatorDb,
-              nativeComparatorDb,
-              callbackComparatorDb,
-              iteratorComparatorDb)
+              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
           .map(Arguments::of);
     }
 
@@ -564,8 +581,15 @@ private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSe
       return (o1, o2) -> {
         if (o1.remaining() != o2.remaining()) {
           // Make sure LMDB is always giving us consistent key lengths.
-          Assertions.fail("o1: " + o1 + " " + getNativeIntOrLong(o1)
-              + ", o2: " + o2 + " " + getNativeIntOrLong(o2));
+          Assertions.fail(
+              "o1: "
+                  + o1
+                  + " "
+                  + getNativeIntOrLong(o1)
+                  + ", o2: "
+                  + o2
+                  + " "
+                  + getNativeIntOrLong(o2));
         }
         return baseComparator.compare(o1, o2);
       };
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 3ff4364f..c35767c0 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -81,8 +81,8 @@
 import org.lmdbjava.CursorIterable.KeyVal;
 
 /**
- * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that
- * comparators work with native order integer keys.
+ * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that comparators work
+ * with native order integer keys.
  */
 @ParameterizedClass(name = "{index}: dbi: {0}")
 @ArgumentsSource(CursorIterableIntegerKeyTest.MyArgumentProvider.class)
@@ -95,19 +95,19 @@ public final class CursorIterableIntegerKeyTest {
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
-  @Parameter
-  public DbiFactory dbiFactory;
+  @Parameter public DbiFactory dbiFactory;
 
   @BeforeEach
   public void before() throws IOException {
     file = FileUtil.createTempFile();
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env = Env.create(bufferProxy)
-        .setMapSize(256, ByteUnit.KIBIBYTES)
-        .setMaxReaders(1)
-        .setMaxDbs(3)
-        .setEnvFlags(MDB_NOSUBDIR)
-        .open(file);
+    env =
+        Env.create(bufferProxy)
+            .setMapSize(256, ByteUnit.KIBIBYTES)
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
 
     populateTestDataList();
   }
@@ -126,7 +126,7 @@ public void testNumericOrderLong() {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       long i = 1;
       while (true) {
-//        System.out.println("putting " + i);
+        //        System.out.println("putting " + i);
         c.put(bbNative(i), bb(i + "-long"));
         final long i2 = i * 10;
         if (i2 < i) {
@@ -146,18 +146,14 @@ public void testNumericOrderLong() {
           final String val = getString(keyVal.val());
           final long key = getNativeLong(keyVal.key());
           entries.add(new AbstractMap.SimpleEntry<>(key, val));
-//          System.out.println(val);
+          //          System.out.println(val);
         }
       }
     }
 
-    final List<Long> dbKeys = entries.stream()
-        .map(Map.Entry::getKey)
-        .collect(Collectors.toList());
-    final List<Long> dbKeysSorted = entries.stream()
-        .map(Map.Entry::getKey)
-        .sorted()
-        .collect(Collectors.toList());
+    final List<Long> dbKeys = entries.stream().map(Map.Entry::getKey).collect(Collectors.toList());
+    final List<Long> dbKeysSorted =
+        entries.stream().map(Map.Entry::getKey).sorted().collect(Collectors.toList());
     for (int i = 0; i < dbKeys.size(); i++) {
       final long dbKey1 = dbKeys.get(i);
       final long dbKey2 = dbKeysSorted.get(i);
@@ -173,7 +169,7 @@ public void testNumericOrderInt() {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       int i = 1;
       while (true) {
-//        System.out.println("putting " + i);
+        //        System.out.println("putting " + i);
         c.put(bbNative(i), bb(i + "-int"));
         final int i2 = i * 10;
         if (i2 < i) {
@@ -193,18 +189,15 @@ public void testNumericOrderInt() {
           final String val = getString(keyVal.val());
           final int key = TestUtils.getNativeInt(keyVal.key());
           entries.add(new AbstractMap.SimpleEntry<>(key, val));
-//          System.out.println(val);
+          //          System.out.println(val);
         }
       }
     }
 
-    final List<Integer> dbKeys = entries.stream()
-        .map(Map.Entry::getKey)
-        .collect(Collectors.toList());
-    final List<Integer> dbKeysSorted = entries.stream()
-        .map(Map.Entry::getKey)
-        .sorted()
-        .collect(Collectors.toList());
+    final List<Integer> dbKeys =
+        entries.stream().map(Map.Entry::getKey).collect(Collectors.toList());
+    final List<Integer> dbKeysSorted =
+        entries.stream().map(Map.Entry::getKey).sorted().collect(Collectors.toList());
     for (int i = 0; i < dbKeys.size(); i++) {
       final long dbKey1 = dbKeys.get(i);
       final long dbKey2 = dbKeysSorted.get(i);
@@ -218,7 +211,7 @@ public void testIntegerKeyKeySize() {
     long maxIntAsLong = Integer.MAX_VALUE;
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-//      System.out.println("Flags: " + db.listFlags(txn));
+      //      System.out.println("Flags: " + db.listFlags(txn));
       int val = 0;
       db.put(txn, bbNative(0L), bb("val_" + ++val));
       db.put(txn, bbNative(10L), bb("val_" + ++val));
@@ -233,16 +226,16 @@ public void testIntegerKeyKeySize() {
       db.put(txn, bbNative(Long.MAX_VALUE), bb("val_" + ++val));
       txn.commit();
     }
-//    try (Txn<ByteBuffer> txn = env.txnRead()) {
-//      try (CursorIterable<ByteBuffer> iterable = db.iterate(txn)) {
-//        for (KeyVal<ByteBuffer> keyVal : iterable) {
-//          final String val = getString(keyVal.val());
-//          final long key = getNativeLong(keyVal.key());
-//          final int remaining = keyVal.key().remaining();
-//          System.out.println("key: " + key + ", val: " + val + ", remaining: " + remaining);
-//        }
-//      }
-//    }
+    //    try (Txn<ByteBuffer> txn = env.txnRead()) {
+    //      try (CursorIterable<ByteBuffer> iterable = db.iterate(txn)) {
+    //        for (KeyVal<ByteBuffer> keyVal : iterable) {
+    //          final String val = getString(keyVal.val());
+    //          final long key = getNativeLong(keyVal.key());
+    //          final int remaining = keyVal.key().remaining();
+    //          System.out.println("key: " + key + ", val: " + val + ", remaining: " + remaining);
+    //        }
+    //      }
+    //    }
   }
 
   @Test
@@ -337,14 +330,16 @@ public void greaterThanTest() {
   }
 
   public void iterableOnlyReturnedOnce() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        c.iterator(); // ok
-        c.iterator(); // fails
-      }
-    }).isInstanceOf(IllegalStateException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
   }
 
   @Test
@@ -352,7 +347,7 @@ public void iterate() {
     populateTestDataList();
     final Dbi<ByteBuffer> db = getDb();
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
 
       for (final KeyVal<ByteBuffer> kv : c) {
         assertThat(getNativeInt(kv.key())).isEqualTo(list.pollFirst());
@@ -362,14 +357,16 @@ public void iterate() {
   }
 
   public void iteratorOnlyReturnedOnce() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        c.iterator(); // ok
-        c.iterator(); // fails
-      }
-    }).isInstanceOf(IllegalStateException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
   }
 
   @Test
@@ -385,21 +382,23 @@ public void lessThanTest() {
   }
 
   public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
-    Assertions.assertThatThrownBy(() -> {
-      populateTestDataList();
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
-        while (i.hasNext()) {
-          final KeyVal<ByteBuffer> kv = i.next();
-          assertThat(getNativeInt(kv.key())).isEqualTo(list.pollFirst());
-          assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
-        }
-        assertThat(i.hasNext()).isEqualTo(false);
-        i.next();
-      }
-    }).isInstanceOf(NoSuchElementException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              populateTestDataList();
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+                while (i.hasNext()) {
+                  final KeyVal<ByteBuffer> kv = i.next();
+                  assertThat(getNativeInt(kv.key())).isEqualTo(list.pollFirst());
+                  assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
+                }
+                assertThat(i.hasNext()).isEqualTo(false);
+                i.next();
+              }
+            })
+        .isInstanceOf(NoSuchElementException.class);
   }
 
   @Test
@@ -431,11 +430,12 @@ public void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.createDbi()
-        .setDbName(DB_1)
-        .withIteratorComparator(ignored -> comparator)
-        .setDbiFlags(MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> guavaDbi =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withIteratorComparator(ignored -> comparator)
+            .setDbiFlags(MDB_CREATE)
+            .open();
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
     verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
@@ -475,63 +475,70 @@ public void removeOddElements() {
   }
 
   public void nextWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          env.close();
-          c.next();
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+                  env.close();
+                  c.next();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   public void removeWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnWrite()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          final KeyVal<ByteBuffer> keyVal = c.next();
-          assertThat(keyVal).isNotNull();
+                  final KeyVal<ByteBuffer> keyVal = c.next();
+                  assertThat(keyVal).isNotNull();
 
-          env.close();
-          c.remove();
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+                  env.close();
+                  c.remove();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   public void hasNextWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-          env.close();
-          c.hasNext();
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.hasNext();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   public void forEachRemainingWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-          env.close();
-          c.forEachRemaining(keyVal -> {
-          });
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.forEachRemaining(keyVal -> {});
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
@@ -551,7 +558,7 @@ private void verify(
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = kv.key().order(ByteOrder.nativeOrder()).getInt();
         final int val = kv.val().getInt();
@@ -572,10 +579,8 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -591,44 +596,51 @@ public String toString() {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
-    public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters,
-                                                        ExtensionContext context) throws Exception {
-      final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-          env.createDbi()
-              .setDbName(DB_1)
-              .withDefaultComparator()
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-          env.createDbi()
-              .setDbName(DB_2)
-              .withNativeComparator()
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-          env.createDbi()
-              .setDbName(DB_3)
-              .withCallbackComparator(MyArgumentProvider::buildComparator)
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-          env.createDbi()
-              .setDbName(DB_4)
-              .withIteratorComparator(MyArgumentProvider::buildComparator)
-              .setDbiFlags(DBI_FLAGS)
-              .open());
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
+      final DbiFactory defaultComparatorDb =
+          new DbiFactory(
+              "defaultComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory nativeComparatorDb =
+          new DbiFactory(
+              "nativeComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_2)
+                      .withNativeComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory callbackComparatorDb =
+          new DbiFactory(
+              "callbackComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_3)
+                      .withCallbackComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory iteratorComparatorDb =
+          new DbiFactory(
+              "iteratorComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_4)
+                      .withIteratorComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
       return Stream.of(
-              defaultComparatorDb,
-              nativeComparatorDb,
-              callbackComparatorDb,
-              iteratorComparatorDb)
+              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
           .map(Arguments::of);
     }
 
@@ -637,8 +649,15 @@ private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSe
       return (o1, o2) -> {
         if (o1.remaining() != o2.remaining()) {
           // Make sure LMDB is always giving us consistent key lengths.
-          Assertions.fail("o1: " + o1 + " " + getNativeIntOrLong(o1)
-              + ", o2: " + o2 + " " + getNativeIntOrLong(o2));
+          Assertions.fail(
+              "o1: "
+                  + o1
+                  + " "
+                  + getNativeIntOrLong(o1)
+                  + ", o2: "
+                  + o2
+                  + " "
+                  + getNativeIntOrLong(o2));
         }
         return baseComparator.compare(o1, o2);
       };
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 82bf337d..9470abb2 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -58,24 +58,27 @@ public void before() throws IOException {
 
     final DbiFlagSet dbiFlagSet = MDB_CREATE;
     // Use a java comparator for start/stop keys only
-    Dbi<ByteBuffer> dbJavaComparator = env.createDbi()
-        .setDbName("JavaComparator")
-        .withDefaultComparator()
-        .setDbiFlags(dbiFlagSet)
-        .open();
+    Dbi<ByteBuffer> dbJavaComparator =
+        env.createDbi()
+            .setDbName("JavaComparator")
+            .withDefaultComparator()
+            .setDbiFlags(dbiFlagSet)
+            .open();
     // Use LMDB comparator for start/stop keys
-    Dbi<ByteBuffer> dbLmdbComparator = env.createDbi()
-        .setDbName("LmdbComparator")
-        .withNativeComparator()
-        .setDbiFlags(dbiFlagSet)
-        .open();
+    Dbi<ByteBuffer> dbLmdbComparator =
+        env.createDbi()
+            .setDbName("LmdbComparator")
+            .withNativeComparator()
+            .setDbiFlags(dbiFlagSet)
+            .open();
 
     // Use a java comparator for start/stop keys and as a callback comparator
-    Dbi<ByteBuffer> dbCallbackComparator = env.createDbi()
-        .setDbName("CallBackComparator")
-        .withCallbackComparator(bufferProxy::getComparator)
-        .setDbiFlags(dbiFlagSet)
-        .open();
+    Dbi<ByteBuffer> dbCallbackComparator =
+        env.createDbi()
+            .setDbName("CallBackComparator")
+            .withCallbackComparator(bufferProxy::getComparator)
+            .setDbiFlags(dbiFlagSet)
+            .open();
 
     dbs.add(dbJavaComparator);
     dbs.add(dbLmdbComparator);
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index e57e8ca4..7c1aa227 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -71,9 +71,7 @@
 import org.junit.jupiter.params.support.ParameterDeclarations;
 import org.lmdbjava.CursorIterable.KeyVal;
 
-/**
- * Test {@link CursorIterable}.
- */
+/** Test {@link CursorIterable}. */
 @ParameterizedClass(name = "{index}: dbi: {0}")
 @ArgumentsSource(CursorIterableTest.MyArgumentProvider.class)
 public final class CursorIterableTest {
@@ -85,23 +83,23 @@ public final class CursorIterableTest {
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
-//  /**
-//   * Injected by {@link #data()} with appropriate runner.
-//   */
-//  @SuppressWarnings("ClassEscapesDefinedScope")
-  @Parameter
-  public DbiFactory dbiFactory;
+  //  /**
+  //   * Injected by {@link #data()} with appropriate runner.
+  //   */
+  //  @SuppressWarnings("ClassEscapesDefinedScope")
+  @Parameter public DbiFactory dbiFactory;
 
   @BeforeEach
   void beforeEach() {
     file = FileUtil.createTempFile();
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env = create(bufferProxy)
-        .setMapSize(256, ByteUnit.KIBIBYTES)
-        .setMaxReaders(1)
-        .setMaxDbs(3)
-        .setEnvFlags(MDB_NOSUBDIR)
-        .open(file);
+    env =
+        create(bufferProxy)
+            .setMapSize(256, ByteUnit.KIBIBYTES)
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
 
     populateTestDataList();
   }
@@ -112,7 +110,6 @@ void afterEach() {
     FileUtil.delete(file);
   }
 
-
   private void populateTestDataList() {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
@@ -207,14 +204,14 @@ void greaterThanTest() {
   @Test
   void iterableOnlyReturnedOnce() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          try (Txn<ByteBuffer> txn = env.txnRead();
-               CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-            c.iterator(); // ok
-            c.iterator(); // fails
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
         .isInstanceOf(IllegalStateException.class);
   }
 
@@ -222,7 +219,7 @@ void iterableOnlyReturnedOnce() {
   void iterate() {
     final Dbi<ByteBuffer> db = getDb();
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
 
       for (final KeyVal<ByteBuffer> kv : c) {
         assertThat(kv.key().getInt()).isEqualTo(list.pollFirst());
@@ -234,14 +231,14 @@ void iterate() {
   @Test
   void iteratorOnlyReturnedOnce() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          try (Txn<ByteBuffer> txn = env.txnRead();
-               CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-            c.iterator(); // ok
-            c.iterator(); // fails
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
         .isInstanceOf(IllegalStateException.class);
   }
 
@@ -260,21 +257,21 @@ void lessThanTest() {
   @Test
   void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          populateTestDataList();
-          try (Txn<ByteBuffer> txn = env.txnRead();
-               CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-            final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
-            while (i.hasNext()) {
-              final KeyVal<ByteBuffer> kv = i.next();
-              assertThat(kv.key().getInt()).isEqualTo(list.pollFirst());
-              assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
-            }
-            assertThat(i.hasNext()).isFalse();
-            i.next();
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              populateTestDataList();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+                while (i.hasNext()) {
+                  final KeyVal<ByteBuffer> kv = i.next();
+                  assertThat(kv.key().getInt()).isEqualTo(list.pollFirst());
+                  assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
+                }
+                assertThat(i.hasNext()).isFalse();
+                i.next();
+              }
+            })
         .isInstanceOf(NoSuchElementException.class);
   }
 
@@ -307,11 +304,8 @@ void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.createDbi()
-        .setDbName(DB_1)
-        .withDefaultComparator()
-        .setDbiFlags(MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> guavaDbi =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bb(7), bb(2)), guavaDbi, 6, 4, 2);
     verify(openClosedBackward(bb(8), bb(4)), guavaDbi, 6, 4);
@@ -353,121 +347,121 @@ void removeOddElements() {
   @Test
   void nextWithClosedEnvTest() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          try (Txn<ByteBuffer> txn = env.txnRead()) {
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-              final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-              env.close();
-              c.next();
-            }
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.next();
+                }
+              }
+            })
         .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   @Test
   void removeWithClosedEnvTest() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-              final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-              final KeyVal<ByteBuffer> keyVal = c.next();
-              assertThat(keyVal).isNotNull();
-
-              env.close();
-              c.remove();
-            }
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  final KeyVal<ByteBuffer> keyVal = c.next();
+                  assertThat(keyVal).isNotNull();
+
+                  env.close();
+                  c.remove();
+                }
+              }
+            })
         .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   @Test
   void hasNextWithClosedEnvTest() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          try (Txn<ByteBuffer> txn = env.txnRead()) {
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-              final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-              env.close();
-              c.hasNext();
-            }
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.hasNext();
+                }
+              }
+            })
         .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   @Test
   void forEachRemainingWithClosedEnvTest() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          try (Txn<ByteBuffer> txn = env.txnRead()) {
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-              final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-              env.close();
-              c.forEachRemaining(keyVal -> {
-              });
-            }
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.forEachRemaining(keyVal -> {});
+                }
+              }
+            })
         .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
-//  @Test
-//  public void testSignedVsUnsigned() {
-//    final ByteBuffer val1 = bb(1);
-//    final ByteBuffer val2 = bb(2);
-//    final ByteBuffer val110 = bb(110);
-//    final ByteBuffer val111 = bb(111);
-//    final ByteBuffer val150 = bb(150);
-//
-//    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-//    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
-//    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
-//
-//    // Compare the same
-//    assertThat(
-//        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
-//
-//    // Compare differently
-//    assertThat(
-//        unsignedComparator.compare(val110, val150),
-//        Matchers.not(signedComparator.compare(val110, val150)));
-//
-//    // Compare differently
-//    assertThat(
-//        unsignedComparator.compare(val111, val150),
-//        Matchers.not(signedComparator.compare(val111, val150)));
-//
-//    // This will fail if the db is using a signed comparator for the start/stop keys
-//    for (final Dbi<ByteBuffer> db : dbs) {
-//      db.put(val110, val110);
-//      db.put(val150, val150);
-//
-//      final ByteBuffer startKeyBuf = val111;
-//      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
-//
-//      try (Txn<ByteBuffer> txn = env.txnRead();
-//          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
-//        for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
-//          final int key = kv.key().getInt();
-//          final int val = kv.val().getInt();
-//          //          System.out.println("key: " + key + " val: " + val);
-//          assertThat(key, is(110));
-//          break;
-//        }
-//      }
-//    }
-//  }
+  //  @Test
+  //  public void testSignedVsUnsigned() {
+  //    final ByteBuffer val1 = bb(1);
+  //    final ByteBuffer val2 = bb(2);
+  //    final ByteBuffer val110 = bb(110);
+  //    final ByteBuffer val111 = bb(111);
+  //    final ByteBuffer val150 = bb(150);
+  //
+  //    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+  //    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
+  //    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
+  //
+  //    // Compare the same
+  //    assertThat(
+  //        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1,
+  // val2)));
+  //
+  //    // Compare differently
+  //    assertThat(
+  //        unsignedComparator.compare(val110, val150),
+  //        Matchers.not(signedComparator.compare(val110, val150)));
+  //
+  //    // Compare differently
+  //    assertThat(
+  //        unsignedComparator.compare(val111, val150),
+  //        Matchers.not(signedComparator.compare(val111, val150)));
+  //
+  //    // This will fail if the db is using a signed comparator for the start/stop keys
+  //    for (final Dbi<ByteBuffer> db : dbs) {
+  //      db.put(val110, val110);
+  //      db.put(val150, val150);
+  //
+  //      final ByteBuffer startKeyBuf = val111;
+  //      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
+  //
+  //      try (Txn<ByteBuffer> txn = env.txnRead();
+  //          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+  //        for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+  //          final int key = kv.key().getInt();
+  //          final int val = kv.val().getInt();
+  //          //          System.out.println("key: " + key + " val: " + val);
+  //          assertThat(key, is(110));
+  //          break;
+  //        }
+  //      }
+  //    }
+  //  }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
     final Dbi<ByteBuffer> db = getDb();
@@ -479,14 +473,13 @@ private void verify(
     verify(range, dbi, expected);
   }
 
-  private void verify(final KeyRange<ByteBuffer> range,
-                      final Dbi<ByteBuffer> dbi,
-                      final int... expected) {
+  private void verify(
+      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
 
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = kv.key().getInt();
         final int val = kv.val().getInt();
@@ -507,10 +500,8 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -526,44 +517,51 @@ public String toString() {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
-    public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters,
-                                                        ExtensionContext context) throws Exception {
-      final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-          env.createDbi()
-              .setDbName(DB_1)
-              .withDefaultComparator()
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-          env.createDbi()
-              .setDbName(DB_2)
-              .withNativeComparator()
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-          env.createDbi()
-              .setDbName(DB_3)
-              .withCallbackComparator(BUFFER_PROXY::getComparator)
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-          env.createDbi()
-              .setDbName(DB_4)
-              .withIteratorComparator(BUFFER_PROXY::getComparator)
-              .setDbiFlags(DBI_FLAGS)
-              .open());
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
+      final DbiFactory defaultComparatorDb =
+          new DbiFactory(
+              "defaultComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory nativeComparatorDb =
+          new DbiFactory(
+              "nativeComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_2)
+                      .withNativeComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory callbackComparatorDb =
+          new DbiFactory(
+              "callbackComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_3)
+                      .withCallbackComparator(BUFFER_PROXY::getComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory iteratorComparatorDb =
+          new DbiFactory(
+              "iteratorComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_4)
+                      .withIteratorComparator(BUFFER_PROXY::getComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
       return Stream.of(
-              defaultComparatorDb,
-              nativeComparatorDb,
-              callbackComparatorDb,
-              iteratorComparatorDb)
+              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
           .map(Arguments::of);
     }
   }
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index f2fc5fbb..3dac152e 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -56,7 +56,8 @@ public final class CursorParamTest {
 
   static Stream<Arguments> data() {
     return Stream.of(
-        Arguments.argumentSet("ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
+        Arguments.argumentSet(
+            "ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
         Arguments.argumentSet("ByteBufferRunner(PROXY_SAFE)", new ByteBufferRunner(PROXY_SAFE)),
         Arguments.argumentSet("ByteArrayRunner(PROXY_BA)", new ByteArrayRunner(PROXY_BA)),
         Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 7177000a..3d6b5b86 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -277,7 +277,8 @@ void getKeyVal() {
 
   @Test
   void putMultiple() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED));
+    final Dbi<ByteBuffer> db =
+        env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED));
     final int elemCount = 20;
 
     final ByteBuffer values = allocateDirect(Integer.BYTES * elemCount);
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index ede387c9..f7484f00 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -40,12 +40,13 @@ public class DbiBuilderTest {
   @BeforeEach
   public void before() {
     file = FileUtil.createTempFile();
-    env = create()
-        .setMapSize(64, ByteUnit.MEBIBYTES)
-        .setMaxReaders(2)
-        .setMaxDbs(2)
-        .setEnvFlags(MDB_NOSUBDIR)
-        .open(file);
+    env =
+        create()
+            .setMapSize(64, ByteUnit.MEBIBYTES)
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
   }
 
   @AfterEach
@@ -56,11 +57,12 @@ public void after() {
 
   @Test
   public void unnamed() {
-    final Dbi<ByteBuffer> dbi = env.createDbi()
-        .withoutDbName()
-        .withDefaultComparator()
-        .setDbiFlags(DbiFlags.MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> dbi =
+        env.createDbi()
+            .withoutDbName()
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
     assertThat(dbi.getName()).isNull();
     assertThat(dbi.getNameAsString()).isEmpty();
     assertThat(env.getDbiNames()).isEmpty();
@@ -69,49 +71,46 @@ public void unnamed() {
 
   @Test
   public void named() {
-    final Dbi<ByteBuffer> dbi = env.createDbi()
-        .setDbName("foo")
-        .withDefaultComparator()
-        .setDbiFlags(DbiFlags.MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> dbi =
+        env.createDbi()
+            .setDbName("foo")
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
 
     assertPutAndGet(dbi);
 
     assertThat(env.getDbiNames()).hasSize(1);
-    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8))
-        .isEqualTo("foo");
-    assertThat(dbi.getNameAsString())
-        .isEqualTo("foo");
-    assertThat(dbi.getNameAsString(StandardCharsets.UTF_8))
-        .isEqualTo("foo");
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8)).isEqualTo("foo");
+    assertThat(dbi.getNameAsString()).isEqualTo("foo");
+    assertThat(dbi.getNameAsString(StandardCharsets.UTF_8)).isEqualTo("foo");
   }
 
   @Test
   public void named2() {
-    final Dbi<ByteBuffer> dbi = env.createDbi()
-        .setDbName("foo".getBytes(StandardCharsets.US_ASCII))
-        .withDefaultComparator()
-        .setDbiFlags(DbiFlags.MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> dbi =
+        env.createDbi()
+            .setDbName("foo".getBytes(StandardCharsets.US_ASCII))
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
 
     assertPutAndGet(dbi);
 
     assertThat(env.getDbiNames()).hasSize(1);
-    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.US_ASCII))
-        .isEqualTo("foo");
-    assertThat(dbi.getNameAsString())
-        .isEqualTo("foo");
-    assertThat(dbi.getNameAsString(StandardCharsets.US_ASCII))
-        .isEqualTo("foo");
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.US_ASCII)).isEqualTo("foo");
+    assertThat(dbi.getNameAsString()).isEqualTo("foo");
+    assertThat(dbi.getNameAsString(StandardCharsets.US_ASCII)).isEqualTo("foo");
   }
 
   @Test
   public void nativeComparator() {
-    final Dbi<ByteBuffer> dbi = env.createDbi()
-        .setDbName("foo")
-        .withNativeComparator()
-        .addDbiFlags(DbiFlags.MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> dbi =
+        env.createDbi()
+            .setDbName("foo")
+            .withNativeComparator()
+            .addDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
 
     assertPutAndGet(dbi);
     assertThat(env.getDbiNames()).hasSize(1);
@@ -121,69 +120,72 @@ public void nativeComparator() {
   public void callback() {
     final Comparator<ByteBuffer> proxyOptimal = ByteBufferProxy.PROXY_OPTIMAL.getComparator();
     // Compare on key length, falling back to default
-    final Comparator<ByteBuffer> comparator = (o1, o2) -> {
-      final int res = Integer.compare(o1.remaining(), o2.remaining());
-      if (res == 0) {
-        return proxyOptimal.compare(o1, o2);
-      } else {
-        return res;
-      }
-    };
-
-    final Dbi<ByteBuffer> dbi = env.createDbi()
-        .setDbName("foo")
-        .withCallbackComparator(ignored -> comparator)
-        .addDbiFlags(DbiFlags.MDB_CREATE)
-        .open();
-
-    TestUtils.doWithWriteTxn(env, txn -> {
-      dbi.put(txn, bb("fox"), bb("val_1"));
-      dbi.put(txn, bb("rabbit"), bb("val_2"));
-      dbi.put(txn, bb("deer"), bb("val_3"));
-      dbi.put(txn, bb("badger"), bb("val_4"));
-      txn.commit();
-    });
+    final Comparator<ByteBuffer> comparator =
+        (o1, o2) -> {
+          final int res = Integer.compare(o1.remaining(), o2.remaining());
+          if (res == 0) {
+            return proxyOptimal.compare(o1, o2);
+          } else {
+            return res;
+          }
+        };
+
+    final Dbi<ByteBuffer> dbi =
+        env.createDbi()
+            .setDbName("foo")
+            .withCallbackComparator(ignored -> comparator)
+            .addDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+
+    TestUtils.doWithWriteTxn(
+        env,
+        txn -> {
+          dbi.put(txn, bb("fox"), bb("val_1"));
+          dbi.put(txn, bb("rabbit"), bb("val_2"));
+          dbi.put(txn, bb("deer"), bb("val_3"));
+          dbi.put(txn, bb("badger"), bb("val_4"));
+          txn.commit();
+        });
 
     final List<String> keys = new ArrayList<>();
-    TestUtils.doWithReadTxn(env, txn -> {
-      try (CursorIterable<ByteBuffer> cursorIterable = dbi.iterate(txn)) {
-        final Iterator<CursorIterable.KeyVal<ByteBuffer>> iterator = cursorIterable.iterator();
-        iterator.forEachRemaining(keyVal -> {
-          keys.add(getString(keyVal.key()));
+    TestUtils.doWithReadTxn(
+        env,
+        txn -> {
+          try (CursorIterable<ByteBuffer> cursorIterable = dbi.iterate(txn)) {
+            final Iterator<CursorIterable.KeyVal<ByteBuffer>> iterator = cursorIterable.iterator();
+            iterator.forEachRemaining(
+                keyVal -> {
+                  keys.add(getString(keyVal.key()));
+                });
+          }
         });
-      }
-    });
-    assertThat(keys).containsExactly(
-        "fox",
-        "deer",
-        "badger",
-        "rabbit");
+    assertThat(keys).containsExactly("fox", "deer", "badger", "rabbit");
   }
 
   @Test
   public void flags() {
-    final Dbi<ByteBuffer> dbi = env.createDbi()
-        .setDbName("foo")
-        .withDefaultComparator()
-        .setDbiFlags(DbiFlags.MDB_DUPSORT, DbiFlags.MDB_DUPFIXED) // Will get overwritten
-        .setDbiFlags() // clear them
-        .addDbiFlags(DbiFlags.MDB_CREATE) // Not a dbi flag as far as lmdb is concerned.
-        .addDbiFlags(DbiFlags.MDB_INTEGERKEY)
-        .addDbiFlags(DbiFlags.MDB_REVERSEKEY)
-        .open();
+    final Dbi<ByteBuffer> dbi =
+        env.createDbi()
+            .setDbName("foo")
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_DUPSORT, DbiFlags.MDB_DUPFIXED) // Will get overwritten
+            .setDbiFlags() // clear them
+            .addDbiFlags(DbiFlags.MDB_CREATE) // Not a dbi flag as far as lmdb is concerned.
+            .addDbiFlags(DbiFlags.MDB_INTEGERKEY)
+            .addDbiFlags(DbiFlags.MDB_REVERSEKEY)
+            .open();
 
     assertPutAndGet(dbi);
 
     assertThat(env.getDbiNames()).hasSize(1);
-    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8))
-        .isEqualTo("foo");
-
-    TestUtils.doWithReadTxn(env, readTxn -> {
-      assertThat(dbi.listFlags(readTxn))
-          .containsExactlyInAnyOrder(
-              DbiFlags.MDB_INTEGERKEY,
-              DbiFlags.MDB_REVERSEKEY);
-    });
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8)).isEqualTo("foo");
+
+    TestUtils.doWithReadTxn(
+        env,
+        readTxn -> {
+          assertThat(dbi.listFlags(readTxn))
+              .containsExactlyInAnyOrder(DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_REVERSEKEY);
+        });
   }
 
   private void assertPutAndGet(Dbi<ByteBuffer> dbi) {
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index 06236497..1c44f0c0 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -22,39 +22,38 @@
 
 public class DbiFlagSetTest extends AbstractFlagSetTest<DbiFlags, DbiFlagSet> {
 
-    @Override
-    List<DbiFlags> getAllFlags() {
-        return Arrays.stream(DbiFlags.values())
-            .collect(Collectors.toList());
-    }
-
-    @Override
-    DbiFlagSet getEmptyFlagSet() {
-        return DbiFlagSet.empty();
-    }
-
-    @Override
-    AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> getBuilder() {
-        return DbiFlagSet.builder();
-    }
-
-    @Override
-    Class<DbiFlags> getFlagType() {
-        return DbiFlags.class;
-    }
-
-    @Override
-    DbiFlagSet getFlagSet(Collection<DbiFlags> flags) {
-        return DbiFlagSet.of(flags);
-    }
-
-    @Override
-    DbiFlagSet getFlagSet(DbiFlags[] flags) {
-        return DbiFlagSet.of(flags);
-    }
-
-    @Override
-    DbiFlagSet getFlagSet(DbiFlags flag) {
-        return DbiFlagSet.of(flag);
-    }
+  @Override
+  List<DbiFlags> getAllFlags() {
+    return Arrays.stream(DbiFlags.values()).collect(Collectors.toList());
+  }
+
+  @Override
+  DbiFlagSet getEmptyFlagSet() {
+    return DbiFlagSet.empty();
+  }
+
+  @Override
+  AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> getBuilder() {
+    return DbiFlagSet.builder();
+  }
+
+  @Override
+  Class<DbiFlags> getFlagType() {
+    return DbiFlags.class;
+  }
+
+  @Override
+  DbiFlagSet getFlagSet(Collection<DbiFlags> flags) {
+    return DbiFlagSet.of(flags);
+  }
+
+  @Override
+  DbiFlagSet getFlagSet(DbiFlags[] flags) {
+    return DbiFlagSet.of(flags);
+  }
+
+  @Override
+  DbiFlagSet getFlagSet(DbiFlags flag) {
+    return DbiFlagSet.of(flag);
+  }
 }
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 8b8a461b..f9e7a033 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -68,9 +68,7 @@
 import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.LmdbNativeException.ConstantDerivedException;
 
-/**
- * Test {@link Dbi}.
- */
+/** Test {@link Dbi}. */
 public final class DbiTest {
 
   private Path file;
@@ -81,19 +79,21 @@ public final class DbiTest {
   @BeforeEach
   void beforeEach() {
     file = FileUtil.createTempFile();
-    env = create()
-        .setMapSize(64, ByteUnit.MEBIBYTES)
-        .setMaxReaders(2)
-        .setMaxDbs(2)
-        .setEnvFlags(MDB_NOSUBDIR)
-        .open(file);
+    env =
+        create()
+            .setMapSize(64, ByteUnit.MEBIBYTES)
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
     fileBa = FileUtil.createTempFile();
-    envBa = create(PROXY_BA)
-        .setMapSize(64, ByteUnit.MEBIBYTES)
-        .setMaxReaders(2)
-        .setMaxDbs(2)
-        .setEnvFlags(MDB_NOSUBDIR)
-        .open(fileBa);
+    envBa =
+        create(PROXY_BA)
+            .setMapSize(64, ByteUnit.MEBIBYTES)
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(fileBa);
   }
 
   @AfterEach
@@ -107,16 +107,17 @@ void afterEach() {
   @Test
   void close() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = env.createDbi()
-              .setDbName(DB_1)
-              .withDefaultComparator()
-              .addDbiFlag(MDB_CREATE)
-              .open();
-          db.put(bb(1), bb(42));
-          db.close();
-          db.put(bb(2), bb(42)); // error
-        })
+            () -> {
+              final Dbi<ByteBuffer> db =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .addDbiFlag(MDB_CREATE)
+                      .open();
+              db.put(bb(1), bb(42));
+              db.close();
+              db.put(bb(2), bb(42)); // error
+            })
         .isInstanceOf(ConstantDerivedException.class);
   }
 
@@ -151,11 +152,12 @@ private <T> void doCustomComparator(
       Comparator<T> comparator,
       IntFunction<T> serializer,
       ToIntFunction<T> deserializer) {
-    final Dbi<T> db = env.createDbi()
-        .setDbName(DB_1)
-        .withCallbackComparator(ignored -> comparator)
-        .setDbiFlags(MDB_CREATE)
-        .open();
+    final Dbi<T> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withCallbackComparator(ignored -> comparator)
+            .setDbiFlags(MDB_CREATE)
+            .open();
     try (Txn<T> txn = env.txnWrite()) {
       assertThat(db.put(txn, serializer.apply(2), serializer.apply(3))).isTrue();
       assertThat(db.put(txn, serializer.apply(4), serializer.apply(6))).isTrue();
@@ -164,7 +166,7 @@ private <T> void doCustomComparator(
       txn.commit();
     }
     try (Txn<T> txn = env.txnRead();
-         CursorIterable<T> ci = db.iterate(txn, atMost(serializer.apply(4)))) {
+        CursorIterable<T> ci = db.iterate(txn, atMost(serializer.apply(4)))) {
       final Iterator<KeyVal<T>> iter = ci.iterator();
       assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(8);
       assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(6);
@@ -175,11 +177,11 @@ private <T> void doCustomComparator(
   @Test
   void dbOpenMaxDatabases() {
     assertThatThrownBy(
-        () -> {
-          env.openDbi("db1 is OK", MDB_CREATE);
-          env.openDbi("db2 is OK", MDB_CREATE);
-          env.openDbi("db3 fails", MDB_CREATE);
-        })
+            () -> {
+              env.openDbi("db1 is OK", MDB_CREATE);
+              env.openDbi("db2 is OK", MDB_CREATE);
+              env.openDbi("db3 fails", MDB_CREATE);
+            })
         .isInstanceOf(DbFullException.class);
   }
 
@@ -202,15 +204,14 @@ private <T> void doDbiWithComparatorThreadSafety(
       ToIntFunction<T> deserializer) {
     final DbiFlagSet flags = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
     final Comparator<T> comparator = comparatorSupplier.get();
-    final Dbi<T> db = env.createDbi()
-        .setDbName(DB_1)
-        .withCallbackComparator(ignored -> comparator)
-        .setDbiFlags(flags)
-        .open();
+    final Dbi<T> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withCallbackComparator(ignored -> comparator)
+            .setDbiFlags(flags)
+            .open();
 
-    final List<Integer> keys = range(0, 1_000)
-        .boxed()
-        .collect(toList());
+    final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
 
     // TODO surround with try-with-resources in J19+
     //noinspection resource // Not in J8
@@ -234,7 +235,7 @@ private <T> void doDbiWithComparatorThreadSafety(
     }
 
     try (Txn<T> txn = env.txnRead();
-         CursorIterable<T> ci = db.iterate(txn)) {
+        CursorIterable<T> ci = db.iterate(txn)) {
       final Iterator<KeyVal<T>> iter = ci.iterator();
       final List<Integer> result = new ArrayList<>();
       while (iter.hasNext()) {
@@ -314,8 +315,8 @@ void getName() {
 
   @Test
   void getNamesWhenDbisPresent() {
-    final byte[] dbHello = new byte[]{'h', 'e', 'l', 'l', 'o'};
-    final byte[] dbWorld = new byte[]{'w', 'o', 'r', 'l', 'd'};
+    final byte[] dbHello = new byte[] {'h', 'e', 'l', 'l', 'o'};
+    final byte[] dbWorld = new byte[] {'w', 'o', 'r', 'l', 'd'};
     env.openDbi(dbHello, MDB_CREATE);
     env.openDbi(dbWorld, MDB_CREATE);
     final List<byte[]> dbiNames = env.getDbiNames();
@@ -332,7 +333,8 @@ void getNamesWhenEmpty() {
 
   @Test
   void listsFlags() {
-    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY));
+    final Dbi<ByteBuffer> dbi =
+        env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY));
 
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       final List<DbiFlags> flags = dbi.listFlags(txn);
@@ -391,12 +393,13 @@ void putCommitGet() {
   void putCommitGetByteArray() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<byte[]> envBa = create(PROXY_BA)
-              .setMapSize(64, ByteUnit.MEBIBYTES)
-              .setMaxReaders(1)
-              .setMaxDbs(2)
-              .setEnvFlags(MDB_NOSUBDIR)
-              .open(file)) {
+          try (Env<byte[]> envBa =
+              create(PROXY_BA)
+                  .setMapSize(64, ByteUnit.MEBIBYTES)
+                  .setMaxReaders(1)
+                  .setMaxDbs(2)
+                  .setEnvFlags(MDB_NOSUBDIR)
+                  .open(file)) {
             final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
             try (Txn<byte[]> txn = envBa.txnWrite()) {
               db.put(txn, ba(5), ba(5));
@@ -528,19 +531,19 @@ void stats() {
   @Test
   void testMapFullException() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-          try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            final ByteBuffer v;
-            try {
-              v = allocateDirect(1_024 * 1_024 * 1_024);
-            } catch (final OutOfMemoryError e) {
-              // Travis CI OS X build cannot allocate this much memory, so assume OK
-              throw new MapFullException();
-            }
-            db.put(txn, bb(1), v);
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                final ByteBuffer v;
+                try {
+                  v = allocateDirect(1_024 * 1_024 * 1_024);
+                } catch (final OutOfMemoryError e) {
+                  // Travis CI OS X build cannot allocate this much memory, so assume OK
+                  throw new MapFullException();
+                }
+                db.put(txn, bb(1), v);
+              }
+            })
         .isInstanceOf(MapFullException.class);
   }
 
@@ -565,110 +568,110 @@ void testParallelWritesStress() {
   @Test
   void closedEnvRejectsOpenCall() {
     assertThatThrownBy(
-        () -> {
-          env.close();
-          env.openDbi(DB_1, MDB_CREATE);
-        })
+            () -> {
+              env.close();
+              env.openDbi(DB_1, MDB_CREATE);
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsCloseCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, (db, txn) -> db.close());
-        })
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.close());
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsGetCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(
-              (db, txn) -> {
-                final ByteBuffer valBuf = db.get(txn, bb(1));
-                assertThat(valBuf).isNotNull();
-                assertThat(valBuf.getInt()).isEqualTo(10);
-              },
-              (db, txn) -> db.get(txn, bb(2)));
-        })
+            () -> {
+              doEnvClosedTest(
+                  (db, txn) -> {
+                    final ByteBuffer valBuf = db.get(txn, bb(1));
+                    assertThat(valBuf).isNotNull();
+                    assertThat(valBuf.getInt()).isEqualTo(10);
+                  },
+                  (db, txn) -> db.get(txn, bb(2)));
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsPutCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
-        })
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsPutWithTxnCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(
-              null,
-              (db, txn) -> {
-                db.put(txn, bb(5), bb(50));
-              });
-        })
+            () -> {
+              doEnvClosedTest(
+                  null,
+                  (db, txn) -> {
+                    db.put(txn, bb(5), bb(50));
+                  });
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsIterateCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, Dbi::iterate);
-        })
+            () -> {
+              doEnvClosedTest(null, Dbi::iterate);
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsDropCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, Dbi::drop);
-        })
+            () -> {
+              doEnvClosedTest(null, Dbi::drop);
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsDropAndDeleteCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
-        })
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsOpenCursorCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, Dbi::openCursor);
-        })
+            () -> {
+              doEnvClosedTest(null, Dbi::openCursor);
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsReserveCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
-        })
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsStatCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, Dbi::stat);
-        })
+            () -> {
+              doEnvClosedTest(null, Dbi::stat);
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index 98a033f5..bd181ce8 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -22,39 +22,38 @@
 
 public class EnvFlagSetTest extends AbstractFlagSetTest<EnvFlags, EnvFlagSet> {
 
-    @Override
-    List<EnvFlags> getAllFlags() {
-        return Arrays.stream(EnvFlags.values())
-            .collect(Collectors.toList());
-    }
-
-    @Override
-    EnvFlagSet getEmptyFlagSet() {
-        return EnvFlagSet.empty();
-    }
-
-    @Override
-    AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> getBuilder() {
-        return EnvFlagSet.builder();
-    }
-
-    @Override
-    EnvFlagSet getFlagSet(Collection<EnvFlags> flags) {
-        return EnvFlagSet.of(flags);
-    }
-
-    @Override
-    EnvFlagSet getFlagSet(EnvFlags[] flags) {
-        return EnvFlagSet.of(flags);
-    }
-
-    @Override
-    EnvFlagSet getFlagSet(EnvFlags flag) {
-        return EnvFlagSet.of(flag);
-    }
-
-    @Override
-    Class<EnvFlags> getFlagType() {
-        return EnvFlags.class;
-    }
+  @Override
+  List<EnvFlags> getAllFlags() {
+    return Arrays.stream(EnvFlags.values()).collect(Collectors.toList());
+  }
+
+  @Override
+  EnvFlagSet getEmptyFlagSet() {
+    return EnvFlagSet.empty();
+  }
+
+  @Override
+  AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> getBuilder() {
+    return EnvFlagSet.builder();
+  }
+
+  @Override
+  EnvFlagSet getFlagSet(Collection<EnvFlags> flags) {
+    return EnvFlagSet.of(flags);
+  }
+
+  @Override
+  EnvFlagSet getFlagSet(EnvFlags[] flags) {
+    return EnvFlagSet.of(flags);
+  }
+
+  @Override
+  EnvFlagSet getFlagSet(EnvFlags flag) {
+    return EnvFlagSet.of(flag);
+  }
+
+  @Override
+  Class<EnvFlags> getFlagType() {
+    return EnvFlags.class;
+  }
 }
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index e1e72401..ab7c02ca 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -42,20 +42,19 @@
 import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.Txn.BadReaderLockException;
 
-/**
- * Test {@link Env}.
- */
+/** Test {@link Env}. */
 public final class EnvTest {
 
   @Test
   void byteUnit() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env = Env.create()
-              .setMaxReaders(1)
-              .setMapSize(1, ByteUnit.MEBIBYTES)
-              .setEnvFlags(MDB_NOSUBDIR)
-              .open(file)) {
+          try (Env<ByteBuffer> env =
+              Env.create()
+                  .setMaxReaders(1)
+                  .setMapSize(1, ByteUnit.MEBIBYTES)
+                  .setEnvFlags(MDB_NOSUBDIR)
+                  .open(file)) {
             final EnvInfo info = env.info();
             assertThat(info.mapSize).isEqualTo(ByteUnit.MEBIBYTES.toBytes(1));
           }
@@ -65,142 +64,132 @@ void byteUnit() {
   @Test
   void cannotChangeMapSizeAfterOpen() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Builder<ByteBuffer> builder = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR);
-                try (Env<ByteBuffer> ignored = builder.open(file)) {
-                  builder.setMapSize(1);
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Builder<ByteBuffer> builder =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR);
+                    try (Env<ByteBuffer> ignored = builder.open(file)) {
+                      builder.setMapSize(1);
+                    }
+                  });
+            })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotChangeMaxDbsAfterOpen() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Builder<ByteBuffer> builder = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR);
-                try (Env<ByteBuffer> ignored = builder.open(file)) {
-                  builder.setMaxDbs(1);
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Builder<ByteBuffer> builder =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR);
+                    try (Env<ByteBuffer> ignored = builder.open(file)) {
+                      builder.setMaxDbs(1);
+                    }
+                  });
+            })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotChangeMaxReadersAfterOpen() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Builder<ByteBuffer> builder = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR);
-                try (Env<ByteBuffer> ignored = builder.open(file)) {
-                  builder.setMaxReaders(1);
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Builder<ByteBuffer> builder =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR);
+                    try (Env<ByteBuffer> ignored = builder.open(file)) {
+                      builder.setMaxReaders(1);
+                    }
+                  });
+            })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotInfoOnceClosed() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Env<ByteBuffer> env = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR)
-                    .open(file);
-                env.close();
-                env.info();
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Env<ByteBuffer> env =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file);
+                    env.close();
+                    env.info();
+                  });
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void cannotOpenTwice() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Builder<ByteBuffer> builder = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR);
-                builder.open(file).close();
-                //noinspection resource // This will fail to open
-                builder.open(file);
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Builder<ByteBuffer> builder =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR);
+                    builder.open(file).close();
+                    //noinspection resource // This will fail to open
+                    builder.open(file);
+                  });
+            })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotOverflowMapSize() {
     assertThatThrownBy(
-        () -> {
-          final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
-          final int mb = 1_024 * 1_024;
-          //noinspection NumericOverflow // Intentional overflow
-          final int size = mb * 2_048; // as per issue 18
-          builder.setMapSize(size);
-        })
+            () -> {
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              final int mb = 1_024 * 1_024;
+              //noinspection NumericOverflow // Intentional overflow
+              final int size = mb * 2_048; // as per issue 18
+              builder.setMapSize(size);
+            })
         .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
   void negativeMapSize() {
     assertThatThrownBy(
-        () -> {
-          final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
-          builder.setMapSize(-1);
-        })
+            () -> {
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              builder.setMapSize(-1);
+            })
         .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
   void cannotStatOnceClosed() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Env<ByteBuffer> env = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR)
-                    .open(file);
-                env.close();
-                env.stat();
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Env<ByteBuffer> env =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file);
+                    env.close();
+                    env.stat();
+                  });
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void cannotSyncOnceClosed() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Env<ByteBuffer> env = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR)
-                    .open(file);
-                env.close();
-                env.sync(false);
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Env<ByteBuffer> env =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file);
+                    env.close();
+                    env.sync(false);
+                  });
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
@@ -224,66 +213,64 @@ void copyDirectoryBased() {
   @Test
   void copyDirectoryRejectsFileDestination() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempDir(
-              dest -> {
-                FileUtil.deleteDir(dest);
-                FileUtil.useTempDir(
-                    src -> {
-                      try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
-                        env.copy(dest.toFile(), MDB_CP_COMPACT);
-                      }
-                    });
-              });
-        })
+            () -> {
+              FileUtil.useTempDir(
+                  dest -> {
+                    FileUtil.deleteDir(dest);
+                    FileUtil.useTempDir(
+                        src -> {
+                          try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
+                            env.copy(dest.toFile(), MDB_CP_COMPACT);
+                          }
+                        });
+                  });
+            })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
   void copyDirectoryRejectsMissingDestination() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempDir(
-              dest -> {
-                try {
-                  Files.delete(dest);
-                  FileUtil.useTempDir(
-                      src -> {
-                        try (Env<ByteBuffer> env =
-                                 Env.create().setMaxReaders(1).open(src)) {
-                          env.copy(dest.toFile(), MDB_CP_COMPACT);
-                        }
-                      });
-                } catch (final IOException e) {
-                  throw new UncheckedIOException(e);
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempDir(
+                  dest -> {
+                    try {
+                      Files.delete(dest);
+                      FileUtil.useTempDir(
+                          src -> {
+                            try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
+                              env.copy(dest.toFile(), MDB_CP_COMPACT);
+                            }
+                          });
+                    } catch (final IOException e) {
+                      throw new UncheckedIOException(e);
+                    }
+                  });
+            })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
   void copyDirectoryRejectsNonEmptyDestination() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempDir(
-              dest -> {
-                try {
-                  final Path subDir = dest.resolve("hello");
-                  Files.createDirectory(subDir);
-                  assertThat(Files.isDirectory(subDir)).isTrue();
-                  FileUtil.useTempDir(
-                      src -> {
-                        try (Env<ByteBuffer> env =
-                                 Env.create().setMaxReaders(1).open(src)) {
-                          env.copy(dest.toFile(), MDB_CP_COMPACT);
-                        }
-                      });
-                } catch (final IOException e) {
-                  throw new UncheckedIOException(e);
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempDir(
+                  dest -> {
+                    try {
+                      final Path subDir = dest.resolve("hello");
+                      Files.createDirectory(subDir);
+                      assertThat(Files.isDirectory(subDir)).isTrue();
+                      FileUtil.useTempDir(
+                          src -> {
+                            try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
+                              env.copy(dest.toFile(), MDB_CP_COMPACT);
+                            }
+                          });
+                    } catch (final IOException e) {
+                      throw new UncheckedIOException(e);
+                    }
+                  });
+            })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
@@ -296,7 +283,7 @@ void copyFileBased() {
           FileUtil.useTempFile(
               src -> {
                 try (Env<ByteBuffer> env =
-                         Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
+                    Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
                   env.copy(dest.toFile(), MDB_CP_COMPACT);
                 }
                 assertThat(FileUtil.size(dest)).isGreaterThan(0L);
@@ -307,19 +294,19 @@ void copyFileBased() {
   @Test
   void copyFileRejectsExistingDestination() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              dest -> {
-                assertThat(Files.exists(dest)).isTrue();
-                FileUtil.useTempFile(
-                    src -> {
-                      try (Env<ByteBuffer> env =
-                               Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
-                        env.copy(dest.toFile(), MDB_CP_COMPACT);
-                      }
-                    });
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  dest -> {
+                    assertThat(Files.exists(dest)).isTrue();
+                    FileUtil.useTempFile(
+                        src -> {
+                          try (Env<ByteBuffer> env =
+                              Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
+                            env.copy(dest.toFile(), MDB_CP_COMPACT);
+                          }
+                        });
+                  });
+            })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
@@ -340,12 +327,13 @@ void createAsDirectory() {
   void createAsFile() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env = Env.create()
-              .setMapSize(1, ByteUnit.MEBIBYTES)
-              .setMaxDbs(1)
-              .setMaxReaders(1)
-              .setEnvFlags(MDB_NOSUBDIR)
-              .open(file)) {
+          try (Env<ByteBuffer> env =
+              Env.create()
+                  .setMapSize(1, ByteUnit.MEBIBYTES)
+                  .setMaxDbs(1)
+                  .setMaxReaders(1)
+                  .setEnvFlags(MDB_NOSUBDIR)
+                  .open(file)) {
             env.sync(true);
             assertThat(Files.isRegularFile(file)).isTrue();
           }
@@ -355,16 +343,16 @@ void createAsFile() {
   @Test
   void detectTransactionThreadViolation() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                try (Env<ByteBuffer> env =
-                         Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file)) {
-                  env.txnRead();
-                  env.txnRead();
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    try (Env<ByteBuffer> env =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file)) {
+                      env.txnRead();
+                      env.txnRead();
+                    }
+                  });
+            })
         .isInstanceOf(BadReaderLockException.class);
   }
 
@@ -372,11 +360,12 @@ void detectTransactionThreadViolation() {
   void info() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env = Env.create()
-              .setMaxReaders(4)
-              .setMapSize(123_456)
-              .setEnvFlags(MDB_NOSUBDIR)
-              .open(file)) {
+          try (Env<ByteBuffer> env =
+              Env.create()
+                  .setMaxReaders(4)
+                  .setMapSize(123_456)
+                  .setEnvFlags(MDB_NOSUBDIR)
+                  .open(file)) {
             final EnvInfo info = env.info();
             assertThat(info).isNotNull();
             assertThat(info.lastPageNumber).isEqualTo(1L);
@@ -394,31 +383,31 @@ void info() {
   @Test
   void mapFull() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempDir(
-              dir -> {
-                final byte[] k = new byte[500];
-                final ByteBuffer key = allocateDirect(500);
-                final ByteBuffer val = allocateDirect(1_024);
-                final Random rnd = new Random();
-                try (Env<ByteBuffer> env =
-                         Env.create()
-                             .setMaxReaders(1)
-                             .setMapSize(8, ByteUnit.MEBIBYTES)
-                             .setMaxDbs(1)
-                             .open(dir)) {
-                  final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-                  //noinspection InfiniteLoopStatement // Needs infinite loop to fill the env
-                  for (; ; ) {
-                    rnd.nextBytes(k);
-                    key.clear();
-                    key.put(k).flip();
-                    val.clear();
-                    db.put(key, val);
-                  }
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempDir(
+                  dir -> {
+                    final byte[] k = new byte[500];
+                    final ByteBuffer key = allocateDirect(500);
+                    final ByteBuffer val = allocateDirect(1_024);
+                    final Random rnd = new Random();
+                    try (Env<ByteBuffer> env =
+                        Env.create()
+                            .setMaxReaders(1)
+                            .setMapSize(8, ByteUnit.MEBIBYTES)
+                            .setMaxDbs(1)
+                            .open(dir)) {
+                      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                      //noinspection InfiniteLoopStatement // Needs infinite loop to fill the env
+                      for (; ; ) {
+                        rnd.nextBytes(k);
+                        key.clear();
+                        key.put(k).flip();
+                        val.clear();
+                        db.put(key, val);
+                      }
+                    }
+                  });
+            })
         .isInstanceOf(MapFullException.class);
   }
 
@@ -426,16 +415,12 @@ void mapFull() {
   void readOnlySupported() {
     FileUtil.useTempDir(
         dir -> {
-          try (Env<ByteBuffer> rwEnv = Env.create()
-              .setMaxReaders(1)
-              .open(dir)) {
+          try (Env<ByteBuffer> rwEnv = Env.create().setMaxReaders(1).open(dir)) {
             final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
             rwDb.put(bb(1), bb(42));
           }
-          try (Env<ByteBuffer> roEnv = Env.create()
-              .setMaxReaders(1)
-              .setEnvFlags(MDB_RDONLY_ENV)
-              .open(dir)) {
+          try (Env<ByteBuffer> roEnv =
+              Env.create().setMaxReaders(1).setEnvFlags(MDB_RDONLY_ENV).open(dir)) {
             final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1, DbiFlagSet.EMPTY);
             try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
               assertThat(roDb.get(roTxn, bb(1))).isNotNull();
@@ -452,11 +437,12 @@ void setMapSize() {
           final ByteBuffer key = allocateDirect(500);
           final ByteBuffer val = allocateDirect(1_024);
           final Random rnd = new Random();
-          try (Env<ByteBuffer> env = Env.create()
-              .setMaxReaders(1)
-              .setMapSize(256, ByteUnit.KIBIBYTES)
-              .setMaxDbs(1)
-              .open(dir)) {
+          try (Env<ByteBuffer> env =
+              Env.create()
+                  .setMaxReaders(1)
+                  .setMapSize(256, ByteUnit.KIBIBYTES)
+                  .setMaxDbs(1)
+                  .open(dir)) {
             final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
             db.put(bb(1), bb(42));
@@ -474,9 +460,11 @@ void setMapSize() {
             }
             assertThat(mapFullExThrown).isTrue();
 
-            assertThatThrownBy(() -> {
-              env.setMapSize(-1, ByteUnit.KIBIBYTES);
-            }).isInstanceOf(IllegalArgumentException.class);
+            assertThatThrownBy(
+                    () -> {
+                      env.setMapSize(-1, ByteUnit.KIBIBYTES);
+                    })
+                .isInstanceOf(IllegalArgumentException.class);
 
             env.setMapSize(1024, ByteUnit.KIBIBYTES);
 
@@ -507,10 +495,8 @@ void setMapSize() {
   void stats() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env = Env.create()
-              .setMaxReaders(1)
-              .setEnvFlags(MDB_NOSUBDIR)
-              .open(file)) {
+          try (Env<ByteBuffer> env =
+              Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file)) {
             final Stat stat = env.stat();
             assertThat(stat).isNotNull();
             assertThat(stat.branchPages).isEqualTo(0L);
@@ -550,10 +536,8 @@ void testDefaultOpenNoName1() {
 
             // As this is the unnamed database it returns all keys in the unnamed db
             final List<byte[]> dbiNames = env.getDbiNames();
-            assertThat(dbiNames)
-                .hasSize(2);
-            assertThat(dbiNames.get(0))
-                .isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
+            assertThat(dbiNames).hasSize(2);
+            assertThat(dbiNames.get(0)).isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
           }
         });
   }
@@ -569,10 +553,8 @@ void testDefaultOpenNoName2() {
 
             // As this is the unnamed database it returns all keys in the unnamed db
             final List<byte[]> dbiNames = env.getDbiNames();
-            assertThat(dbiNames)
-                .hasSize(1);
-            assertThat(dbiNames.get(0))
-                .isEqualTo(new byte[0]);
+            assertThat(dbiNames).hasSize(1);
+            assertThat(dbiNames.get(0)).isEqualTo(new byte[0]);
           }
         });
   }
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index 21ef5182..71523c66 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -37,10 +37,7 @@ public class GarbageCollectionTest {
   void buffersNotGarbageCollectedTest() {
     FileUtil.useTempDir(
         dir -> {
-          try (Env<ByteBuffer> env = create()
-              .setMapSize(2_085_760_999)
-              .setMaxDbs(1)
-              .open(dir)) {
+          try (Env<ByteBuffer> env = create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir)) {
             final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
             try (Txn<ByteBuffer> txn = env.txnWrite()) {
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 9991b870..bc1a24e0 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -28,8 +28,7 @@ public class PutFlagSetTest extends AbstractFlagSetTest<PutFlags, PutFlagSet> {
 
   @Override
   List<PutFlags> getAllFlags() {
-    return Arrays.stream(PutFlags.values())
-        .collect(Collectors.toList());
+    return Arrays.stream(PutFlags.values()).collect(Collectors.toList());
   }
 
   @Override
@@ -67,10 +66,14 @@ public void testAddFlagVsCheckPresence() {
 
     final int cnt = 10_000_000;
     final int[] arr = new int[cnt];
-    final List<PutFlagSet> flagSets = IntStream.range(0, cnt)
-        .boxed()
-        .map(i -> PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_NOOVERWRITE, PutFlags.MDB_RESERVE))
-        .collect(Collectors.toList());
+    final List<PutFlagSet> flagSets =
+        IntStream.range(0, cnt)
+            .boxed()
+            .map(
+                i ->
+                    PutFlagSet.of(
+                        PutFlags.MDB_APPEND, PutFlags.MDB_NOOVERWRITE, PutFlags.MDB_RESERVE))
+            .collect(Collectors.toList());
 
     Instant time;
     for (int i = 0; i < 5; i++) {
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 68d988d1..2545fecf 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -69,29 +69,25 @@ static ByteBuffer bb(final String value) {
   }
 
   static ByteBuffer bbNative(final int value) {
-    final ByteBuffer bb = allocateDirect(Integer.BYTES)
-        .order(ByteOrder.nativeOrder());
+    final ByteBuffer bb = allocateDirect(Integer.BYTES).order(ByteOrder.nativeOrder());
     bb.putInt(value).flip();
     return bb;
   }
 
   static ByteBuffer bbNative(final long value) {
-    final ByteBuffer bb = allocateDirect(Long.BYTES)
-        .order(ByteOrder.nativeOrder());
+    final ByteBuffer bb = allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
     bb.putLong(value).flip();
     return bb;
   }
 
   static int getNativeInt(final ByteBuffer bb) {
-    final int val = bb.order(ByteOrder.nativeOrder())
-        .getInt();
+    final int val = bb.order(ByteOrder.nativeOrder()).getInt();
     bb.rewind();
     return val;
   }
 
   static long getNativeLong(final ByteBuffer bb) {
-    final long val = bb.order(ByteOrder.nativeOrder())
-        .getLong();
+    final long val = bb.order(ByteOrder.nativeOrder()).getLong();
     bb.rewind();
     return val;
   }
@@ -105,8 +101,7 @@ static long getNativeIntOrLong(final ByteBuffer bb) {
   }
 
   static String getString(final ByteBuffer bb) {
-    final String str = StandardCharsets.UTF_8.decode(bb)
-        .toString();
+    final String str = StandardCharsets.UTF_8.decode(bb).toString();
     bb.rewind();
     return str;
   }
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 93c4a031..5b875edf 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -55,9 +55,7 @@ public final class TutorialTest {
 
   private static final String DB_NAME = "my DB";
 
-  /**
-   * In this first tutorial we will use LmdbJava with some basic defaults.
-   */
+  /** In this first tutorial we will use LmdbJava with some basic defaults. */
   @Test
   void tutorial1() {
     // We need a storage directory first.
@@ -67,15 +65,16 @@ void tutorial1() {
 
           // We always need an Env. An Env owns a physical on-disk storage file. One
           // Env can store many different databases (ie sorted maps).
-          final Env<ByteBuffer> env = Env.create()
-              // LMDB also needs to know how large our DB might be. Over-estimating is OK.
-              .setMapSize(10_485_760)
-              // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
-              .setMaxDbs(1)
-              // Now let's open the Env. The same path can be concurrently opened and
-              // used in different processes, but do not open the same path twice in
-              // the same process at the same time.
-              .open(dir);
+          final Env<ByteBuffer> env =
+              Env.create()
+                  // LMDB also needs to know how large our DB might be. Over-estimating is OK.
+                  .setMapSize(10_485_760)
+                  // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
+                  .setMaxDbs(1)
+                  // Now let's open the Env. The same path can be concurrently opened and
+                  // used in different processes, but do not open the same path twice in
+                  // the same process at the same time.
+                  .open(dir);
 
           // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
           // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
@@ -124,9 +123,7 @@ void tutorial1() {
         });
   }
 
-  /**
-   * In this second tutorial we'll learn more about LMDB's ACID Txns.
-   */
+  /** In this second tutorial we'll learn more about LMDB's ACID Txns. */
   @Test
   void tutorial2() {
     FileUtil.useTempDir(
@@ -337,9 +334,7 @@ void tutorial4() {
         });
   }
 
-  /**
-   * In this fifth tutorial we'll explore multiple values sharing a single key.
-   */
+  /** In this fifth tutorial we'll explore multiple values sharing a single key. */
   @Test
   void tutorial5() {
     FileUtil.useTempDir(
@@ -399,7 +394,8 @@ void tutorial6() {
     FileUtil.useTempDir(
         dir -> {
           // Note we need to specify the Verifier's DBI_COUNT for the Env.
-          final Env<ByteBuffer> env = Env.create(PROXY_OPTIMAL)
+          final Env<ByteBuffer> env =
+              Env.create(PROXY_OPTIMAL)
                   .setMapSize(10_485_760)
                   .setMaxDbs(Verifier.DBI_COUNT)
                   .open(dir);
@@ -415,9 +411,7 @@ void tutorial6() {
         });
   }
 
-  /**
-   * In this final tutorial we'll look at using Agrona's DirectBuffer.
-   */
+  /** In this final tutorial we'll look at using Agrona's DirectBuffer. */
   @Test
   void tutorial7() {
     FileUtil.useTempDir(
@@ -425,10 +419,8 @@ void tutorial7() {
           // The critical difference is we pass the PROXY_DB field to Env.create().
           // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
           // Aside from that and a different type argument, it's the same as usual...
-          final Env<DirectBuffer> env = Env.create(PROXY_DB)
-              .setMapSize(10_485_760)
-              .setMaxDbs(1)
-              .open(dir);
+          final Env<DirectBuffer> env =
+              Env.create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir);
 
           final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
@@ -485,10 +477,6 @@ void tutorial7() {
   // or reverse ordered keys, using Env.DISABLE_CHECKS_PROP etc), but you now
   // know enough to tackle the JavaDocs with confidence. Have fun!
   private Env<ByteBuffer> createSimpleEnv(final Path path) {
-    return Env.create()
-        .setMapSize(10_485_760)
-        .setMaxDbs(1)
-        .setMaxReaders(1)
-        .open(path);
+    return Env.create().setMapSize(10_485_760).setMaxDbs(1).setMaxReaders(1).open(path);
   }
 }
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 87455cb7..4cf1e879 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -24,8 +24,7 @@ public class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
 
   @Override
   List<TxnFlags> getAllFlags() {
-    return Arrays.stream(TxnFlags.values())
-        .collect(Collectors.toList());
+    return Arrays.stream(TxnFlags.values()).collect(Collectors.toList());
   }
 
   @Override
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index ba8e55d3..157ba94d 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -125,10 +125,8 @@ void rangeSearch() {
   @Test
   void readOnlyTxnAllowedInReadOnlyEnv() {
     env.openDbi(DB_1, MDB_CREATE);
-    try (Env<ByteBuffer> roEnv = create()
-        .setMaxReaders(1)
-        .setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV)
-        .open(file)) {
+    try (Env<ByteBuffer> roEnv =
+        create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV).open(file)) {
       assertThat(roEnv.txnRead()).isNotNull();
     }
   }
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 75812e18..7f6b3dff 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -24,21 +24,20 @@
 import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.Test;
 
-/**
- * Test {@link Verifier}.
- */
+/** Test {@link Verifier}. */
 public final class VerifierTest {
 
   @Test
   void verification() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env = create()
-              .setMaxReaders(1)
-              .setMaxDbs(Verifier.DBI_COUNT)
-              .setMapSize(10, ByteUnit.MEBIBYTES)
-              .setEnvFlags(MDB_NOSUBDIR)
-              .open(file)) {
+          try (Env<ByteBuffer> env =
+              create()
+                  .setMaxReaders(1)
+                  .setMaxDbs(Verifier.DBI_COUNT)
+                  .setMapSize(10, ByteUnit.MEBIBYTES)
+                  .setEnvFlags(MDB_NOSUBDIR)
+                  .open(file)) {
             final Verifier v = new Verifier(env);
             final int seconds = Integer.getInteger("verificationSeconds", 2);
             assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);

From cf3a11e0a3a201f3b49f3163ff8ca53fb61d40b8 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 10:13:08 +0000
Subject: [PATCH 45/90] Remove class separators

---
 src/main/java/org/lmdbjava/AbstractFlagSet.java       |  9 +++------
 src/main/java/org/lmdbjava/ByteBufferProxy.java       |  9 +++------
 src/main/java/org/lmdbjava/CopyFlagSet.java           |  6 ++----
 src/main/java/org/lmdbjava/CursorIterable.java        |  6 ++----
 src/main/java/org/lmdbjava/DbiBuilder.java            | 11 +++--------
 src/main/java/org/lmdbjava/DbiFlagSet.java            |  6 ++----
 src/main/java/org/lmdbjava/Env.java                   |  3 +--
 src/main/java/org/lmdbjava/EnvFlagSet.java            |  6 ++----
 src/main/java/org/lmdbjava/PutFlagSet.java            |  6 ++----
 src/main/java/org/lmdbjava/TxnFlagSet.java            |  9 +++------
 .../java/org/lmdbjava/ComparatorIntegerKeyTest.java   |  9 +++------
 .../org/lmdbjava/CursorIterableIntegerDupTest.java    |  6 ++----
 .../org/lmdbjava/CursorIterableIntegerKeyTest.java    |  6 ++----
 src/test/java/org/lmdbjava/CursorIterableTest.java    |  6 ++----
 14 files changed, 32 insertions(+), 66 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index fbaa4c6f..673dac08 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -100,8 +100,7 @@ public String toString() {
     return FlagSet.asString(this);
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   abstract static class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag>
       implements FlagSet<T> {
 
@@ -182,8 +181,7 @@ private Set<T> initSet() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   static class AbstractEmptyFlagSet<T extends MaskedFlag> implements FlagSet<T> {
 
     @Override
@@ -237,8 +235,7 @@ public int hashCode() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * A builder for creating a {@link AbstractFlagSet}.
    *
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 52bfc924..7272206a 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -86,8 +86,7 @@ public BufferMustBeDirectException() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -246,8 +245,7 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -292,8 +290,7 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index 1aed9878..663a367d 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -45,8 +45,7 @@ static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
         CopyFlags.class, CopyFlagSetImpl::new, copyFlag -> copyFlag, () -> CopyFlagSetImpl.EMPTY);
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
 
     static final CopyFlagSet EMPTY = new EmptyCopyFlagSet();
@@ -56,8 +55,7 @@ private CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
       implements CopyFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 2289f130..f5ec4fc0 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -239,8 +239,7 @@ enum State {
     TERMINATED
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   static class JavaRangeComparator<T> implements RangeComparator {
 
     private final Comparator<T> comparator;
@@ -274,8 +273,7 @@ public void close() throws Exception {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order. Has a
    * very slight overhead as compared to {@link JavaRangeComparator}.
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index d5d1af8c..c8dacd08 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -82,8 +82,6 @@ public DbiBuilderStage2<T> withoutDbName() {
     return setDbName((byte[]) null);
   }
 
-  // --------------------------------------------------------------------------------
-
   /**
    * Intermediate builder stage for constructing a {@link Dbi}.
    *
@@ -209,8 +207,7 @@ public DbiBuilderStage3<T> withIteratorComparator(
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * Final stage builder for constructing a {@link Dbi}.
    *
@@ -394,8 +391,7 @@ private Dbi<T> openDbi(final Txn<T> txn, final DbiBuilder<T> dbiBuilder) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   private enum ComparatorType {
     /**
      * Default Java comparator for {@link CursorIterable} KeyRange testing, LMDB comparator for
@@ -414,8 +410,7 @@ private enum ComparatorType {
     ;
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   @FunctionalInterface
   public interface ComparatorFactory<T> {
 
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 6f2d3c81..0452f068 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -49,8 +49,7 @@ static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
         DbiFlags.class, DbiFlagSetImpl::new, dbiFlag -> dbiFlag, () -> DbiFlagSetImpl.EMPTY);
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
 
     static final DbiFlagSet EMPTY = new EmptyDbiFlagSet();
@@ -60,8 +59,7 @@ private DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
       implements DbiFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 54115b33..370fbc8c 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -633,8 +633,7 @@ public AlreadyOpenException() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * Builder for configuring and opening Env.
    *
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index 771f5e2c..e0c4d21c 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -45,8 +45,7 @@ static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
         EnvFlags.class, EnvFlagSetImpl::new, envFlag -> envFlag, () -> EnvFlagSetImpl.EMPTY);
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
 
     static final EnvFlagSet EMPTY = new EmptyEnvFlagSet();
@@ -56,8 +55,7 @@ private EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
       implements EnvFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index ee2a9826..ee2855a6 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -45,8 +45,7 @@ static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
         PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, EmptyPutFlagSet::new);
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
 
     public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
@@ -56,8 +55,7 @@ private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
       implements PutFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index 1fa34d32..c15ebec1 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -45,8 +45,7 @@ static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
         TxnFlags.class, TxnFlagSetImpl::new, SingleTxnFlagSet::new, () -> TxnFlagSetImpl.EMPTY);
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
 
     static final TxnFlagSet EMPTY = new EmptyTxnFlagSet();
@@ -56,8 +55,7 @@ private TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
       implements TxnFlagSet {
 
@@ -66,8 +64,7 @@ class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
       implements TxnFlagSet {}
 }
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
index 00c0ce28..e35d7d27 100644
--- a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -185,8 +185,7 @@ void testRandomInt(final ComparatorRunner runner) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /** Tests {@link ByteBufferProxy}. */
   private static final class ByteBufferRunner implements ComparatorRunner {
 
@@ -260,8 +259,7 @@ private ByteBuffer intToBuffer(final int val, final int bufferCapacity) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /** Tests {@link DirectBufferProxy}. */
   private static final class DirectBufferRunner implements ComparatorRunner {
     private static final Comparator<DirectBuffer> COMPARATOR =
@@ -331,8 +329,7 @@ public int compare(int int1, int int2) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
   private interface ComparatorRunner {
 
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 7a2515b2..da0b86f2 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -511,8 +511,7 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -528,8 +527,7 @@ public String toString() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index c35767c0..509b5bbb 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -579,8 +579,7 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -596,8 +595,7 @@ public String toString() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 7c1aa227..75358b56 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -500,8 +500,7 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -517,8 +516,7 @@ public String toString() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override

From 0c97cf469952ee263b3b1d7b85fcd6f3320ccabc Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 10:14:02 +0000
Subject: [PATCH 46/90] Run format plugin

---
 src/main/java/org/lmdbjava/AbstractFlagSet.java              | 3 ---
 src/main/java/org/lmdbjava/ByteBufferProxy.java              | 3 ---
 src/main/java/org/lmdbjava/CopyFlagSet.java                  | 2 --
 src/main/java/org/lmdbjava/CursorIterable.java               | 2 --
 src/main/java/org/lmdbjava/DbiBuilder.java                   | 3 ---
 src/main/java/org/lmdbjava/DbiFlagSet.java                   | 2 --
 src/main/java/org/lmdbjava/Env.java                          | 1 -
 src/main/java/org/lmdbjava/EnvFlagSet.java                   | 2 --
 src/main/java/org/lmdbjava/PutFlagSet.java                   | 2 --
 src/main/java/org/lmdbjava/TxnFlagSet.java                   | 3 ---
 src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java     | 3 ---
 src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java | 2 --
 src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java | 2 --
 src/test/java/org/lmdbjava/CursorIterableTest.java           | 2 --
 14 files changed, 32 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 673dac08..655369e1 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -100,7 +100,6 @@ public String toString() {
     return FlagSet.asString(this);
   }
 
-  
   abstract static class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag>
       implements FlagSet<T> {
 
@@ -181,7 +180,6 @@ private Set<T> initSet() {
     }
   }
 
-  
   static class AbstractEmptyFlagSet<T extends MaskedFlag> implements FlagSet<T> {
 
     @Override
@@ -235,7 +233,6 @@ public int hashCode() {
     }
   }
 
-  
   /**
    * A builder for creating a {@link AbstractFlagSet}.
    *
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 7272206a..25218fe4 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -86,7 +86,6 @@ public BufferMustBeDirectException() {
     }
   }
 
-  
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -245,7 +244,6 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
-  
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -290,7 +288,6 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
-  
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index 663a367d..cea2fce9 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -45,7 +45,6 @@ static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
         CopyFlags.class, CopyFlagSetImpl::new, copyFlag -> copyFlag, () -> CopyFlagSetImpl.EMPTY);
   }
 
-  
   class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
 
     static final CopyFlagSet EMPTY = new EmptyCopyFlagSet();
@@ -55,7 +54,6 @@ private CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
     }
   }
 
-  
   class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
       implements CopyFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index f5ec4fc0..fe379151 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -239,7 +239,6 @@ enum State {
     TERMINATED
   }
 
-  
   static class JavaRangeComparator<T> implements RangeComparator {
 
     private final Comparator<T> comparator;
@@ -273,7 +272,6 @@ public void close() throws Exception {
     }
   }
 
-  
   /**
    * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order. Has a
    * very slight overhead as compared to {@link JavaRangeComparator}.
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index c8dacd08..450fb3c7 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -207,7 +207,6 @@ public DbiBuilderStage3<T> withIteratorComparator(
     }
   }
 
-  
   /**
    * Final stage builder for constructing a {@link Dbi}.
    *
@@ -391,7 +390,6 @@ private Dbi<T> openDbi(final Txn<T> txn, final DbiBuilder<T> dbiBuilder) {
     }
   }
 
-  
   private enum ComparatorType {
     /**
      * Default Java comparator for {@link CursorIterable} KeyRange testing, LMDB comparator for
@@ -410,7 +408,6 @@ private enum ComparatorType {
     ;
   }
 
-  
   @FunctionalInterface
   public interface ComparatorFactory<T> {
 
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 0452f068..d0b13793 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -49,7 +49,6 @@ static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
         DbiFlags.class, DbiFlagSetImpl::new, dbiFlag -> dbiFlag, () -> DbiFlagSetImpl.EMPTY);
   }
 
-  
   class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
 
     static final DbiFlagSet EMPTY = new EmptyDbiFlagSet();
@@ -59,7 +58,6 @@ private DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
     }
   }
 
-  
   class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
       implements DbiFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 370fbc8c..8fa9e901 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -633,7 +633,6 @@ public AlreadyOpenException() {
     }
   }
 
-  
   /**
    * Builder for configuring and opening Env.
    *
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index e0c4d21c..4ce5eadc 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -45,7 +45,6 @@ static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
         EnvFlags.class, EnvFlagSetImpl::new, envFlag -> envFlag, () -> EnvFlagSetImpl.EMPTY);
   }
 
-  
   class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
 
     static final EnvFlagSet EMPTY = new EmptyEnvFlagSet();
@@ -55,7 +54,6 @@ private EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
     }
   }
 
-  
   class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
       implements EnvFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index ee2855a6..8c587138 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -45,7 +45,6 @@ static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
         PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, EmptyPutFlagSet::new);
   }
 
-  
   class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
 
     public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
@@ -55,7 +54,6 @@ private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
     }
   }
 
-  
   class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
       implements PutFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index c15ebec1..4bfdf2e3 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -45,7 +45,6 @@ static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
         TxnFlags.class, TxnFlagSetImpl::new, SingleTxnFlagSet::new, () -> TxnFlagSetImpl.EMPTY);
   }
 
-  
   class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
 
     static final TxnFlagSet EMPTY = new EmptyTxnFlagSet();
@@ -55,7 +54,6 @@ private TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
     }
   }
 
-  
   class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
       implements TxnFlagSet {
 
@@ -64,7 +62,6 @@ class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
     }
   }
 
-  
   class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
       implements TxnFlagSet {}
 }
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
index e35d7d27..dbe00fa0 100644
--- a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -185,7 +185,6 @@ void testRandomInt(final ComparatorRunner runner) {
     }
   }
 
-  
   /** Tests {@link ByteBufferProxy}. */
   private static final class ByteBufferRunner implements ComparatorRunner {
 
@@ -259,7 +258,6 @@ private ByteBuffer intToBuffer(final int val, final int bufferCapacity) {
     }
   }
 
-  
   /** Tests {@link DirectBufferProxy}. */
   private static final class DirectBufferRunner implements ComparatorRunner {
     private static final Comparator<DirectBuffer> COMPARATOR =
@@ -329,7 +327,6 @@ public int compare(int int1, int int2) {
     }
   }
 
-  
   /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
   private interface ComparatorRunner {
 
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index da0b86f2..703865d0 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -511,7 +511,6 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-  
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -527,7 +526,6 @@ public String toString() {
     }
   }
 
-  
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 509b5bbb..6baa1907 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -579,7 +579,6 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-  
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -595,7 +594,6 @@ public String toString() {
     }
   }
 
-  
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 75358b56..c853a8ab 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -500,7 +500,6 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-  
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -516,7 +515,6 @@ public String toString() {
     }
   }
 
-  
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override

From 72d4e3f40f9e734986a7f6e97caca341f7fefdae Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 11:24:42 +0000
Subject: [PATCH 47/90] Remove binaries accidentally added, fix test

---
 .../org/lmdbjava/aarch64-linux-gnu.so          | Bin 302728 -> 0 bytes
 .../org/lmdbjava/aarch64-macos-none.so         | Bin 135224 -> 0 bytes
 .../resources/org/lmdbjava/x86_64-linux-gnu.so | Bin 308688 -> 0 bytes
 .../org/lmdbjava/x86_64-macos-none.so          | Bin 100150 -> 0 bytes
 .../org/lmdbjava/x86_64-windows-gnu.dll        | Bin 260096 -> 0 bytes
 src/test/java/org/lmdbjava/EnvTest.java        |   8 ++++++--
 6 files changed, 6 insertions(+), 2 deletions(-)
 delete mode 100755 src/main/resources/org/lmdbjava/aarch64-linux-gnu.so
 delete mode 100755 src/main/resources/org/lmdbjava/aarch64-macos-none.so
 delete mode 100755 src/main/resources/org/lmdbjava/x86_64-linux-gnu.so
 delete mode 100755 src/main/resources/org/lmdbjava/x86_64-macos-none.so
 delete mode 100755 src/main/resources/org/lmdbjava/x86_64-windows-gnu.dll

diff --git a/src/main/resources/org/lmdbjava/aarch64-linux-gnu.so b/src/main/resources/org/lmdbjava/aarch64-linux-gnu.so
deleted file mode 100755
index 7e911756099eb50521ad1767c0974d8313f614f5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 302728
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

diff --git a/src/main/resources/org/lmdbjava/aarch64-macos-none.so b/src/main/resources/org/lmdbjava/aarch64-macos-none.so
deleted file mode 100755
index 99858e49fc1eb11b561128aee6efbe7a944796b1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 135224
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
GLFzw?Mkv4l

diff --git a/src/main/resources/org/lmdbjava/x86_64-linux-gnu.so b/src/main/resources/org/lmdbjava/x86_64-linux-gnu.so
deleted file mode 100755
index ee2e17bf647c7f90c7c7d4f9f7d79f8fcb8da64c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 308688
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
G|9=4X8?l)H

diff --git a/src/main/resources/org/lmdbjava/x86_64-macos-none.so b/src/main/resources/org/lmdbjava/x86_64-macos-none.so
deleted file mode 100755
index dfceffe6966fe34917667e541759522100fce1ab..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 100150
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
KZG*E#P5d7NyZXTZ

diff --git a/src/main/resources/org/lmdbjava/x86_64-windows-gnu.dll b/src/main/resources/org/lmdbjava/x86_64-windows-gnu.dll
deleted file mode 100755
index 05e7b2c1149d829f2c5d94ba1124ef83428020a1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 260096
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%0AtMSHeh0
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%0AE`$1*$`K+)v{&D6#OlpG6l89AIh5}8l{%=vi3aw
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

diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index ab7c02ca..c9434d63 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -538,6 +538,7 @@ void testDefaultOpenNoName1() {
             final List<byte[]> dbiNames = env.getDbiNames();
             assertThat(dbiNames).hasSize(2);
             assertThat(dbiNames.get(0)).isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
+            assertThat(dbiNames.get(1)).isEqualTo("def".getBytes(Env.DEFAULT_NAME_CHARSET));
           }
         });
   }
@@ -550,11 +551,14 @@ void testDefaultOpenNoName2() {
             final EnvInfo info = env.info();
             assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
             final Dbi<ByteBuffer> db = env.openDbi((byte[]) null, MDB_CREATE);
+            db.put(bb("abc"), allocateDirect(1));
+            db.put(bb("def"), allocateDirect(1));
 
             // As this is the unnamed database it returns all keys in the unnamed db
             final List<byte[]> dbiNames = env.getDbiNames();
-            assertThat(dbiNames).hasSize(1);
-            assertThat(dbiNames.get(0)).isEqualTo(new byte[0]);
+            assertThat(dbiNames).hasSize(2);
+            assertThat(dbiNames.get(0)).isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
+            assertThat(dbiNames.get(1)).isEqualTo("def".getBytes(Env.DEFAULT_NAME_CHARSET));
           }
         });
   }

From 18013fb8bef56e3f9c2dc45e2ebc3b5e55ebdf02 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Fri, 7 Nov 2025 11:49:16 +0000
Subject: [PATCH 48/90] Merged new comparator code

---
 src/main/java/org/lmdbjava/Env.java           | 64 ++++++++++++++---
 .../java/org/lmdbjava/FileUtil.java           |  8 +--
 .../java/org/lmdbjava/CursorParamTest.java    |  4 +-
 src/test/java/org/lmdbjava/CursorTest.java    |  4 +-
 src/test/java/org/lmdbjava/DbiTest.java       |  9 ++-
 src/test/java/org/lmdbjava/EnvTest.java       | 69 +++++++++----------
 .../org/lmdbjava/GarbageCollectionTest.java   |  3 +-
 src/test/java/org/lmdbjava/TutorialTest.java  | 12 ++--
 src/test/java/org/lmdbjava/TxnTest.java       |  8 ++-
 src/test/java/org/lmdbjava/VerifierTest.java  |  3 +-
 10 files changed, 117 insertions(+), 67 deletions(-)
 rename src/{test => main}/java/org/lmdbjava/FileUtil.java (94%)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 480ee8b7..43a52d5b 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -29,6 +29,7 @@
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -147,7 +148,30 @@ public void close() {
    *
    * @param path writable destination path as described above
    */
+  @Deprecated // Use java.nio.Path
   public void copy(final File path) {
+    requireNonNull(path);
+    copy(path.toPath(), CopyFlagSet.EMPTY);
+  }
+
+  /**
+   * Copies an LMDB environment to the specified destination path.
+   *
+   * <p>This function may be used to make a backup of an existing environment. No lockfile is
+   * created, since it gets recreated at need.
+   *
+   * <p>If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the destination path
+   * must be a directory that exists but contains no files. If {@link EnvFlags#MDB_NOSUBDIR} was
+   * used, the destination path must not exist, but it must be possible to create a file at the
+   * provided path.
+   *
+   * <p>Note: This call can trigger significant file size growth if run in parallel with write
+   * transactions, because it employs a read-only transaction. See long-lived transactions under
+   * "Caveats" in the LMDB native documentation.
+   *
+   * @param path writable destination path as described above
+   */
+  public void copy(final Path path) {
     copy(path, CopyFlagSet.EMPTY);
   }
 
@@ -169,10 +193,34 @@ public void copy(final File path) {
    * @param path writable destination path as described above
    * @param flags special options for this copy
    */
+  @Deprecated // Use java.nio.Path
   public void copy(final File path, final CopyFlagSet flags) {
+    requireNonNull(path);
+    copy(path.toPath(), flags);
+  }
+
+  /**
+   * Copies an LMDB environment to the specified destination path.
+   *
+   * <p>This function may be used to make a backup of an existing environment. No lockfile is
+   * created, since it gets recreated at need.
+   *
+   * <p>If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the destination path
+   * must be a directory that exists but contains no files. If {@link EnvFlags#MDB_NOSUBDIR} was
+   * used, the destination path must not exist, but it must be possible to create a file at the
+   * provided path.
+   *
+   * <p>Note: This call can trigger significant file size growth if run in parallel with write
+   * transactions, because it employs a read-only transaction. See long-lived transactions under
+   * "Caveats" in the LMDB native documentation.
+   *
+   * @param path writable destination path as described above
+   * @param flags special options for this copy
+   */
+  public void copy(final Path path, final CopyFlagSet flags) {
     requireNonNull(path);
     validatePath(path);
-    checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flags.getMask()));
+    checkRc(LIB.mdb_env_copy2(ptr, path.toAbsolutePath().toString(), flags.getMask()));
   }
 
   /**
@@ -524,22 +572,22 @@ void checkNotClosed() {
     }
   }
 
-  private void validateDirectoryEmpty(final File path) {
-    if (!path.exists()) {
+  private void validateDirectoryEmpty(final Path path) {
+    if (!Files.exists(path)) {
       throw new InvalidCopyDestination("Path does not exist");
     }
-    if (!path.isDirectory()) {
+    if (!Files.isDirectory(path)) {
       throw new InvalidCopyDestination("Path must be a directory");
     }
-    final String[] files = path.list();
-    if (files != null && files.length > 0) {
+    final long fileCount = FileUtil.count(path);
+    if (fileCount > 0) {
       throw new InvalidCopyDestination("Path must contain no files");
     }
   }
 
-  private void validatePath(final File path) {
+  private void validatePath(final Path path) {
     if (noSubDir) {
-      if (path.exists()) {
+      if (Files.exists(path)) {
         throw new InvalidCopyDestination("Path must not exist for MDB_NOSUBDIR");
       }
       return;
diff --git a/src/test/java/org/lmdbjava/FileUtil.java b/src/main/java/org/lmdbjava/FileUtil.java
similarity index 94%
rename from src/test/java/org/lmdbjava/FileUtil.java
rename to src/main/java/org/lmdbjava/FileUtil.java
index cc7ed635..476f0436 100644
--- a/src/test/java/org/lmdbjava/FileUtil.java
+++ b/src/main/java/org/lmdbjava/FileUtil.java
@@ -31,7 +31,7 @@ final class FileUtil {
 
   private FileUtil() {}
 
-  public static long size(final Path path) {
+  static long size(final Path path) {
     try {
       return Files.size(path);
     } catch (final IOException e) {
@@ -39,7 +39,7 @@ public static long size(final Path path) {
     }
   }
 
-  public static void deleteFile(final Path path) {
+  static void deleteFile(final Path path) {
     try {
       Files.delete(path);
     } catch (final IOException e) {
@@ -47,7 +47,7 @@ public static void deleteFile(final Path path) {
     }
   }
 
-  public static void deleteDir(final Path path) {
+  static void deleteDir(final Path path) {
     if (path != null && Files.isDirectory(path)) {
       recursiveDelete(path);
       deleteIfExists(path);
@@ -102,7 +102,7 @@ private static void deleteIfExists(final Path path) {
     }
   }
 
-  public static long count(final Path path) {
+  static long count(final Path path) {
     try (final Stream<Path> stream = Files.list(path)) {
       return stream.count();
     } catch (final IOException e) {
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index e228e968..ed43bf5b 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -170,7 +170,9 @@ private Env<T> env(final Path tmp) {
           .setMapSize(MEBIBYTES.toBytes(1))
           .setMaxReaders(1)
           .setMaxDbs(1)
-          .open(tmp.resolve("db").toFile(), POSIX_MODE, MDB_NOSUBDIR);
+          .setFilePermissions(POSIX_MODE)
+          .setEnvFlags(MDB_NOSUBDIR)
+          .open(tmp.resolve("db"));
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 530b2e80..509f03dc 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -66,7 +66,9 @@ void beforeEach() {
             .setMapSize(MEBIBYTES.toBytes(1))
             .setMaxReaders(1)
             .setMaxDbs(1)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .setFilePermissions(POSIX_MODE)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
   }
 
   @AfterEach
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 632d51b5..fdf55d89 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -85,14 +85,16 @@ void beforeEach() {
             .setMapSize(MEBIBYTES.toBytes(64))
             .setMaxReaders(2)
             .setMaxDbs(2)
-            .open(file.toFile(), MDB_NOSUBDIR);
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
     final Path fileBa = tempDir.createTempFile();
     envBa =
         create(PROXY_BA)
             .setMapSize(MEBIBYTES.toBytes(64))
             .setMaxReaders(2)
             .setMaxDbs(2)
-            .open(fileBa.toFile(), MDB_NOSUBDIR);
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(fileBa);
   }
 
   @AfterEach
@@ -382,7 +384,8 @@ void putCommitGetByteArray() {
             .setMapSize(MEBIBYTES.toBytes(64))
             .setMaxReaders(1)
             .setMaxDbs(2)
-            .open(file.toFile(), MDB_NOSUBDIR)) {
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file)) {
       final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
       try (Txn<byte[]> txn = envBa.txnWrite()) {
         db.put(txn, ba(5), ba(5));
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 6c24c406..c81bbde7 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -25,7 +25,6 @@
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.Builder.MAX_READERS_DEFAULT;
 import static org.lmdbjava.Env.create;
-import static org.lmdbjava.Env.open;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.TestUtils.DB_1;
@@ -69,7 +68,8 @@ void byteUnit() {
         create()
             .setMaxReaders(1)
             .setMapSize(MEBIBYTES.toBytes(1))
-            .open(file.toFile(), MDB_NOSUBDIR)) {
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file)) {
       final EnvInfo info = env.info();
       assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
     }
@@ -81,7 +81,7 @@ void cannotChangeMapSizeAfterOpen() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+              try (Env<ByteBuffer> env = builder.setEnvFlags(MDB_NOSUBDIR).open(file)) {
                 builder.setMapSize(1);
               }
             })
@@ -94,7 +94,7 @@ void cannotChangeMaxDbsAfterOpen() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+              try (Env<ByteBuffer> env = builder.setEnvFlags(MDB_NOSUBDIR).open(file)) {
                 builder.setMaxDbs(1);
               }
             })
@@ -107,7 +107,7 @@ void cannotChangeMaxReadersAfterOpen() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+              try (Env<ByteBuffer> env = builder.setEnvFlags(MDB_NOSUBDIR).open(file)) {
                 builder.setMaxReaders(1);
               }
             })
@@ -120,7 +120,7 @@ void cannotInfoOnceClosed() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Env<ByteBuffer> env =
-                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                  create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file);
               env.close();
               env.info();
             })
@@ -133,8 +133,8 @@ void cannotOpenTwice() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-              builder.open(file.toFile(), MDB_NOSUBDIR).close();
-              builder.open(file.toFile(), MDB_NOSUBDIR);
+              builder.setEnvFlags(MDB_NOSUBDIR).open(file).close();
+              builder.setEnvFlags(MDB_NOSUBDIR).open(file);
             })
         .isInstanceOf(AlreadyOpenException.class);
   }
@@ -157,7 +157,7 @@ void cannotStatOnceClosed() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Env<ByteBuffer> env =
-                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                  create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file);
               env.close();
               env.stat();
             })
@@ -170,7 +170,7 @@ void cannotSyncOnceClosed() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Env<ByteBuffer> env =
-                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                  create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file);
               env.close();
               env.sync(false);
             })
@@ -184,8 +184,8 @@ void copyDirectoryBased() {
     assertThat(Files.isDirectory(dest)).isTrue();
     assertThat(FileUtil.count(dest)).isEqualTo(0);
     final Path src = tempDir.createTempDir();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-      env.copy(dest.toFile(), MDB_CP_COMPACT);
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
+      env.copy(dest, MDB_CP_COMPACT);
       assertThat(FileUtil.count(dest)).isEqualTo(1);
     }
   }
@@ -197,8 +197,8 @@ void copyDirectoryRejectsFileDestination() {
               final Path dest = tempDir.createTempDir();
               FileUtil.deleteDir(dest);
               final Path src = tempDir.createTempDir();
-              try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-                env.copy(dest.toFile(), MDB_CP_COMPACT);
+              try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
+                env.copy(dest, MDB_CP_COMPACT);
               }
             })
         .isInstanceOf(InvalidCopyDestination.class);
@@ -212,8 +212,8 @@ void copyDirectoryRejectsMissingDestination() {
               try {
                 Files.delete(dest);
                 final Path src = tempDir.createTempDir();
-                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
+                  env.copy(dest, MDB_CP_COMPACT);
                 }
               } catch (final IOException e) {
                 throw new UncheckedIOException(e);
@@ -232,8 +232,8 @@ void copyDirectoryRejectsNonEmptyDestination() {
                 Files.createDirectory(subDir);
                 assertThat(Files.isDirectory(subDir)).isTrue();
                 final Path src = tempDir.createTempDir();
-                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
+                  env.copy(dest, MDB_CP_COMPACT);
                 }
               } catch (final IOException e) {
                 throw new UncheckedIOException(e);
@@ -247,8 +247,8 @@ void copyFileBased() {
     final Path dest = tempDir.createTempFile();
     assertThat(Files.exists(dest)).isFalse();
     final Path src = tempDir.createTempFile();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
-      env.copy(dest.toFile(), MDB_CP_COMPACT);
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
+      env.copy(dest, MDB_CP_COMPACT);
     }
     assertThat(FileUtil.size(dest)).isGreaterThan(0L);
   }
@@ -262,8 +262,8 @@ void copyFileRejectsExistingDestination() {
               assertThat(Files.exists(dest)).isTrue();
               final Path src = tempDir.createTempFile();
               try (Env<ByteBuffer> env =
-                  create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
-                env.copy(dest.toFile(), MDB_CP_COMPACT);
+                  create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
+                env.copy(dest, MDB_CP_COMPACT);
               }
             })
         .isInstanceOf(InvalidCopyDestination.class);
@@ -272,7 +272,7 @@ void copyFileRejectsExistingDestination() {
   @Test
   void createAsDirectory() {
     final Path dest = tempDir.createTempDir();
-    final Env<ByteBuffer> env = create().setMaxReaders(1).open(dest.toFile());
+    final Env<ByteBuffer> env = create().setMaxReaders(1).open(dest);
     assertThat(Files.isDirectory(dest)).isTrue();
     env.sync(false);
     env.close();
@@ -288,7 +288,8 @@ void createAsFile() {
             .setMapSize(MEBIBYTES.toBytes(1))
             .setMaxDbs(1)
             .setMaxReaders(1)
-            .open(file.toFile(), MDB_NOSUBDIR)) {
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file)) {
       env.sync(true);
       assertThat(Files.isRegularFile(file)).isTrue();
     }
@@ -300,7 +301,7 @@ void detectTransactionThreadViolation() {
             () -> {
               final Path file = tempDir.createTempFile();
               try (Env<ByteBuffer> env =
-                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+                  create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file)) {
                 env.txnRead();
                 env.txnRead();
               }
@@ -312,7 +313,7 @@ void detectTransactionThreadViolation() {
   void info() {
     final Path file = tempDir.createTempFile();
     try (Env<ByteBuffer> env =
-        create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
+        create().setMaxReaders(4).setMapSize(123_456).setEnvFlags(MDB_NOSUBDIR).open(file)) {
       final EnvInfo info = env.info();
       assertThat(info).isNotNull();
       assertThat(info.lastPageNumber).isEqualTo(1L);
@@ -340,7 +341,7 @@ void mapFull() {
                       .setMaxReaders(1)
                       .setMapSize(MEBIBYTES.toBytes(8))
                       .setMaxDbs(1)
-                      .open(dir.toFile())) {
+                      .open(dir)) {
                 final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
                 for (; ; ) {
                   rnd.nextBytes(k);
@@ -357,11 +358,11 @@ void mapFull() {
   @Test
   void readOnlySupported() {
     final Path dir = tempDir.createTempDir();
-    try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(dir.toFile())) {
+    try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(dir)) {
       final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
       rwDb.put(bb(1), bb(42));
     }
-    try (Env<ByteBuffer> roEnv = create().setMaxReaders(1).open(dir.toFile(), MDB_RDONLY_ENV)) {
+    try (Env<ByteBuffer> roEnv = create().setMaxReaders(1).setEnvFlags(MDB_RDONLY_ENV).open(dir)) {
       final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
       try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
         assertThat(roDb.get(roTxn, bb(1))).isNotNull();
@@ -377,11 +378,7 @@ void setMapSize() {
     final ByteBuffer val = allocateDirect(1_024);
     final Random rnd = new Random();
     try (Env<ByteBuffer> env =
-        create()
-            .setMaxReaders(1)
-            .setMapSize(KIBIBYTES.toBytes(256))
-            .setMaxDbs(1)
-            .open(dir.toFile())) {
+        create().setMaxReaders(1).setMapSize(KIBIBYTES.toBytes(256)).setMaxDbs(1).open(dir)) {
       final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
       db.put(bb(1), bb(42));
@@ -426,7 +423,7 @@ void setMapSize() {
   @Test
   void stats() {
     final Path file = tempDir.createTempFile();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file)) {
       final Stat stat = env.stat();
       assertThat(stat).isNotNull();
       assertThat(stat.branchPages).isEqualTo(0L);
@@ -442,7 +439,7 @@ void stats() {
   @Test
   void testDefaultOpen() {
     final Path dir = tempDir.createTempDir();
-    try (Env<ByteBuffer> env = open(dir.toFile(), 10)) {
+    try (Env<ByteBuffer> env = Env.create().setMapSize(MEBIBYTES.toBytes(10)).open(dir)) {
       final EnvInfo info = env.info();
       assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
       final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index 36273559..0d2ba389 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -38,8 +38,7 @@ public class GarbageCollectionTest {
   void buffersNotGarbageCollectedTest() {
     try (final TempDir tempDir = new TempDir()) {
       final Path dir = tempDir.createTempDir();
-      try (Env<ByteBuffer> env =
-          create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir.toFile())) {
+      try (Env<ByteBuffer> env = create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir)) {
         final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
         try (Txn<ByteBuffer> txn = env.txnWrite()) {
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 6af2599b..03c7991c 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -89,7 +89,7 @@ void tutorial1() {
             // Now let's open the Env. The same path can be concurrently opened and
             // used in different processes, but do not open the same path twice in
             // the same process at the same time.
-            .open(dir.toFile());
+            .open(dir);
 
     // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
     // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
@@ -400,10 +400,7 @@ void tutorial6() {
     final Path dir = tempDir.createTempDir();
     // Note we need to specify the Verifier's DBI_COUNT for the Env.
     final Env<ByteBuffer> env =
-        create(PROXY_OPTIMAL)
-            .setMapSize(10_485_760)
-            .setMaxDbs(Verifier.DBI_COUNT)
-            .open(dir.toFile());
+        create(PROXY_OPTIMAL).setMapSize(10_485_760).setMaxDbs(Verifier.DBI_COUNT).open(dir);
 
     // Create a Verifier (it's a Callable<Long> for those needing full control).
     final Verifier v = new Verifier(env);
@@ -422,8 +419,7 @@ void tutorial7() {
     // The critical difference is we pass the PROXY_DB field to Env.create().
     // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
     // Aside from that and a different type argument, it's the same as usual...
-    final Env<DirectBuffer> env =
-        create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir.toFile());
+    final Env<DirectBuffer> env = create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir);
 
     final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
@@ -477,6 +473,6 @@ void tutorial7() {
   // or reverse ordered keys, using Env.DISABLE_CHECKS_PROP etc), but you now
   // know enough to tackle the JavaDocs with confidence. Have fun!
   private Env<ByteBuffer> createSimpleEnv(final Path path) {
-    return create().setMapSize(10_485_760).setMaxDbs(1).setMaxReaders(1).open(path.toFile());
+    return create().setMapSize(10_485_760).setMaxDbs(1).setMaxReaders(1).open(path);
   }
 }
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index ebb06137..3b0c81fd 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -70,7 +70,9 @@ void beforeEach() {
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
             .setMaxDbs(2)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .setFilePermissions(POSIX_MODE)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
   }
 
   @AfterEach
@@ -129,7 +131,7 @@ void rangeSearch() {
   void readOnlyTxnAllowedInReadOnlyEnv() {
     env.openDbi(DB_1, MDB_CREATE);
     try (Env<ByteBuffer> roEnv =
-        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
+        create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV).open(file)) {
       assertThat(roEnv.txnRead()).isNotNull();
     }
   }
@@ -141,7 +143,7 @@ void readWriteTxnDeniedInReadOnlyEnv() {
               env.openDbi(DB_1, MDB_CREATE);
               env.close();
               try (Env<ByteBuffer> roEnv =
-                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
+                  create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV).open(file)) {
                 roEnv.txnWrite(); // error
               }
             })
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 9d127cf8..df682450 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -38,7 +38,8 @@ void verification() {
               .setMaxReaders(1)
               .setMaxDbs(Verifier.DBI_COUNT)
               .setMapSize(MEBIBYTES.toBytes(10))
-              .open(file.toFile(), MDB_NOSUBDIR)) {
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
         final Verifier v = new Verifier(env);
         final int seconds = Integer.getInteger("verificationSeconds", 2);
         assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);

From 48aa0fdebaf57c6cd35f9ab600136c6b2a6edcae Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 16:50:21 +0000
Subject: [PATCH 49/90] Fix javadoc warnings and class visibility, fix licence
 warnings

---
 pom.xml                                       |   1 +
 .../java/org/lmdbjava/AbstractFlagSet.java    |  25 ++--
 src/main/java/org/lmdbjava/ByteUnit.java      |   7 +-
 src/main/java/org/lmdbjava/CopyFlagSet.java   |  55 +++++---
 .../java/org/lmdbjava/CopyFlagSetEmpty.java   |  20 +++
 .../java/org/lmdbjava/CopyFlagSetImpl.java    |  27 ++++
 src/main/java/org/lmdbjava/CopyFlags.java     |   4 +-
 src/main/java/org/lmdbjava/Dbi.java           |   7 +-
 src/main/java/org/lmdbjava/DbiBuilder.java    | 119 ++++++++++--------
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  45 ++++---
 .../java/org/lmdbjava/DbiFlagSetEmpty.java    |  20 +++
 .../java/org/lmdbjava/DbiFlagSetImpl.java     |  27 ++++
 src/main/java/org/lmdbjava/DbiFlags.java      |   2 -
 src/main/java/org/lmdbjava/Env.java           |  14 ++-
 src/main/java/org/lmdbjava/EnvFlagSet.java    |  48 ++++---
 .../java/org/lmdbjava/EnvFlagSetEmpty.java    |  20 +++
 .../java/org/lmdbjava/EnvFlagSetImpl.java     |  27 ++++
 src/main/java/org/lmdbjava/FlagSet.java       |  27 +++-
 src/main/java/org/lmdbjava/MaskedFlag.java    |  12 +-
 src/main/java/org/lmdbjava/PutFlagSet.java    |  44 ++++---
 .../java/org/lmdbjava/PutFlagSetEmpty.java    |  20 +++
 .../java/org/lmdbjava/PutFlagSetImpl.java     |  27 ++++
 src/main/java/org/lmdbjava/TxnFlagSet.java    |  60 +++++----
 .../java/org/lmdbjava/TxnFlagSetEmpty.java    |  20 +++
 .../java/org/lmdbjava/TxnFlagSetImpl.java     |  27 ++++
 .../org/lmdbjava/AbstractFlagSetTest.java     |  21 ++++
 src/test/java/org/lmdbjava/ByteUnitTest.java  |  11 ++
 .../java/org/lmdbjava/CopyFlagSetTest.java    |   2 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  |   2 +-
 .../org/lmdbjava/CursorIterableRangeTest.java |   8 +-
 .../java/org/lmdbjava/DbiBuilderTest.java     |   5 +-
 .../java/org/lmdbjava/DbiFlagSetTest.java     |   2 +-
 .../java/org/lmdbjava/EnvFlagSetTest.java     |   2 +-
 .../org/lmdbjava/GarbageCollectionTest.java   |   2 +-
 .../java/org/lmdbjava/PutFlagSetTest.java     |   2 +-
 src/test/java/org/lmdbjava/TempDir.java       |   2 +-
 .../java/org/lmdbjava/TxnFlagSetTest.java     |   2 +-
 37 files changed, 571 insertions(+), 195 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/CopyFlagSetEmpty.java
 create mode 100644 src/main/java/org/lmdbjava/CopyFlagSetImpl.java
 create mode 100644 src/main/java/org/lmdbjava/DbiFlagSetEmpty.java
 create mode 100644 src/main/java/org/lmdbjava/DbiFlagSetImpl.java
 create mode 100644 src/main/java/org/lmdbjava/EnvFlagSetEmpty.java
 create mode 100644 src/main/java/org/lmdbjava/EnvFlagSetImpl.java
 create mode 100644 src/main/java/org/lmdbjava/PutFlagSetEmpty.java
 create mode 100644 src/main/java/org/lmdbjava/PutFlagSetImpl.java
 create mode 100644 src/main/java/org/lmdbjava/TxnFlagSetEmpty.java
 create mode 100644 src/main/java/org/lmdbjava/TxnFlagSetImpl.java

diff --git a/pom.xml b/pom.xml
index 11dbdeb5..7c204a77 100644
--- a/pom.xml
+++ b/pom.xml
@@ -139,6 +139,7 @@
               <excludes>
                 <exclude>LICENSE.txt</exclude>
                 <exclude>**/*.md</exclude>
+                <exclude>**/*.csv</exclude>
                 <exclude>lmdb/**</exclude>
                 <exclude>licenses/**</exclude>
               </excludes>
diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 655369e1..cff79ef1 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -24,8 +24,10 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
-/** Encapsulates an immutable set of flags and the associated bit mask for the flags in the set. */
-public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
+/** Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
+ * @param <T> The type of the flags in this set. Must extend {@link MaskedFlag} and {@link Enum<T>}.
+ * */
+abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
 
   private final Set<T> flags;
   private final int mask;
@@ -36,25 +38,16 @@ protected AbstractFlagSet(final EnumSet<T> flags) {
     this.flags = Collections.unmodifiableSet(Objects.requireNonNull(flags));
   }
 
-  /**
-   * @return THe combined bit mask for all flags in the set.
-   */
   @Override
   public int getMask() {
     return mask;
   }
 
-  /**
-   * @return All flags in the set.
-   */
   @Override
   public Set<T> getFlags() {
     return flags;
   }
 
-  /**
-   * @return True if flag has been set, i.e. is contained in this set.
-   */
   @Override
   public boolean isSet(final T flag) {
     // Probably cheaper to compare the masks than to use EnumSet.contains()
@@ -163,11 +156,6 @@ public String toString() {
       return FlagSet.asString(this);
     }
 
-    @Override
-    public boolean equals(Object object) {
-      return FlagSet.equals(this, object);
-    }
-
     @Override
     public int hashCode() {
       return Objects.hash(flag, getFlags());
@@ -239,7 +227,7 @@ public int hashCode() {
    * @param <E> The type of flag to be held in the {@link AbstractFlagSet}
    * @param <S> The type of the {@link AbstractFlagSet} implementation.
    */
-  public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>> {
+  public static final class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>> {
 
     final Class<E> type;
     final EnumSet<E> enumSet;
@@ -247,7 +235,7 @@ public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>
     final Function<E, S> singletonSetConstructor;
     final Supplier<S> emptySetSupplier;
 
-    protected Builder(
+    Builder(
         final Class<E> type,
         final Function<EnumSet<E>, S> constructor,
         final Function<E, S> singletonSetConstructor,
@@ -279,6 +267,7 @@ public Builder<E, S> setFlags(final Collection<E> flags) {
     }
 
     /**
+     * Replaces any flags already set in the builder with the passed flags.
      * @param flags The flags to set in the builder.
      * @return this builder instance.
      */
diff --git a/src/main/java/org/lmdbjava/ByteUnit.java b/src/main/java/org/lmdbjava/ByteUnit.java
index ed4b1ca8..c03eea9d 100644
--- a/src/main/java/org/lmdbjava/ByteUnit.java
+++ b/src/main/java/org/lmdbjava/ByteUnit.java
@@ -17,12 +17,14 @@
 
 /** Simple {@link Enum} for converting various IEC and SI byte units down a number of bytes. */
 public enum ByteUnit {
+
+  /** IEC/SI byte unit for bytes. */
   BYTES(1L),
 
   /** IEC byte unit for 1024 bytes. */
-  KIBIBYTES(1024L),
+  KIBIBYTES(1_024L),
   /** IEC byte unit for 1024^2 bytes. */
-  MEBIBYTES(1_0485_76L),
+  MEBIBYTES(1_048_576L),
   /** IEC byte unit for 1024^3 bytes. */
   GIBIBYTES(1_073_741_824L),
   /** IEC byte unit for 1024^4 bytes. */
@@ -59,6 +61,7 @@ public long toBytes(final long value) {
   }
 
   /**
+   * Gets factor to apply when converting this unit into bytes.
    * @return The factor to apply when converting this unit into bytes.
    */
   public long getFactor() {
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index cea2fce9..56c875c4 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -15,45 +15,60 @@
  */
 package org.lmdbjava;
 
+import java.nio.file.Path;
 import java.util.Collection;
-import java.util.EnumSet;
 import java.util.Objects;
 
+/** An immutable set of flags for use when performing a {@link Env#copy(Path, CopyFlagSet)}. */
 public interface CopyFlagSet extends FlagSet<CopyFlags> {
 
+  /**
+   * An immutable empty {@link CopyFlagSet}.
+   */
   CopyFlagSet EMPTY = CopyFlagSetImpl.EMPTY;
 
+  /**
+   * Gets the immutable empty {@link CopyFlagSet} instance.
+   * @return The immutable empty {@link CopyFlagSet} instance.
+   */
   static CopyFlagSet empty() {
     return CopyFlagSetImpl.EMPTY;
   }
 
-  static CopyFlagSet of(final CopyFlags dbiFlag) {
-    Objects.requireNonNull(dbiFlag);
-    return dbiFlag;
+  /**
+   * Creates an immutable {@link CopyFlagSet} containing copyFlag.
+   * @param copyFlag The flag to include in the {@link CopyFlagSet}
+   * @return An immutable {@link CopyFlagSet} containing just copyFlag.
+   */
+  static CopyFlagSet of(final CopyFlags copyFlag) {
+    Objects.requireNonNull(copyFlag);
+    return copyFlag;
   }
 
-  static CopyFlagSet of(final CopyFlags... CopyFlags) {
-    return builder().setFlags(CopyFlags).build();
+  /**
+   * Creates an immutable {@link CopyFlagSet} containing copyFlags.
+   * @param copyFlags The flags to include in the {@link CopyFlagSet}.
+   * @return An immutable {@link CopyFlagSet} containing copyFlags.
+   */
+  static CopyFlagSet of(final CopyFlags... copyFlags) {
+    return builder().setFlags(copyFlags).build();
   }
 
-  static CopyFlagSet of(final Collection<CopyFlags> CopyFlags) {
-    return builder().setFlags(CopyFlags).build();
+  /**
+   * Creates an immutable {@link CopyFlagSet} containing copyFlags.
+   * @param copyFlags The flags to include in the {@link CopyFlagSet}.
+   * @return An immutable {@link CopyFlagSet} containing copyFlags.
+   */
+  static CopyFlagSet of(final Collection<CopyFlags> copyFlags) {
+    return builder().setFlags(copyFlags).build();
   }
 
+  /**
+   * Create a builder for building an {@link CopyFlagSet}.
+   * @return A builder instance for building an {@link CopyFlagSet}.
+   */
   static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
         CopyFlags.class, CopyFlagSetImpl::new, copyFlag -> copyFlag, () -> CopyFlagSetImpl.EMPTY);
   }
-
-  class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
-
-    static final CopyFlagSet EMPTY = new EmptyCopyFlagSet();
-
-    private CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
-      super(flags);
-    }
-  }
-
-  class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
-      implements CopyFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java b/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java
new file mode 100644
index 00000000..3227b9e9
--- /dev/null
+++ b/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+class CopyFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
+    implements CopyFlagSet {
+}
diff --git a/src/main/java/org/lmdbjava/CopyFlagSetImpl.java b/src/main/java/org/lmdbjava/CopyFlagSetImpl.java
new file mode 100644
index 00000000..a566fc2a
--- /dev/null
+++ b/src/main/java/org/lmdbjava/CopyFlagSetImpl.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.EnumSet;
+
+class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
+
+  static final CopyFlagSet EMPTY = new CopyFlagSetEmpty();
+
+  CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
+    super(flags);
+  }
+}
diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index b45dc87c..d2d7b0e2 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -15,11 +15,11 @@
  */
 package org.lmdbjava;
 
-import java.io.File;
+import java.nio.file.Path;
 import java.util.EnumSet;
 import java.util.Set;
 
-/** Flags for use when performing a {@link Env#copy(File, CopyFlagSet)}. */
+/** Flags for use when performing a {@link Env#copy(Path, CopyFlagSet)}. */
 public enum CopyFlags implements MaskedFlag, CopyFlagSet {
 
   /** Compacting copy: Omit free space from copy, and renumber all pages sequentially. */
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 88d1bb53..3a387960 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -271,12 +271,16 @@ public T get(final Txn<T> txn, final T key) {
   /**
    * Obtains the name of this database.
    *
-   * @return the name (may be null)
+   * @return The name (it maybe null)
    */
   public byte[] getName() {
     return name == null ? null : Arrays.copyOf(name, name.length);
   }
 
+  /**
+   * Obtains the name of this database, using the {@link Env#DEFAULT_NAME_CHARSET} {@link Charset}.
+   * @return The name of this database, using the {@link Env#DEFAULT_NAME_CHARSET} {@link Charset}.
+   */
   public String getNameAsString() {
     return getNameAsString(Env.DEFAULT_NAME_CHARSET);
   }
@@ -284,6 +288,7 @@ public String getNameAsString() {
   /**
    * Obtains the name of this database, using the supplied {@link Charset}.
    *
+   * @param charset The {@link Charset} to use when converting the DB from a byte[] to a {@link String}.
    * @return The name of the database. If this is the unnamed database an empty string will be
    *     returned.
    * @throws RuntimeException if the name can't be decoded.
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 450fb3c7..df9853ff 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -26,7 +26,7 @@
  *
  * @param <T> buffer type
  */
-public class DbiBuilder<T> {
+public final class DbiBuilder<T> {
 
   private final Env<T> env;
   private final BufferProxy<T> proxy;
@@ -48,7 +48,7 @@ public class DbiBuilder<T> {
    *     DbiBuilder#withoutDbName()})
    * @return The next builder stage.
    */
-  public DbiBuilderStage2<T> setDbName(final String name) {
+  public Stage2<T> setDbName(final String name) {
     // Null name is allowed so no null check
     final byte[] nameBytes = name == null ? null : name.getBytes(Env.DEFAULT_NAME_CHARSET);
     return setDbName(nameBytes);
@@ -60,10 +60,10 @@ public DbiBuilderStage2<T> setDbName(final String name) {
    * @param name The name of the database in byte form.
    * @return The next builder stage.
    */
-  public DbiBuilderStage2<T> setDbName(final byte[] name) {
+  public Stage2<T> setDbName(final byte[] name) {
     // Null name is allowed so no null check
     this.name = name;
-    return new DbiBuilderStage2<>(this);
+    return new Stage2<>(this);
   }
 
   /**
@@ -78,7 +78,7 @@ public DbiBuilderStage2<T> setDbName(final byte[] name) {
    *
    * @return The next builder stage.
    */
-  public DbiBuilderStage2<T> withoutDbName() {
+  public Stage2<T> withoutDbName() {
     return setDbName((byte[]) null);
   }
 
@@ -87,14 +87,14 @@ public DbiBuilderStage2<T> withoutDbName() {
    *
    * @param <T> buffer type
    */
-  public static class DbiBuilderStage2<T> {
+  public static final class Stage2<T> {
 
     private final DbiBuilder<T> dbiBuilder;
 
     private ComparatorFactory<T> comparatorFactory;
     private ComparatorType comparatorType;
 
-    private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
+    private Stage2(final DbiBuilder<T> dbiBuilder) {
       this.dbiBuilder = dbiBuilder;
     }
 
@@ -109,20 +109,20 @@ private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
      * functionally identical.
      *
      * <p>This option may be slightly more performant than when using {@link
-     * DbiBuilderStage2#withNativeComparator()} which calls down to LMDB for ALL comparison
+     * Stage2#withNativeComparator()} which calls down to LMDB for ALL comparison
      * operations.
      *
      * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
-     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
-     * DbiBuilderStage2#withDefaultComparator()} or {@link
-     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * choose {@link Stage2#withNativeComparator()}, {@link
+     * Stage2#withDefaultComparator()} or {@link
+     * Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
      * be used.
      *
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withDefaultComparator() {
+    public Stage3<T> withDefaultComparator() {
       this.comparatorType = ComparatorType.DEFAULT;
-      return new DbiBuilderStage3<>(this);
+      return new Stage3<>(this);
     }
 
     /**
@@ -131,21 +131,21 @@ public DbiBuilderStage3<T> withDefaultComparator() {
      * keys using the same comparator that is used for insertion order into the db.
      *
      * <p>This option may be slightly less performant than when using {@link
-     * DbiBuilderStage2#withDefaultComparator()} as it needs to call down to LMDB to perform the
+     * Stage2#withDefaultComparator()} as it needs to call down to LMDB to perform the
      * comparisons, however it guarantees that {@link CursorIterable} key comparison matches LMDB
      * key comparison.
      *
      * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
-     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
-     * DbiBuilderStage2#withDefaultComparator()} or {@link
-     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * choose {@link Stage2#withNativeComparator()}, {@link
+     * Stage2#withDefaultComparator()} or {@link
+     * Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
      * be used.
      *
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withNativeComparator() {
+    public Stage3<T> withNativeComparator() {
       this.comparatorType = ComparatorType.NATIVE;
-      return new DbiBuilderStage3<>(this);
+      return new Stage3<>(this);
     }
 
     /**
@@ -167,11 +167,11 @@ public DbiBuilderStage3<T> withNativeComparator() {
      *     the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withCallbackComparator(
+    public Stage3<T> withCallbackComparator(
         final ComparatorFactory<T> comparatorFactory) {
       this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.CALLBACK;
-      return new DbiBuilderStage3<>(this);
+      return new Stage3<>(this);
     }
 
     /**
@@ -189,9 +189,9 @@ public DbiBuilderStage3<T> withCallbackComparator(
      * when using {@link CursorIterable}.
      *
      * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
-     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
-     * DbiBuilderStage2#withDefaultComparator()} or {@link
-     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * choose {@link Stage2#withNativeComparator()}, {@link
+     * Stage2#withDefaultComparator()} or {@link
+     * Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
      * be used.
      *
      * @param comparatorFactory The comparator to use with {@link CursorIterable}. {@link
@@ -199,11 +199,11 @@ public DbiBuilderStage3<T> withCallbackComparator(
      *     the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withIteratorComparator(
+    public Stage3<T> withIteratorComparator(
         final ComparatorFactory<T> comparatorFactory) {
       this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.ITERATOR;
-      return new DbiBuilderStage3<>(this);
+      return new Stage3<>(this);
     }
   }
 
@@ -212,31 +212,32 @@ public DbiBuilderStage3<T> withIteratorComparator(
    *
    * @param <T> buffer type
    */
-  public static class DbiBuilderStage3<T> {
+  public static final class Stage3<T> {
 
-    private final DbiBuilderStage2<T> dbiBuilderStage2;
+    private final Stage2<T> stage2;
     private final AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder =
         DbiFlagSet.builder();
     private Txn<T> txn = null;
 
-    private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
-      this.dbiBuilderStage2 = dbiBuilderStage2;
+    private Stage3(Stage2<T> stage2) {
+      this.stage2 = stage2;
     }
 
     /**
      * Apply all the dbi flags supplied in dbiFlags.
      *
      * <p>Clears all flags currently set by previous calls to {@link
-     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)}
+     * or {@link Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlags to open the database with. A null {@link Collection} will just clear all set
      *     flags. Null items are ignored.
+     * @return This builder instance.
      */
-    public DbiBuilderStage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
+    public Stage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
-        dbiFlags.stream().filter(Objects::nonNull).forEach(dbiFlags::add);
+        dbiFlags.stream().filter(Objects::nonNull).forEach(this.flagSetBuilder::addFlag);
       }
       return this;
     }
@@ -245,13 +246,14 @@ public DbiBuilderStage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
      * Apply all the dbi flags supplied in dbiFlags.
      *
      * <p>Clears all flags currently set by previous calls to {@link
-     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)}
+     * or {@link Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlags to open the database with. A null array will just clear all set flags. Null
      *     items are ignored.
+     * @return This builder instance.
      */
-    public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
+    public Stage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
         Arrays.stream(dbiFlags).filter(Objects::nonNull).forEach(this.flagSetBuilder::addFlag);
@@ -263,12 +265,13 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
      * Apply all the dbi flags supplied in dbiFlags.
      *
      * <p>Clears all flags currently set by previous calls to {@link
-     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)}
+     * or {@link Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlagSet to open the database with. A null value will just clear all set flags.
+     * @return This builder instance.
      */
-    public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
+    public Stage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
       flagSetBuilder.clear();
       if (dbiFlagSet != null) {
         this.flagSetBuilder.setFlags(dbiFlagSet.getFlags());
@@ -278,28 +281,28 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
 
     /**
      * Adds a dbiFlag to those flags already added to this builder by {@link
-     * DbiBuilderStage3#setDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#setDbiFlags(Collection)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(DbiFlags...)}, {@link Stage3#setDbiFlags(Collection)}
+     * or {@link Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlag to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
      */
-    public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
+    public Stage3<T> addDbiFlag(final DbiFlags dbiFlag) {
       this.flagSetBuilder.addFlag(dbiFlag);
       return this;
     }
 
     /**
      * Adds a dbiFlag to those flags already added to this builder by {@link
-     * DbiBuilderStage3#setDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#setDbiFlags(Collection)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(DbiFlags...)}, {@link Stage3#setDbiFlags(Collection)}
+     * or {@link Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlagSet to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
      */
-    public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
+    public Stage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
       if (dbiFlagSet != null) {
-        flagSetBuilder.addFlags(dbiFlagSet.getFlags());
+        this.flagSetBuilder.addFlags(dbiFlagSet.getFlags());
       }
       return this;
     }
@@ -307,7 +310,7 @@ public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
     /**
      * Use the supplied transaction to open the {@link Dbi}.
      *
-     * <p>The caller MUST commit the transaction after calling {@link DbiBuilderStage3#open()}, in
+     * <p>The caller MUST commit the transaction after calling {@link Stage3#open()}, in
      * order to retain the <code>Dbi</code> in the <code>Env</code>.
      *
      * <p>If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for
@@ -319,7 +322,7 @@ public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
      *     be a read/write {@link Txn}.
      * @return this builder instance.
      */
-    public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
+    public Stage3<T> setTxn(final Txn<T> txn) {
       this.txn = Objects.requireNonNull(txn);
       return this;
     }
@@ -333,7 +336,7 @@ public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
      * @return A newly constructed and opened {@link Dbi}.
      */
     public Dbi<T> open() {
-      final DbiBuilder<T> dbiBuilder = dbiBuilderStage2.dbiBuilder;
+      final DbiBuilder<T> dbiBuilder = stage2.dbiBuilder;
       if (txn != null) {
         return openDbi(txn, dbiBuilder);
       } else {
@@ -363,7 +366,7 @@ private Comparator<T> getComparator(
           break;
         case CALLBACK:
         case ITERATOR:
-          comparator = dbiBuilderStage2.comparatorFactory.create(dbiFlagSet);
+          comparator = stage2.comparatorFactory.create(dbiFlagSet);
           Objects.requireNonNull(comparator, "comparatorFactory returned null");
           break;
         case NATIVE:
@@ -376,7 +379,7 @@ private Comparator<T> getComparator(
 
     private Dbi<T> openDbi(final Txn<T> txn, final DbiBuilder<T> dbiBuilder) {
       final DbiFlagSet dbiFlagSet = flagSetBuilder.build();
-      final ComparatorType comparatorType = dbiBuilderStage2.comparatorType;
+      final ComparatorType comparatorType = stage2.comparatorType;
       final Comparator<T> comparator = getComparator(dbiBuilder, comparatorType, dbiFlagSet);
       final boolean useNativeCallback = comparatorType == ComparatorType.CALLBACK;
       return new Dbi<>(
@@ -408,9 +411,21 @@ private enum ComparatorType {
     ;
   }
 
+  /**
+   * A factory for creating a {@link Comparator} from a {@link DbiFlagSet}
+   * @param <T> The type of buffer that will be compared by the created {@link Comparator}.
+   */
   @FunctionalInterface
   public interface ComparatorFactory<T> {
 
+    /**
+     * Creates a comparator for the supplied {@link DbiFlagSet}. This will only be called once
+     * during the initialisation of the {@link Dbi}.
+     *
+     * @param dbiFlagSet The flags set on the DB that the returned {@link Comparator} will be used by.
+     *                   The flags in the set may impact how the returned {@link Comparator} should behave.
+     * @return A {@link Comparator} applicable to the passed DB flags.
+     */
     Comparator<T> create(final DbiFlagSet dbiFlagSet);
   }
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index d0b13793..2481f166 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -16,9 +16,9 @@
 package org.lmdbjava;
 
 import java.util.Collection;
-import java.util.EnumSet;
 import java.util.Objects;
 
+/** An immutable set of flags for use when opening a {@link Dbi}. */
 public interface DbiFlagSet extends FlagSet<DbiFlags> {
 
   /** An immutable empty {@link DbiFlagSet}. */
@@ -27,37 +27,48 @@ public interface DbiFlagSet extends FlagSet<DbiFlags> {
   /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
   DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_INTEGERDUP);
 
+  /**
+   * Gets the immutable empty {@link DbiFlagSet} instance.
+   * @return The immutable empty {@link DbiFlagSet} instance.
+   */
   static DbiFlagSet empty() {
     return DbiFlagSetImpl.EMPTY;
   }
 
+  /**
+   * Creates an immutable {@link DbiFlagSet} containing dbiFlag.
+   * @param dbiFlag The flag to include in the {@link DbiFlagSet}
+   * @return An immutable {@link DbiFlagSet} containing just dbiFlag.
+   */
   static DbiFlagSet of(final DbiFlags dbiFlag) {
     Objects.requireNonNull(dbiFlag);
     return dbiFlag;
   }
 
-  static DbiFlagSet of(final DbiFlags... DbiFlags) {
-    return builder().setFlags(DbiFlags).build();
+  /**
+   * Creates an immutable {@link DbiFlagSet} containing dbiFlags.
+   * @param dbiFlags The flags to include in the {@link DbiFlagSet}.
+   * @return An immutable {@link DbiFlagSet} containing dbiFlags.
+   */
+  static DbiFlagSet of(final DbiFlags... dbiFlags) {
+    return builder().setFlags(dbiFlags).build();
   }
 
-  static DbiFlagSet of(final Collection<DbiFlags> DbiFlags) {
-    return builder().setFlags(DbiFlags).build();
+  /**
+   * Creates an immutable {@link DbiFlagSet} containing dbiFlags.
+   * @param dbiFlags The flags to include in the {@link DbiFlagSet}.
+   * @return An immutable {@link DbiFlagSet} containing dbiFlags.
+   */
+  static DbiFlagSet of(final Collection<DbiFlags> dbiFlags) {
+    return builder().setFlags(dbiFlags).build();
   }
 
+  /**
+   * Create a builder for building an {@link DbiFlagSet}.
+   * @return A builder instance for building an {@link DbiFlagSet}.
+   */
   static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
         DbiFlags.class, DbiFlagSetImpl::new, dbiFlag -> dbiFlag, () -> DbiFlagSetImpl.EMPTY);
   }
-
-  class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
-
-    static final DbiFlagSet EMPTY = new EmptyDbiFlagSet();
-
-    private DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
-      super(flags);
-    }
-  }
-
-  class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
-      implements DbiFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java b/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java
new file mode 100644
index 00000000..3b57642c
--- /dev/null
+++ b/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+class DbiFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
+    implements DbiFlagSet {
+}
diff --git a/src/main/java/org/lmdbjava/DbiFlagSetImpl.java b/src/main/java/org/lmdbjava/DbiFlagSetImpl.java
new file mode 100644
index 00000000..a43e887f
--- /dev/null
+++ b/src/main/java/org/lmdbjava/DbiFlagSetImpl.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.EnumSet;
+
+class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
+
+  static final DbiFlagSet EMPTY = new DbiFlagSetEmpty();
+
+  DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
+    super(flags);
+  }
+}
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index f8ccbe20..e1e66a31 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -34,8 +34,6 @@ public enum DbiFlags implements MaskedFlag, DbiFlagSet {
    * <p>Duplicate keys may be used in the database. Or, from another perspective, keys may have
    * multiple data items, stored in sorted order. By default, keys must be unique and may have only
    * a single data item.
-   *
-   * <p>
    */
   MDB_DUPSORT(0x04),
   /**
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index c2b337ce..b368b4aa 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -54,6 +54,10 @@ public final class Env<T> implements AutoCloseable {
   /** Java system property name that can be set to disable optional checks. */
   public static final String DISABLE_CHECKS_PROP = "lmdbjava.disable.checks";
 
+  /**
+   * The default {@link Charset} used to convert DB names from a byte[] to a String or
+   * to encode a String as a byte[]. Only used if not explicit {@link Charset} is provided.
+   */
   public static final Charset DEFAULT_NAME_CHARSET = StandardCharsets.UTF_8;
 
   /**
@@ -196,9 +200,9 @@ public void copy(final Path path, final CopyFlagSet flags) {
    * @deprecated Use {@link Env#copy(Path, CopyFlagSet)}
    */
   @Deprecated
-  public void copy(final File path, final CopyFlagSet flags) {
+  public void copy(final File path, final CopyFlags... flags) {
     requireNonNull(path);
-    copy(path.toPath(), flags);
+    copy(path.toPath(), CopyFlagSet.of(flags));
   }
 
   /**
@@ -268,7 +272,8 @@ public void setMapSize(final long mapSize) {
   /**
    * Set the size of the data memory map.
    *
-   * @param mapSize the new size, in bytes
+   * @param mapSize new map size in the units of byteUnit.
+   * @param byteUnit The unit that mapSize is in.
    */
   public void setMapSize(final long mapSize, final ByteUnit byteUnit) {
     requireNonNull(byteUnit);
@@ -804,7 +809,8 @@ public Builder<T> setMapSize(final long mapSize) {
     /**
      * Sets the map size in the supplied unit.
      *
-     * @param mapSize new limit in
+     * @param mapSize new map size in the units of byteUnit.
+     * @param byteUnit The unit that mapSize is in.
      * @return the builder
      */
     public Builder<T> setMapSize(final long mapSize, final ByteUnit byteUnit) {
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index 4ce5eadc..7e5f8cc3 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -16,44 +16,58 @@
 package org.lmdbjava;
 
 import java.util.Collection;
-import java.util.EnumSet;
 import java.util.Objects;
 
+/** An immutable set of flags for use when opening the {@link Env}. */
 public interface EnvFlagSet extends FlagSet<EnvFlags> {
 
+  /**
+   * An immutable empty {@link EnvFlagSet}.
+   */
   EnvFlagSet EMPTY = EnvFlagSetImpl.EMPTY;
 
+  /**
+   * Gets the immutable empty {@link EnvFlagSet} instance.
+   * @return The immutable empty {@link EnvFlagSet} instance.
+   */
   static EnvFlagSet empty() {
     return EnvFlagSetImpl.EMPTY;
   }
 
+  /**
+   * Creates an immutable {@link EnvFlagSet} containing envFlag.
+   * @param envFlag The flag to include in the {@link EnvFlagSet}
+   * @return An immutable {@link EnvFlagSet} containing just envFlag.
+   */
   static EnvFlagSet of(final EnvFlags envFlag) {
     Objects.requireNonNull(envFlag);
     return envFlag;
   }
 
-  static EnvFlagSet of(final EnvFlags... EnvFlags) {
-    return builder().setFlags(EnvFlags).build();
+  /**
+   * Creates an immutable {@link EnvFlagSet} containing envFlags.
+   * @param envFlags The flags to include in the {@link EnvFlagSet}.
+   * @return An immutable {@link EnvFlagSet} containing envFlags.
+   */
+  static EnvFlagSet of(final EnvFlags... envFlags) {
+    return builder().setFlags(envFlags).build();
   }
 
-  static EnvFlagSet of(final Collection<EnvFlags> EnvFlags) {
-    return builder().setFlags(EnvFlags).build();
+  /**
+   * Creates an immutable {@link EnvFlagSet} containing envFlags.
+   * @param envFlags The flags to include in the {@link EnvFlagSet}.
+   * @return An immutable {@link EnvFlagSet} containing envFlags.
+   */
+  static EnvFlagSet of(final Collection<EnvFlags> envFlags) {
+    return builder().setFlags(envFlags).build();
   }
 
+  /**
+   * Create a builder for building an {@link EnvFlagSet}.
+   * @return A builder instance for building an {@link EnvFlagSet}.
+   */
   static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
         EnvFlags.class, EnvFlagSetImpl::new, envFlag -> envFlag, () -> EnvFlagSetImpl.EMPTY);
   }
-
-  class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
-
-    static final EnvFlagSet EMPTY = new EmptyEnvFlagSet();
-
-    private EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
-      super(flags);
-    }
-  }
-
-  class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
-      implements EnvFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java b/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java
new file mode 100644
index 00000000..7cd55edf
--- /dev/null
+++ b/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+class EnvFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
+    implements EnvFlagSet {
+}
diff --git a/src/main/java/org/lmdbjava/EnvFlagSetImpl.java b/src/main/java/org/lmdbjava/EnvFlagSetImpl.java
new file mode 100644
index 00000000..ba1bdfef
--- /dev/null
+++ b/src/main/java/org/lmdbjava/EnvFlagSetImpl.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.EnumSet;
+
+class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
+
+  static final EnvFlagSet EMPTY = new EnvFlagSetEmpty();
+
+  EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
+    super(flags);
+  }
+}
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index e5e1c6a4..de63d9c6 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -25,16 +25,19 @@
  * A set of flags, each with a bit mask value. Flags can be combined in a set such that the set has
  * a combined bit mask value.
  *
- * @param <T>
+ * @param <T> The type of flag in the set, must extend {@link MaskedFlag}.
  */
 public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
 
   /**
+   * The combined mask for this flagSet.
    * @return The combined mask for this flagSet.
    */
   int getMask();
 
   /**
+   * Combines this {@link FlagSet} with another and returns the combined mask value.
+   * @param other The other {@link FlagSet} to combine with this.
    * @return The result of combining the mask of this {@link FlagSet} with the mask of the other
    *     {@link FlagSet}.
    */
@@ -47,22 +50,28 @@ default int getMaskWith(final FlagSet<T> other) {
   }
 
   /**
+   * Get the set of flags in this {@link FlagSet}.
    * @return The set of flags in this {@link FlagSet}.
    */
   Set<T> getFlags();
 
   /**
+   * Tests if flag is non-null and included in this {@link FlagSet}.
+   * @param flag The flag to test.
    * @return True if flag is non-null and included in this {@link FlagSet}.
    */
   boolean isSet(T flag);
 
   /**
+   * The number of flags in this set.
    * @return The number of flags in this set.
    */
   int size();
 
   /**
-   * @return True if at least one of flags are included in thie {@link FlagSet}
+   * Tests if at least one of flags are included in this {@link FlagSet}
+   * @param flags The flags to test.
+   * @return True if at least one of flags are included in this {@link FlagSet}
    */
   default boolean areAnySet(final FlagSet<T> flags) {
     if (flags == null) {
@@ -78,11 +87,13 @@ default boolean areAnySet(final FlagSet<T> flags) {
   }
 
   /**
+   * Tests if this {@link FlagSet} is empty.
    * @return True if this {@link FlagSet} is empty.
    */
   boolean isEmpty();
 
   /**
+   * Gets an {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
    * @return The {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
    */
   @Override
@@ -90,7 +101,11 @@ default Iterator<T> iterator() {
     return getFlags().iterator();
   }
 
-  /** Convert this {@link FlagSet} to a string for use in toString methods. */
+  /** Convert this {@link FlagSet} to a string for use in toString methods.
+   * @param flagSet The {@link FlagSet} to convert to a string.
+   * @param <T> The type of the flags in the {@link FlagSet}.
+   * @return The {@link String} representation of the flagSet.
+   * */
   static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
     Objects.requireNonNull(flagSet);
     final String flagsStr =
@@ -101,6 +116,12 @@ static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
     return "FlagSet{" + "flags=[" + flagsStr + "], mask=" + flagSet.getMask() + '}';
   }
 
+  /**
+   * Compares a {@link FlagSet} to another object
+   * @param flagSet The {@link FlagSet} to compare.
+   * @param other THe object to compare against the {@link FlagSet}.
+   * @return True if both arguments implement {@link FlagSet} and contain the same flags.
+   */
   static boolean equals(final FlagSet<?> flagSet, final Object other) {
     if (other instanceof FlagSet) {
       final FlagSet<?> flagSet2 = (FlagSet<?>) other;
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 400f2f30..a45fab97 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -22,6 +22,9 @@
 /** Indicates an enum that can provide integers for each of its values. */
 public interface MaskedFlag {
 
+  /**
+   * The mask value for an empty mask, i.e. no flags set.
+   */
   int EMPTY_MASK = 0;
 
   /**
@@ -32,6 +35,7 @@ public interface MaskedFlag {
   int getMask();
 
   /**
+   * The name of the flag.
    * @return The name of the flag.
    */
   String name();
@@ -59,8 +63,12 @@ static <M extends MaskedFlag> int mask(final M... flags) {
     }
   }
 
-  /** Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s. */
-  static <M extends MaskedFlag> int mask(final int mask1, final int mask2) {
+  /** Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s.
+   * @param mask1 The mask to combine with mask2.
+   * @param mask2 The mask to combine with mask1.
+   * @return The combined mask value for the two passed masks.
+   * */
+  static int mask(final int mask1, final int mask2) {
     return mask1 | mask2;
   }
 
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 8c587138..2f71c604 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -16,44 +16,58 @@
 package org.lmdbjava;
 
 import java.util.Collection;
-import java.util.EnumSet;
 import java.util.Objects;
 
+ /** An immutable set of flags for use when performing a "put". */
 public interface PutFlagSet extends FlagSet<PutFlags> {
 
+   /**
+    * An immutable empty {@link PutFlagSet}.
+    */
   PutFlagSet EMPTY = PutFlagSetImpl.EMPTY;
 
+   /**
+    * Gets the immutable empty {@link PutFlagSet} instance.
+    * @return The immutable empty {@link PutFlagSet} instance.
+    */
   static PutFlagSet empty() {
     return PutFlagSetImpl.EMPTY;
   }
 
+   /**
+    * Creates an immutable {@link PutFlagSet} containing putFlag.
+    * @param putFlag The flag to include in the {@link PutFlagSet}
+    * @return An immutable {@link PutFlagSet} containing just putFlag.
+    */
   static PutFlagSet of(final PutFlags putFlag) {
     Objects.requireNonNull(putFlag);
     return putFlag;
   }
 
+   /**
+    * Creates an immutable {@link PutFlagSet} containing putFlags.
+    * @param putFlags The flags to include in the {@link PutFlagSet}.
+    * @return An immutable {@link PutFlagSet} containing putFlags.
+    */
   static PutFlagSet of(final PutFlags... putFlags) {
     return builder().setFlags(putFlags).build();
   }
 
+   /**
+    * Creates an immutable {@link PutFlagSet} containing putFlags.
+    * @param putFlags The flags to include in the {@link PutFlagSet}.
+    * @return An immutable {@link PutFlagSet} containing putFlags.
+    */
   static PutFlagSet of(final Collection<PutFlags> putFlags) {
     return builder().setFlags(putFlags).build();
   }
 
+   /**
+    * Create a builder for building an {@link PutFlagSet}.
+    * @return A builder instance for building an {@link PutFlagSet}.
+    */
   static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
-        PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, EmptyPutFlagSet::new);
+        PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, PutFlagSetEmpty::new);
   }
-
-  class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
-
-    public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
-
-    private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
-      super(flags);
-    }
-  }
-
-  class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
-      implements PutFlagSet {}
-}
+ }
diff --git a/src/main/java/org/lmdbjava/PutFlagSetEmpty.java b/src/main/java/org/lmdbjava/PutFlagSetEmpty.java
new file mode 100644
index 00000000..8119edbe
--- /dev/null
+++ b/src/main/java/org/lmdbjava/PutFlagSetEmpty.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+class PutFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
+    implements PutFlagSet {
+}
diff --git a/src/main/java/org/lmdbjava/PutFlagSetImpl.java b/src/main/java/org/lmdbjava/PutFlagSetImpl.java
new file mode 100644
index 00000000..afa495ef
--- /dev/null
+++ b/src/main/java/org/lmdbjava/PutFlagSetImpl.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.EnumSet;
+
+class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
+
+  public static final PutFlagSet EMPTY = new PutFlagSetEmpty();
+
+  PutFlagSetImpl(final EnumSet<PutFlags> flags) {
+    super(flags);
+  }
+}
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index 4bfdf2e3..7436f5d4 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -16,52 +16,58 @@
 package org.lmdbjava;
 
 import java.util.Collection;
-import java.util.EnumSet;
 import java.util.Objects;
 
+/** An immutable set of flags for use when creating a {@link Txn}. */
 public interface TxnFlagSet extends FlagSet<TxnFlags> {
 
+  /**
+   * An immutable empty {@link TxnFlagSet}.
+   */
   TxnFlagSet EMPTY = TxnFlagSetImpl.EMPTY;
 
+  /**
+   * Gets the immutable empty {@link TxnFlagSet} instance.
+   * @return The immutable empty {@link TxnFlagSet} instance.
+   */
   static TxnFlagSet empty() {
     return TxnFlagSetImpl.EMPTY;
   }
 
-  static TxnFlagSet of(final TxnFlags putflag) {
-    Objects.requireNonNull(putflag);
-    return new SingleTxnFlagSet(putflag);
+  /**
+   * Creates an immutable {@link TxnFlagSet} containing txnFlag.
+   * @param txnFlag The flag to include in the {@link TxnFlagSet}
+   * @return An immutable {@link TxnFlagSet} containing just txnFlag.
+   */
+  static TxnFlagSet of(final TxnFlags txnFlag) {
+    Objects.requireNonNull(txnFlag);
+    return txnFlag;
   }
 
-  static TxnFlagSet of(final TxnFlags... TxnFlags) {
-    return builder().setFlags(TxnFlags).build();
+  /**
+   * Creates an immutable {@link TxnFlagSet} containing txnFlags.
+   * @param txnFlags The flags to include in the {@link TxnFlagSet}.
+   * @return An immutable {@link TxnFlagSet} containing txnFlags.
+   */
+  static TxnFlagSet of(final TxnFlags... txnFlags) {
+    return builder().setFlags(txnFlags).build();
   }
 
+  /**
+   * Creates an immutable {@link TxnFlagSet} containing txnFlags.
+   * @param txnFlags The flags to include in the {@link TxnFlagSet}.
+   * @return An immutable {@link TxnFlagSet} containing txnFlags.
+   */
   static TxnFlagSet of(final Collection<TxnFlags> txnFlags) {
     return builder().setFlags(txnFlags).build();
   }
 
+  /**
+   * Create a builder for building an {@link TxnFlagSet}.
+   * @return A builder instance for building an {@link TxnFlagSet}.
+   */
   static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
-        TxnFlags.class, TxnFlagSetImpl::new, SingleTxnFlagSet::new, () -> TxnFlagSetImpl.EMPTY);
-  }
-
-  class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
-
-    static final TxnFlagSet EMPTY = new EmptyTxnFlagSet();
-
-    private TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
-      super(flags);
-    }
+        TxnFlags.class, TxnFlagSetImpl::new, txnFlag -> txnFlag, () -> TxnFlagSetImpl.EMPTY);
   }
-
-  class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
-      implements TxnFlagSet {
-
-    SingleTxnFlagSet(final TxnFlags flag) {
-      super(flag);
-    }
-  }
-
-  class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
-      implements TxnFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java b/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java
new file mode 100644
index 00000000..2b7f152d
--- /dev/null
+++ b/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+class TxnFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
+    implements TxnFlagSet {
+}
diff --git a/src/main/java/org/lmdbjava/TxnFlagSetImpl.java b/src/main/java/org/lmdbjava/TxnFlagSetImpl.java
new file mode 100644
index 00000000..c81f3be0
--- /dev/null
+++ b/src/main/java/org/lmdbjava/TxnFlagSetImpl.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.EnumSet;
+
+class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
+
+  static final TxnFlagSet EMPTY = new TxnFlagSetEmpty();
+
+  TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
+    super(flags);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index dbe32e14..dcebc722 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -140,6 +140,27 @@ void testAsFlag() {
     }
   }
 
+  @Test
+  void testAddCollection() {
+    final F flagSet = getBuilder()
+        .addFlags(getAllFlags())
+        .build();
+
+    assertThat(flagSet.getFlags())
+        .containsExactlyElementsOf(getAllFlags());
+  }
+
+  @Test
+  void testClearBuilder() {
+    final F flagSet = getBuilder()
+        .addFlag(getFirst())
+        .clear()
+        .build();
+
+    assertThat(flagSet.isEmpty())
+        .isTrue();
+  }
+
   private T[] toArray(final int cnt) {
     //noinspection unchecked
     return (T[]) Array.newInstance(getFlagType(), cnt);
diff --git a/src/test/java/org/lmdbjava/ByteUnitTest.java b/src/test/java/org/lmdbjava/ByteUnitTest.java
index 5724429d..d6608684 100644
--- a/src/test/java/org/lmdbjava/ByteUnitTest.java
+++ b/src/test/java/org/lmdbjava/ByteUnitTest.java
@@ -27,37 +27,48 @@ void test() {
     // BYTES
     Assertions.assertThat(ByteUnit.BYTES.toBytes(2)).isEqualTo(2L);
     Assertions.assertThat(ByteUnit.BYTES.toBytes(0)).isEqualTo(0L);
+    Assertions.assertThat(ByteUnit.BYTES.getFactor()).isEqualTo(1L);
 
     // IEC Units
     Assertions.assertThat(ByteUnit.KIBIBYTES.toBytes(1)).isEqualTo(1024L);
     Assertions.assertThat(ByteUnit.KIBIBYTES.toBytes(2)).isEqualTo(2048L);
+    Assertions.assertThat(ByteUnit.KIBIBYTES.getFactor()).isEqualTo(1024L);
 
     Assertions.assertThat(ByteUnit.MEBIBYTES.toBytes(1)).isEqualTo(1048576L);
     Assertions.assertThat(ByteUnit.MEBIBYTES.toBytes(2)).isEqualTo(2097152L);
+    Assertions.assertThat(ByteUnit.MEBIBYTES.getFactor()).isEqualTo(1048576L);
 
     Assertions.assertThat(ByteUnit.GIBIBYTES.toBytes(1)).isEqualTo(1073741824L);
     Assertions.assertThat(ByteUnit.GIBIBYTES.toBytes(2)).isEqualTo(2147483648L);
+    Assertions.assertThat(ByteUnit.GIBIBYTES.getFactor()).isEqualTo(1073741824L);
 
     Assertions.assertThat(ByteUnit.TEBIBYTES.toBytes(1)).isEqualTo(1099511627776L);
     Assertions.assertThat(ByteUnit.TEBIBYTES.toBytes(2)).isEqualTo(2199023255552L);
+    Assertions.assertThat(ByteUnit.TEBIBYTES.getFactor()).isEqualTo(1099511627776L);
 
     Assertions.assertThat(ByteUnit.PEBIBYTES.toBytes(1)).isEqualTo(1125899906842624L);
     Assertions.assertThat(ByteUnit.PEBIBYTES.toBytes(2)).isEqualTo(2251799813685248L);
+    Assertions.assertThat(ByteUnit.PEBIBYTES.getFactor()).isEqualTo(1125899906842624L);
 
     // SI Units
     Assertions.assertThat(ByteUnit.KILOBYTES.toBytes(1)).isEqualTo(1000L);
     Assertions.assertThat(ByteUnit.KILOBYTES.toBytes(2)).isEqualTo(2000L);
+    Assertions.assertThat(ByteUnit.KILOBYTES.getFactor()).isEqualTo(1000L);
 
     Assertions.assertThat(ByteUnit.MEGABYTES.toBytes(1)).isEqualTo(1000000L);
     Assertions.assertThat(ByteUnit.MEGABYTES.toBytes(2)).isEqualTo(2000000L);
+    Assertions.assertThat(ByteUnit.MEGABYTES.getFactor()).isEqualTo(1000000L);
 
     Assertions.assertThat(ByteUnit.GIGABYTES.toBytes(1)).isEqualTo(1000000000L);
     Assertions.assertThat(ByteUnit.GIGABYTES.toBytes(2)).isEqualTo(2000000000L);
+    Assertions.assertThat(ByteUnit.GIGABYTES.getFactor()).isEqualTo(1000000000L);
 
     Assertions.assertThat(ByteUnit.TERABYTES.toBytes(1)).isEqualTo(1000000000000L);
     Assertions.assertThat(ByteUnit.TERABYTES.toBytes(2)).isEqualTo(2000000000000L);
+    Assertions.assertThat(ByteUnit.TERABYTES.getFactor()).isEqualTo(1000000000000L);
 
     Assertions.assertThat(ByteUnit.PETABYTES.toBytes(1)).isEqualTo(1000000000000000L);
     Assertions.assertThat(ByteUnit.PETABYTES.toBytes(2)).isEqualTo(2000000000000000L);
+    Assertions.assertThat(ByteUnit.PETABYTES.getFactor()).isEqualTo(1000000000000000L);
   }
 }
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 898da499..559bd8ea 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -20,7 +20,7 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class CopyFlagSetTest extends AbstractFlagSetTest<CopyFlags, CopyFlagSet> {
+class CopyFlagSetTest extends AbstractFlagSetTest<CopyFlags, CopyFlagSet> {
 
   @Override
   List<CopyFlags> getAllFlags() {
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index bb1665c6..66d83cc5 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -34,7 +34,7 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-public class CursorIterablePerfTest {
+class CursorIterablePerfTest {
 
   private static final int ITERATIONS = 100_000;
 
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index fbda0314..54b57794 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -148,7 +148,7 @@ void testLongKey(
 
   private void testCSV(
       final Function<
-              DbiBuilder.DbiBuilderStage2<ByteBuffer>, DbiBuilder.DbiBuilderStage3<ByteBuffer>>
+          DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>
           comparatorFunc,
       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
       final DbiFlagSet dbiFlags,
@@ -170,7 +170,7 @@ private void testCSV(
 
   private void testCSV(
       final Function<
-              DbiBuilder.DbiBuilderStage2<ByteBuffer>, DbiBuilder.DbiBuilderStage3<ByteBuffer>>
+          DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>
           comparatorFunc,
       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
       final DbiFlagSet dbiFlags,
@@ -191,9 +191,9 @@ private void testCSV(
               .setEnvFlags(MDB_NOSUBDIR)
               .open(file)) {
 
-        final DbiBuilder.DbiBuilderStage2<ByteBuffer> builderStage2 =
+        final DbiBuilder.Stage2<ByteBuffer> builderStage2 =
             env.createDbi().setDbName(DB_1);
-        final DbiBuilder.DbiBuilderStage3<ByteBuffer> builderStage3 =
+        final DbiBuilder.Stage3<ByteBuffer> builderStage3 =
             comparatorFunc.apply(builderStage2);
         final Dbi<ByteBuffer> dbi = builderStage3.setDbiFlags(dbiFlags).open();
 
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index b7d6480f..c06c3dc9 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -24,6 +24,7 @@
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
@@ -31,7 +32,7 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-public class DbiBuilderTest {
+class DbiBuilderTest {
 
   private TempDir tempDir;
   private Env<ByteBuffer> env;
@@ -169,6 +170,8 @@ public void flags() {
             .withDefaultComparator()
             .setDbiFlags(DbiFlags.MDB_DUPSORT, DbiFlags.MDB_DUPFIXED) // Will get overwritten
             .setDbiFlags() // clear them
+            .setDbiFlags(Collections.singletonList(DbiFlags.MDB_INTEGERDUP))
+            .setDbiFlags() // clear them
             .addDbiFlags(DbiFlags.MDB_CREATE) // Not a dbi flag as far as lmdb is concerned.
             .addDbiFlags(DbiFlags.MDB_INTEGERKEY)
             .addDbiFlags(DbiFlags.MDB_REVERSEKEY)
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index 1c44f0c0..be97aea6 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -20,7 +20,7 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class DbiFlagSetTest extends AbstractFlagSetTest<DbiFlags, DbiFlagSet> {
+class DbiFlagSetTest extends AbstractFlagSetTest<DbiFlags, DbiFlagSet> {
 
   @Override
   List<DbiFlags> getAllFlags() {
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index bd181ce8..35fcc001 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -20,7 +20,7 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class EnvFlagSetTest extends AbstractFlagSetTest<EnvFlags, EnvFlagSet> {
+class EnvFlagSetTest extends AbstractFlagSetTest<EnvFlags, EnvFlagSet> {
 
   @Override
   List<EnvFlags> getAllFlags() {
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index 26a99e98..e6c8ca88 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -27,7 +27,7 @@
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 
-public class GarbageCollectionTest {
+class GarbageCollectionTest {
 
   private static final String DB_NAME = "my DB";
   private static final String KEY_PREFIX = "Uncorruptedkey";
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index bc1a24e0..9b6f3a09 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -24,7 +24,7 @@
 import java.util.stream.IntStream;
 import org.junit.jupiter.api.Test;
 
-public class PutFlagSetTest extends AbstractFlagSetTest<PutFlags, PutFlagSet> {
+class PutFlagSetTest extends AbstractFlagSetTest<PutFlags, PutFlagSet> {
 
   @Override
   List<PutFlags> getAllFlags() {
diff --git a/src/test/java/org/lmdbjava/TempDir.java b/src/test/java/org/lmdbjava/TempDir.java
index 7d2977b9..d8acb2b9 100644
--- a/src/test/java/org/lmdbjava/TempDir.java
+++ b/src/test/java/org/lmdbjava/TempDir.java
@@ -21,7 +21,7 @@
 import java.nio.file.Path;
 import java.util.UUID;
 
-public class TempDir implements AutoCloseable {
+class TempDir implements AutoCloseable {
   private final Path root;
 
   public TempDir() {
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 4cf1e879..3ef93195 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -20,7 +20,7 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
+class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
 
   @Override
   List<TxnFlags> getAllFlags() {

From 72b5234561243a6f589d4355e7718e92f538bc86 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 16:52:46 +0000
Subject: [PATCH 50/90] Auto-format

---
 .../java/org/lmdbjava/AbstractFlagSet.java    |  7 +-
 src/main/java/org/lmdbjava/ByteUnit.java      |  1 +
 src/main/java/org/lmdbjava/CopyFlagSet.java   |  9 ++-
 .../java/org/lmdbjava/CopyFlagSetEmpty.java   |  3 +-
 src/main/java/org/lmdbjava/Dbi.java           |  4 +-
 src/main/java/org/lmdbjava/DbiBuilder.java    | 64 +++++++++----------
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  5 ++
 .../java/org/lmdbjava/DbiFlagSetEmpty.java    |  3 +-
 src/main/java/org/lmdbjava/Env.java           |  4 +-
 src/main/java/org/lmdbjava/EnvFlagSet.java    |  9 ++-
 .../java/org/lmdbjava/EnvFlagSetEmpty.java    |  3 +-
 src/main/java/org/lmdbjava/FlagSet.java       | 15 ++++-
 src/main/java/org/lmdbjava/MaskedFlag.java    | 11 ++--
 src/main/java/org/lmdbjava/PutFlagSet.java    | 59 +++++++++--------
 .../java/org/lmdbjava/PutFlagSetEmpty.java    |  3 +-
 src/main/java/org/lmdbjava/TxnFlagSet.java    |  9 ++-
 .../java/org/lmdbjava/TxnFlagSetEmpty.java    |  3 +-
 .../org/lmdbjava/AbstractFlagSetTest.java     | 15 ++---
 .../org/lmdbjava/CursorIterableRangeTest.java | 14 ++--
 19 files changed, 126 insertions(+), 115 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index cff79ef1..99b073d9 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -24,9 +24,11 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
-/** Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
+/**
+ * Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
+ *
  * @param <T> The type of the flags in this set. Must extend {@link MaskedFlag} and {@link Enum<T>}.
- * */
+ */
 abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
 
   private final Set<T> flags;
@@ -268,6 +270,7 @@ public Builder<E, S> setFlags(final Collection<E> flags) {
 
     /**
      * Replaces any flags already set in the builder with the passed flags.
+     *
      * @param flags The flags to set in the builder.
      * @return this builder instance.
      */
diff --git a/src/main/java/org/lmdbjava/ByteUnit.java b/src/main/java/org/lmdbjava/ByteUnit.java
index c03eea9d..51dab217 100644
--- a/src/main/java/org/lmdbjava/ByteUnit.java
+++ b/src/main/java/org/lmdbjava/ByteUnit.java
@@ -62,6 +62,7 @@ public long toBytes(final long value) {
 
   /**
    * Gets factor to apply when converting this unit into bytes.
+   *
    * @return The factor to apply when converting this unit into bytes.
    */
   public long getFactor() {
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index 56c875c4..c8e35477 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -22,13 +22,12 @@
 /** An immutable set of flags for use when performing a {@link Env#copy(Path, CopyFlagSet)}. */
 public interface CopyFlagSet extends FlagSet<CopyFlags> {
 
-  /**
-   * An immutable empty {@link CopyFlagSet}.
-   */
+  /** An immutable empty {@link CopyFlagSet}. */
   CopyFlagSet EMPTY = CopyFlagSetImpl.EMPTY;
 
   /**
    * Gets the immutable empty {@link CopyFlagSet} instance.
+   *
    * @return The immutable empty {@link CopyFlagSet} instance.
    */
   static CopyFlagSet empty() {
@@ -37,6 +36,7 @@ static CopyFlagSet empty() {
 
   /**
    * Creates an immutable {@link CopyFlagSet} containing copyFlag.
+   *
    * @param copyFlag The flag to include in the {@link CopyFlagSet}
    * @return An immutable {@link CopyFlagSet} containing just copyFlag.
    */
@@ -47,6 +47,7 @@ static CopyFlagSet of(final CopyFlags copyFlag) {
 
   /**
    * Creates an immutable {@link CopyFlagSet} containing copyFlags.
+   *
    * @param copyFlags The flags to include in the {@link CopyFlagSet}.
    * @return An immutable {@link CopyFlagSet} containing copyFlags.
    */
@@ -56,6 +57,7 @@ static CopyFlagSet of(final CopyFlags... copyFlags) {
 
   /**
    * Creates an immutable {@link CopyFlagSet} containing copyFlags.
+   *
    * @param copyFlags The flags to include in the {@link CopyFlagSet}.
    * @return An immutable {@link CopyFlagSet} containing copyFlags.
    */
@@ -65,6 +67,7 @@ static CopyFlagSet of(final Collection<CopyFlags> copyFlags) {
 
   /**
    * Create a builder for building an {@link CopyFlagSet}.
+   *
    * @return A builder instance for building an {@link CopyFlagSet}.
    */
   static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
diff --git a/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java b/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java
index 3227b9e9..f18af382 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java
@@ -16,5 +16,4 @@
 package org.lmdbjava;
 
 class CopyFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
-    implements CopyFlagSet {
-}
+    implements CopyFlagSet {}
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 3a387960..e5d66568 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -279,6 +279,7 @@ public byte[] getName() {
 
   /**
    * Obtains the name of this database, using the {@link Env#DEFAULT_NAME_CHARSET} {@link Charset}.
+   *
    * @return The name of this database, using the {@link Env#DEFAULT_NAME_CHARSET} {@link Charset}.
    */
   public String getNameAsString() {
@@ -288,7 +289,8 @@ public String getNameAsString() {
   /**
    * Obtains the name of this database, using the supplied {@link Charset}.
    *
-   * @param charset The {@link Charset} to use when converting the DB from a byte[] to a {@link String}.
+   * @param charset The {@link Charset} to use when converting the DB from a byte[] to a {@link
+   *     String}.
    * @return The name of the database. If this is the unnamed database an empty string will be
    *     returned.
    * @throws RuntimeException if the name can't be decoded.
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index df9853ff..fcb457ed 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -109,14 +109,12 @@ private Stage2(final DbiBuilder<T> dbiBuilder) {
      * functionally identical.
      *
      * <p>This option may be slightly more performant than when using {@link
-     * Stage2#withNativeComparator()} which calls down to LMDB for ALL comparison
-     * operations.
+     * Stage2#withNativeComparator()} which calls down to LMDB for ALL comparison operations.
      *
      * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
-     * choose {@link Stage2#withNativeComparator()}, {@link
-     * Stage2#withDefaultComparator()} or {@link
-     * Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
-     * be used.
+     * choose {@link Stage2#withNativeComparator()}, {@link Stage2#withDefaultComparator()} or
+     * {@link Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never be
+     * used.
      *
      * @return The next builder stage.
      */
@@ -131,15 +129,13 @@ public Stage3<T> withDefaultComparator() {
      * keys using the same comparator that is used for insertion order into the db.
      *
      * <p>This option may be slightly less performant than when using {@link
-     * Stage2#withDefaultComparator()} as it needs to call down to LMDB to perform the
-     * comparisons, however it guarantees that {@link CursorIterable} key comparison matches LMDB
-     * key comparison.
+     * Stage2#withDefaultComparator()} as it needs to call down to LMDB to perform the comparisons,
+     * however it guarantees that {@link CursorIterable} key comparison matches LMDB key comparison.
      *
      * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
-     * choose {@link Stage2#withNativeComparator()}, {@link
-     * Stage2#withDefaultComparator()} or {@link
-     * Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
-     * be used.
+     * choose {@link Stage2#withNativeComparator()}, {@link Stage2#withDefaultComparator()} or
+     * {@link Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never be
+     * used.
      *
      * @return The next builder stage.
      */
@@ -167,8 +163,7 @@ public Stage3<T> withNativeComparator() {
      *     the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public Stage3<T> withCallbackComparator(
-        final ComparatorFactory<T> comparatorFactory) {
+    public Stage3<T> withCallbackComparator(final ComparatorFactory<T> comparatorFactory) {
       this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.CALLBACK;
       return new Stage3<>(this);
@@ -189,18 +184,16 @@ public Stage3<T> withCallbackComparator(
      * when using {@link CursorIterable}.
      *
      * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
-     * choose {@link Stage2#withNativeComparator()}, {@link
-     * Stage2#withDefaultComparator()} or {@link
-     * Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
-     * be used.
+     * choose {@link Stage2#withNativeComparator()}, {@link Stage2#withDefaultComparator()} or
+     * {@link Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never be
+     * used.
      *
      * @param comparatorFactory The comparator to use with {@link CursorIterable}. {@link
      *     ComparatorFactory#create(DbiFlagSet)} will be called once during the initialisation of
      *     the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public Stage3<T> withIteratorComparator(
-        final ComparatorFactory<T> comparatorFactory) {
+    public Stage3<T> withIteratorComparator(final ComparatorFactory<T> comparatorFactory) {
       this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.ITERATOR;
       return new Stage3<>(this);
@@ -227,8 +220,8 @@ private Stage3(Stage2<T> stage2) {
      * Apply all the dbi flags supplied in dbiFlags.
      *
      * <p>Clears all flags currently set by previous calls to {@link
-     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)}
-     * or {@link Stage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)} or {@link
+     * Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlags to open the database with. A null {@link Collection} will just clear all set
      *     flags. Null items are ignored.
@@ -246,8 +239,8 @@ public Stage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
      * Apply all the dbi flags supplied in dbiFlags.
      *
      * <p>Clears all flags currently set by previous calls to {@link
-     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)}
-     * or {@link Stage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)} or {@link
+     * Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlags to open the database with. A null array will just clear all set flags. Null
      *     items are ignored.
@@ -265,8 +258,8 @@ public Stage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
      * Apply all the dbi flags supplied in dbiFlags.
      *
      * <p>Clears all flags currently set by previous calls to {@link
-     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)}
-     * or {@link Stage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)} or {@link
+     * Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlagSet to open the database with. A null value will just clear all set flags.
      * @return This builder instance.
@@ -281,8 +274,8 @@ public Stage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
 
     /**
      * Adds a dbiFlag to those flags already added to this builder by {@link
-     * Stage3#setDbiFlags(DbiFlags...)}, {@link Stage3#setDbiFlags(Collection)}
-     * or {@link Stage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(DbiFlags...)}, {@link Stage3#setDbiFlags(Collection)} or {@link
+     * Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlag to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
@@ -294,8 +287,8 @@ public Stage3<T> addDbiFlag(final DbiFlags dbiFlag) {
 
     /**
      * Adds a dbiFlag to those flags already added to this builder by {@link
-     * Stage3#setDbiFlags(DbiFlags...)}, {@link Stage3#setDbiFlags(Collection)}
-     * or {@link Stage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(DbiFlags...)}, {@link Stage3#setDbiFlags(Collection)} or {@link
+     * Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlagSet to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
@@ -310,8 +303,8 @@ public Stage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
     /**
      * Use the supplied transaction to open the {@link Dbi}.
      *
-     * <p>The caller MUST commit the transaction after calling {@link Stage3#open()}, in
-     * order to retain the <code>Dbi</code> in the <code>Env</code>.
+     * <p>The caller MUST commit the transaction after calling {@link Stage3#open()}, in order to
+     * retain the <code>Dbi</code> in the <code>Env</code>.
      *
      * <p>If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for
      * the purpose of creating and opening the {@link Dbi}, then closed. Therefore, if you already
@@ -413,6 +406,7 @@ private enum ComparatorType {
 
   /**
    * A factory for creating a {@link Comparator} from a {@link DbiFlagSet}
+   *
    * @param <T> The type of buffer that will be compared by the created {@link Comparator}.
    */
   @FunctionalInterface
@@ -422,8 +416,8 @@ public interface ComparatorFactory<T> {
      * Creates a comparator for the supplied {@link DbiFlagSet}. This will only be called once
      * during the initialisation of the {@link Dbi}.
      *
-     * @param dbiFlagSet The flags set on the DB that the returned {@link Comparator} will be used by.
-     *                   The flags in the set may impact how the returned {@link Comparator} should behave.
+     * @param dbiFlagSet The flags set on the DB that the returned {@link Comparator} will be used
+     *     by. The flags in the set may impact how the returned {@link Comparator} should behave.
      * @return A {@link Comparator} applicable to the passed DB flags.
      */
     Comparator<T> create(final DbiFlagSet dbiFlagSet);
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 2481f166..82043fe3 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -29,6 +29,7 @@ public interface DbiFlagSet extends FlagSet<DbiFlags> {
 
   /**
    * Gets the immutable empty {@link DbiFlagSet} instance.
+   *
    * @return The immutable empty {@link DbiFlagSet} instance.
    */
   static DbiFlagSet empty() {
@@ -37,6 +38,7 @@ static DbiFlagSet empty() {
 
   /**
    * Creates an immutable {@link DbiFlagSet} containing dbiFlag.
+   *
    * @param dbiFlag The flag to include in the {@link DbiFlagSet}
    * @return An immutable {@link DbiFlagSet} containing just dbiFlag.
    */
@@ -47,6 +49,7 @@ static DbiFlagSet of(final DbiFlags dbiFlag) {
 
   /**
    * Creates an immutable {@link DbiFlagSet} containing dbiFlags.
+   *
    * @param dbiFlags The flags to include in the {@link DbiFlagSet}.
    * @return An immutable {@link DbiFlagSet} containing dbiFlags.
    */
@@ -56,6 +59,7 @@ static DbiFlagSet of(final DbiFlags... dbiFlags) {
 
   /**
    * Creates an immutable {@link DbiFlagSet} containing dbiFlags.
+   *
    * @param dbiFlags The flags to include in the {@link DbiFlagSet}.
    * @return An immutable {@link DbiFlagSet} containing dbiFlags.
    */
@@ -65,6 +69,7 @@ static DbiFlagSet of(final Collection<DbiFlags> dbiFlags) {
 
   /**
    * Create a builder for building an {@link DbiFlagSet}.
+   *
    * @return A builder instance for building an {@link DbiFlagSet}.
    */
   static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
diff --git a/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java b/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java
index 3b57642c..cff91caf 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java
@@ -16,5 +16,4 @@
 package org.lmdbjava;
 
 class DbiFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
-    implements DbiFlagSet {
-}
+    implements DbiFlagSet {}
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index b368b4aa..d6fa7dc2 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -55,8 +55,8 @@ public final class Env<T> implements AutoCloseable {
   public static final String DISABLE_CHECKS_PROP = "lmdbjava.disable.checks";
 
   /**
-   * The default {@link Charset} used to convert DB names from a byte[] to a String or
-   * to encode a String as a byte[]. Only used if not explicit {@link Charset} is provided.
+   * The default {@link Charset} used to convert DB names from a byte[] to a String or to encode a
+   * String as a byte[]. Only used if not explicit {@link Charset} is provided.
    */
   public static final Charset DEFAULT_NAME_CHARSET = StandardCharsets.UTF_8;
 
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index 7e5f8cc3..70ed4e90 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -21,13 +21,12 @@
 /** An immutable set of flags for use when opening the {@link Env}. */
 public interface EnvFlagSet extends FlagSet<EnvFlags> {
 
-  /**
-   * An immutable empty {@link EnvFlagSet}.
-   */
+  /** An immutable empty {@link EnvFlagSet}. */
   EnvFlagSet EMPTY = EnvFlagSetImpl.EMPTY;
 
   /**
    * Gets the immutable empty {@link EnvFlagSet} instance.
+   *
    * @return The immutable empty {@link EnvFlagSet} instance.
    */
   static EnvFlagSet empty() {
@@ -36,6 +35,7 @@ static EnvFlagSet empty() {
 
   /**
    * Creates an immutable {@link EnvFlagSet} containing envFlag.
+   *
    * @param envFlag The flag to include in the {@link EnvFlagSet}
    * @return An immutable {@link EnvFlagSet} containing just envFlag.
    */
@@ -46,6 +46,7 @@ static EnvFlagSet of(final EnvFlags envFlag) {
 
   /**
    * Creates an immutable {@link EnvFlagSet} containing envFlags.
+   *
    * @param envFlags The flags to include in the {@link EnvFlagSet}.
    * @return An immutable {@link EnvFlagSet} containing envFlags.
    */
@@ -55,6 +56,7 @@ static EnvFlagSet of(final EnvFlags... envFlags) {
 
   /**
    * Creates an immutable {@link EnvFlagSet} containing envFlags.
+   *
    * @param envFlags The flags to include in the {@link EnvFlagSet}.
    * @return An immutable {@link EnvFlagSet} containing envFlags.
    */
@@ -64,6 +66,7 @@ static EnvFlagSet of(final Collection<EnvFlags> envFlags) {
 
   /**
    * Create a builder for building an {@link EnvFlagSet}.
+   *
    * @return A builder instance for building an {@link EnvFlagSet}.
    */
   static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
diff --git a/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java b/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java
index 7cd55edf..552b1646 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java
@@ -16,5 +16,4 @@
 package org.lmdbjava;
 
 class EnvFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
-    implements EnvFlagSet {
-}
+    implements EnvFlagSet {}
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index de63d9c6..bec120e4 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -31,12 +31,14 @@ public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
 
   /**
    * The combined mask for this flagSet.
+   *
    * @return The combined mask for this flagSet.
    */
   int getMask();
 
   /**
    * Combines this {@link FlagSet} with another and returns the combined mask value.
+   *
    * @param other The other {@link FlagSet} to combine with this.
    * @return The result of combining the mask of this {@link FlagSet} with the mask of the other
    *     {@link FlagSet}.
@@ -51,12 +53,14 @@ default int getMaskWith(final FlagSet<T> other) {
 
   /**
    * Get the set of flags in this {@link FlagSet}.
+   *
    * @return The set of flags in this {@link FlagSet}.
    */
   Set<T> getFlags();
 
   /**
    * Tests if flag is non-null and included in this {@link FlagSet}.
+   *
    * @param flag The flag to test.
    * @return True if flag is non-null and included in this {@link FlagSet}.
    */
@@ -64,12 +68,14 @@ default int getMaskWith(final FlagSet<T> other) {
 
   /**
    * The number of flags in this set.
+   *
    * @return The number of flags in this set.
    */
   int size();
 
   /**
    * Tests if at least one of flags are included in this {@link FlagSet}
+   *
    * @param flags The flags to test.
    * @return True if at least one of flags are included in this {@link FlagSet}
    */
@@ -88,12 +94,14 @@ default boolean areAnySet(final FlagSet<T> flags) {
 
   /**
    * Tests if this {@link FlagSet} is empty.
+   *
    * @return True if this {@link FlagSet} is empty.
    */
   boolean isEmpty();
 
   /**
    * Gets an {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
+   *
    * @return The {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
    */
   @Override
@@ -101,11 +109,13 @@ default Iterator<T> iterator() {
     return getFlags().iterator();
   }
 
-  /** Convert this {@link FlagSet} to a string for use in toString methods.
+  /**
+   * Convert this {@link FlagSet} to a string for use in toString methods.
+   *
    * @param flagSet The {@link FlagSet} to convert to a string.
    * @param <T> The type of the flags in the {@link FlagSet}.
    * @return The {@link String} representation of the flagSet.
-   * */
+   */
   static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
     Objects.requireNonNull(flagSet);
     final String flagsStr =
@@ -118,6 +128,7 @@ static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
 
   /**
    * Compares a {@link FlagSet} to another object
+   *
    * @param flagSet The {@link FlagSet} to compare.
    * @param other THe object to compare against the {@link FlagSet}.
    * @return True if both arguments implement {@link FlagSet} and contain the same flags.
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index a45fab97..67afebce 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -22,9 +22,7 @@
 /** Indicates an enum that can provide integers for each of its values. */
 public interface MaskedFlag {
 
-  /**
-   * The mask value for an empty mask, i.e. no flags set.
-   */
+  /** The mask value for an empty mask, i.e. no flags set. */
   int EMPTY_MASK = 0;
 
   /**
@@ -36,6 +34,7 @@ public interface MaskedFlag {
 
   /**
    * The name of the flag.
+   *
    * @return The name of the flag.
    */
   String name();
@@ -63,11 +62,13 @@ static <M extends MaskedFlag> int mask(final M... flags) {
     }
   }
 
-  /** Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s.
+  /**
+   * Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s.
+   *
    * @param mask1 The mask to combine with mask2.
    * @param mask2 The mask to combine with mask1.
    * @return The combined mask value for the two passed masks.
-   * */
+   */
   static int mask(final int mask1, final int mask2) {
     return mask1 | mask2;
   }
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 2f71c604..a5605d1a 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -18,56 +18,59 @@
 import java.util.Collection;
 import java.util.Objects;
 
- /** An immutable set of flags for use when performing a "put". */
+/** An immutable set of flags for use when performing a "put". */
 public interface PutFlagSet extends FlagSet<PutFlags> {
 
-   /**
-    * An immutable empty {@link PutFlagSet}.
-    */
+  /** An immutable empty {@link PutFlagSet}. */
   PutFlagSet EMPTY = PutFlagSetImpl.EMPTY;
 
-   /**
-    * Gets the immutable empty {@link PutFlagSet} instance.
-    * @return The immutable empty {@link PutFlagSet} instance.
-    */
+  /**
+   * Gets the immutable empty {@link PutFlagSet} instance.
+   *
+   * @return The immutable empty {@link PutFlagSet} instance.
+   */
   static PutFlagSet empty() {
     return PutFlagSetImpl.EMPTY;
   }
 
-   /**
-    * Creates an immutable {@link PutFlagSet} containing putFlag.
-    * @param putFlag The flag to include in the {@link PutFlagSet}
-    * @return An immutable {@link PutFlagSet} containing just putFlag.
-    */
+  /**
+   * Creates an immutable {@link PutFlagSet} containing putFlag.
+   *
+   * @param putFlag The flag to include in the {@link PutFlagSet}
+   * @return An immutable {@link PutFlagSet} containing just putFlag.
+   */
   static PutFlagSet of(final PutFlags putFlag) {
     Objects.requireNonNull(putFlag);
     return putFlag;
   }
 
-   /**
-    * Creates an immutable {@link PutFlagSet} containing putFlags.
-    * @param putFlags The flags to include in the {@link PutFlagSet}.
-    * @return An immutable {@link PutFlagSet} containing putFlags.
-    */
+  /**
+   * Creates an immutable {@link PutFlagSet} containing putFlags.
+   *
+   * @param putFlags The flags to include in the {@link PutFlagSet}.
+   * @return An immutable {@link PutFlagSet} containing putFlags.
+   */
   static PutFlagSet of(final PutFlags... putFlags) {
     return builder().setFlags(putFlags).build();
   }
 
-   /**
-    * Creates an immutable {@link PutFlagSet} containing putFlags.
-    * @param putFlags The flags to include in the {@link PutFlagSet}.
-    * @return An immutable {@link PutFlagSet} containing putFlags.
-    */
+  /**
+   * Creates an immutable {@link PutFlagSet} containing putFlags.
+   *
+   * @param putFlags The flags to include in the {@link PutFlagSet}.
+   * @return An immutable {@link PutFlagSet} containing putFlags.
+   */
   static PutFlagSet of(final Collection<PutFlags> putFlags) {
     return builder().setFlags(putFlags).build();
   }
 
-   /**
-    * Create a builder for building an {@link PutFlagSet}.
-    * @return A builder instance for building an {@link PutFlagSet}.
-    */
+  /**
+   * Create a builder for building an {@link PutFlagSet}.
+   *
+   * @return A builder instance for building an {@link PutFlagSet}.
+   */
   static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
         PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, PutFlagSetEmpty::new);
   }
- }
+}
diff --git a/src/main/java/org/lmdbjava/PutFlagSetEmpty.java b/src/main/java/org/lmdbjava/PutFlagSetEmpty.java
index 8119edbe..a017711a 100644
--- a/src/main/java/org/lmdbjava/PutFlagSetEmpty.java
+++ b/src/main/java/org/lmdbjava/PutFlagSetEmpty.java
@@ -16,5 +16,4 @@
 package org.lmdbjava;
 
 class PutFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
-    implements PutFlagSet {
-}
+    implements PutFlagSet {}
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index 7436f5d4..44beb4e3 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -21,13 +21,12 @@
 /** An immutable set of flags for use when creating a {@link Txn}. */
 public interface TxnFlagSet extends FlagSet<TxnFlags> {
 
-  /**
-   * An immutable empty {@link TxnFlagSet}.
-   */
+  /** An immutable empty {@link TxnFlagSet}. */
   TxnFlagSet EMPTY = TxnFlagSetImpl.EMPTY;
 
   /**
    * Gets the immutable empty {@link TxnFlagSet} instance.
+   *
    * @return The immutable empty {@link TxnFlagSet} instance.
    */
   static TxnFlagSet empty() {
@@ -36,6 +35,7 @@ static TxnFlagSet empty() {
 
   /**
    * Creates an immutable {@link TxnFlagSet} containing txnFlag.
+   *
    * @param txnFlag The flag to include in the {@link TxnFlagSet}
    * @return An immutable {@link TxnFlagSet} containing just txnFlag.
    */
@@ -46,6 +46,7 @@ static TxnFlagSet of(final TxnFlags txnFlag) {
 
   /**
    * Creates an immutable {@link TxnFlagSet} containing txnFlags.
+   *
    * @param txnFlags The flags to include in the {@link TxnFlagSet}.
    * @return An immutable {@link TxnFlagSet} containing txnFlags.
    */
@@ -55,6 +56,7 @@ static TxnFlagSet of(final TxnFlags... txnFlags) {
 
   /**
    * Creates an immutable {@link TxnFlagSet} containing txnFlags.
+   *
    * @param txnFlags The flags to include in the {@link TxnFlagSet}.
    * @return An immutable {@link TxnFlagSet} containing txnFlags.
    */
@@ -64,6 +66,7 @@ static TxnFlagSet of(final Collection<TxnFlags> txnFlags) {
 
   /**
    * Create a builder for building an {@link TxnFlagSet}.
+   *
    * @return A builder instance for building an {@link TxnFlagSet}.
    */
   static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
diff --git a/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java b/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java
index 2b7f152d..2c229db9 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java
@@ -16,5 +16,4 @@
 package org.lmdbjava;
 
 class TxnFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
-    implements TxnFlagSet {
-}
+    implements TxnFlagSet {}
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index dcebc722..5dfe5a0d 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -142,23 +142,16 @@ void testAsFlag() {
 
   @Test
   void testAddCollection() {
-    final F flagSet = getBuilder()
-        .addFlags(getAllFlags())
-        .build();
+    final F flagSet = getBuilder().addFlags(getAllFlags()).build();
 
-    assertThat(flagSet.getFlags())
-        .containsExactlyElementsOf(getAllFlags());
+    assertThat(flagSet.getFlags()).containsExactlyElementsOf(getAllFlags());
   }
 
   @Test
   void testClearBuilder() {
-    final F flagSet = getBuilder()
-        .addFlag(getFirst())
-        .clear()
-        .build();
+    final F flagSet = getBuilder().addFlag(getFirst()).clear().build();
 
-    assertThat(flagSet.isEmpty())
-        .isTrue();
+    assertThat(flagSet.isEmpty()).isTrue();
   }
 
   private T[] toArray(final int cnt) {
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 54b57794..a1ac67b7 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -147,9 +147,7 @@ void testLongKey(
   }
 
   private void testCSV(
-      final Function<
-          DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>
-          comparatorFunc,
+      final Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc,
       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
       final DbiFlagSet dbiFlags,
       final String keyType,
@@ -169,9 +167,7 @@ private void testCSV(
   }
 
   private void testCSV(
-      final Function<
-          DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>
-          comparatorFunc,
+      final Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc,
       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
       final DbiFlagSet dbiFlags,
       final String keyType,
@@ -191,10 +187,8 @@ private void testCSV(
               .setEnvFlags(MDB_NOSUBDIR)
               .open(file)) {
 
-        final DbiBuilder.Stage2<ByteBuffer> builderStage2 =
-            env.createDbi().setDbName(DB_1);
-        final DbiBuilder.Stage3<ByteBuffer> builderStage3 =
-            comparatorFunc.apply(builderStage2);
+        final DbiBuilder.Stage2<ByteBuffer> builderStage2 = env.createDbi().setDbName(DB_1);
+        final DbiBuilder.Stage3<ByteBuffer> builderStage3 = comparatorFunc.apply(builderStage2);
         final Dbi<ByteBuffer> dbi = builderStage3.setDbiFlags(dbiFlags).open();
 
         dbPopulator.accept(env, dbi);

From dd95dea98a60cd8bcf60e3a74c41ee9e538be576 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 17:01:58 +0000
Subject: [PATCH 51/90] Add error handling for parse(Int|Long)

---
 .../org/lmdbjava/CursorIterableRangeTest.java |  8 ++++----
 src/test/java/org/lmdbjava/TestUtils.java     | 20 +++++++++++++++++++
 2 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index a1ac67b7..0bd62695 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -222,15 +222,15 @@ private ByteBuffer parseKey(final String key, final int keyLen, final ByteOrder
     if (key != null) {
       if (ByteOrder.nativeOrder().equals(byteOrder)) {
         if (keyLen == Integer.BYTES) {
-          return bbNativeInt(Integer.parseInt(key.trim()));
+          return bbNativeInt(TestUtils.parseInt(key));
         } else {
-          return bbNativeLong(Long.parseLong(key.trim()));
+          return bbNativeLong(TestUtils.parseLong(key));
         }
       } else {
         if (keyLen == Integer.BYTES) {
-          return bb(Integer.parseInt(key.trim()));
+          return bb(TestUtils.parseInt(key));
         } else {
-          return bb(Long.parseLong(key.trim()));
+          return bb(TestUtils.parseLong(key));
         }
       }
     }
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index abaf63bb..00b923fa 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -120,6 +120,26 @@ static byte[] getBytes(final ByteBuffer byteBuffer) {
     return bytes;
   }
 
+  static int parseInt(final String str) {
+    Objects.requireNonNull(str);
+    final String trimmed = str.trim();
+    try {
+      return Integer.parseInt(trimmed);
+    } catch (NumberFormatException e) {
+      throw new RuntimeException("Unable to parse '" + trimmed + "' as an int.");
+    }
+  }
+
+  static long parseLong(final String str) {
+    Objects.requireNonNull(str);
+    final String trimmed = str.trim();
+    try {
+      return Long.parseLong(trimmed);
+    } catch (NumberFormatException e) {
+      throw new RuntimeException("Unable to parse '" + trimmed + "' as a long.");
+    }
+  }
+
   static void invokePrivateConstructor(final Class<?> clazz) {
     try {
       final Constructor<?> c = clazz.getDeclaredConstructor();

From b53378ade4925608fcfc420e2b567d10f055fe13 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 17:04:38 +0000
Subject: [PATCH 52/90] Remove unused code

---
 .../java/org/lmdbjava/AbstractFlagSet.java    | 85 -------------------
 1 file changed, 85 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 99b073d9..71a7416a 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -80,11 +80,6 @@ public Iterator<T> iterator() {
     return flags.iterator();
   }
 
-  @Override
-  public boolean equals(Object object) {
-    return FlagSet.equals(this, object);
-  }
-
   @Override
   public int hashCode() {
     return Objects.hash(flags, mask);
@@ -95,81 +90,6 @@ public String toString() {
     return FlagSet.asString(this);
   }
 
-  abstract static class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag>
-      implements FlagSet<T> {
-
-    private final T flag;
-    // Only holding this for iterator() and getFlags() so make it lazy.
-    private EnumSet<T> enumSet;
-
-    public AbstractSingleFlagSet(final T flag) {
-      this.flag = Objects.requireNonNull(flag);
-    }
-
-    @Override
-    public int getMask() {
-      return flag.getMask();
-    }
-
-    @Override
-    public Set<T> getFlags() {
-      if (enumSet == null) {
-        return initSet();
-      } else {
-        return this.enumSet;
-      }
-    }
-
-    @Override
-    public boolean isSet(final T flag) {
-      return this.flag == flag;
-    }
-
-    @Override
-    public boolean areAnySet(FlagSet<T> flags) {
-      if (flags == null) {
-        return false;
-      } else {
-        return flags.isSet(this.flag);
-      }
-    }
-
-    @Override
-    public int size() {
-      return 1;
-    }
-
-    @Override
-    public boolean isEmpty() {
-      return false;
-    }
-
-    @Override
-    public Iterator<T> iterator() {
-      if (enumSet == null) {
-        return initSet().iterator();
-      } else {
-        return this.enumSet.iterator();
-      }
-    }
-
-    @Override
-    public String toString() {
-      return FlagSet.asString(this);
-    }
-
-    @Override
-    public int hashCode() {
-      return Objects.hash(flag, getFlags());
-    }
-
-    private Set<T> initSet() {
-      final EnumSet<T> set = EnumSet.of(this.flag);
-      this.enumSet = set;
-      return set;
-    }
-  }
-
   static class AbstractEmptyFlagSet<T extends MaskedFlag> implements FlagSet<T> {
 
     @Override
@@ -212,11 +132,6 @@ public String toString() {
       return FlagSet.asString(this);
     }
 
-    @Override
-    public boolean equals(Object object) {
-      return FlagSet.equals(this, object);
-    }
-
     @Override
     public int hashCode() {
       return Objects.hash(getMask(), getFlags());

From deb1f1b41b4c02ab6e5847a39084a2d99dbace04 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 17:12:53 +0000
Subject: [PATCH 53/90] Remove unused code

---
 src/main/java/org/lmdbjava/Key.java | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Key.java b/src/main/java/org/lmdbjava/Key.java
index ac25f65d..d4892b45 100644
--- a/src/main/java/org/lmdbjava/Key.java
+++ b/src/main/java/org/lmdbjava/Key.java
@@ -24,6 +24,7 @@
 
 /**
  * Represents off-heap memory holding a key only.
+ * Equivalent to {@link KeyVal} without the val part.
  *
  * @param <T> buffer type
  */
@@ -31,17 +32,15 @@ final class Key<T> implements AutoCloseable {
 
   private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
   private boolean closed;
-  private T k;
+  private final T k;
   private final BufferProxy<T> proxy;
   private final Pointer ptrKey;
-  private final long ptrKeyAddr;
 
   Key(final BufferProxy<T> proxy) {
     requireNonNull(proxy);
     this.proxy = proxy;
     this.k = proxy.allocate();
     ptrKey = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE, false);
-    ptrKeyAddr = ptrKey.address();
   }
 
   @Override
@@ -53,19 +52,10 @@ public void close() {
     proxy.deallocate(k);
   }
 
-  T key() {
-    return k;
-  }
-
   void keyIn(final T key) {
     proxy.in(key, ptrKey);
   }
 
-  T keyOut() {
-    k = proxy.out(k, ptrKey);
-    return k;
-  }
-
   Pointer pointer() {
     return ptrKey;
   }

From 2bfe07c49c9470e374979b28903cda3c78256527 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 17:15:24 +0000
Subject: [PATCH 54/90] Remove unused hashCode methods

---
 src/main/java/org/lmdbjava/AbstractFlagSet.java | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 71a7416a..2e917515 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -80,11 +80,6 @@ public Iterator<T> iterator() {
     return flags.iterator();
   }
 
-  @Override
-  public int hashCode() {
-    return Objects.hash(flags, mask);
-  }
-
   @Override
   public String toString() {
     return FlagSet.asString(this);
@@ -131,11 +126,6 @@ public Iterator<T> iterator() {
     public String toString() {
       return FlagSet.asString(this);
     }
-
-    @Override
-    public int hashCode() {
-      return Objects.hash(getMask(), getFlags());
-    }
   }
 
   /**

From a84ceaa5b735bcce0a1c3a58a15db5bc49d4da34 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Sun, 9 Nov 2025 19:20:06 +0000
Subject: [PATCH 55/90] Change CursorIterableRangeTest to do default+native
 modes

---
 src/main/java/org/lmdbjava/Key.java           |   3 +-
 .../org/lmdbjava/CursorIterableRangeTest.java | 121 ++++++++++++------
 src/test/java/org/lmdbjava/TestUtils.java     |   2 -
 src/test/java/org/lmdbjava/TutorialTest.java  | 121 ++++++++++++++++++
 4 files changed, 203 insertions(+), 44 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Key.java b/src/main/java/org/lmdbjava/Key.java
index d4892b45..da8bbe6b 100644
--- a/src/main/java/org/lmdbjava/Key.java
+++ b/src/main/java/org/lmdbjava/Key.java
@@ -23,8 +23,7 @@
 import jnr.ffi.provider.MemoryManager;
 
 /**
- * Represents off-heap memory holding a key only.
- * Equivalent to {@link KeyVal} without the val part.
+ * Represents off-heap memory holding a key only. Equivalent to {@link KeyVal} without the val part.
  *
  * @param <T> buffer type
  */
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 0bd62695..46305959 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -18,13 +18,8 @@
 
 import static java.nio.ByteBuffer.allocateDirect;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.lmdbjava.DbiFlags.MDB_CREATE;
-import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
-import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
 import static org.lmdbjava.Env.create;
-import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
 import java.io.File;
@@ -41,14 +36,19 @@
 import java.util.function.Function;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvFileSource;
-import org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy;
 import org.lmdbjava.CursorIterable.KeyVal;
 
 /** Test {@link CursorIterable}. */
 public final class CursorIterableRangeTest {
 
-  private static final DbiFlagSet CREATE_AND_DUPSORT = DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT);
-  private static final DbiFlagSet CREATE_AND_INTEGERKEY = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
+  private static final DbiFlagSet FLAGSET_DUPSORT =
+      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_DUPSORT);
+  private static final DbiFlagSet FLAGSET_REVERSEKEY =
+      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_REVERSEKEY);
+  private static final DbiFlagSet FLAGSET_INTEGERKEY =
+      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY);
+  private static final DbiFlagSet FLAGSET_REVERSE_INTEGERKEY =
+      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_REVERSEKEY);
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testSignedComparator.csv")
@@ -57,7 +57,7 @@ void testSignedComparator(
     testCSV(
         builder -> builder.withCallbackComparator(ignored -> ByteBuffer::compareTo),
         createBasicDBPopulator(),
-        MDB_CREATE,
+        DbiFlags.MDB_CREATE,
         keyType,
         startKey,
         stopKey,
@@ -68,16 +68,21 @@ void testSignedComparator(
   @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparator.csv")
   void testUnsignedComparator(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(
-        builder ->
-            builder.withIteratorComparator(
-                ignored -> AbstractByteBufferProxy::compareLexicographically),
-        createBasicDBPopulator(),
-        MDB_CREATE,
-        keyType,
-        startKey,
-        stopKey,
-        expectedKV);
+    testCSV(createBasicDBPopulator(), DbiFlags.MDB_CREATE, keyType, startKey, stopKey, expectedKV);
+  }
+
+  @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
+  @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparator.csv")
+  void testUnsignedComparator_Iterator(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(createBasicDBPopulator(), DbiFlags.MDB_CREATE, keyType, startKey, stopKey, expectedKV);
+  }
+
+  @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
+  @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparator.csv")
+  void testUnsignedComparator_Callback(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(createBasicDBPopulator(), DbiFlags.MDB_CREATE, keyType, startKey, stopKey, expectedKV);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
@@ -87,7 +92,7 @@ void testSignedComparatorDupsort(
     testCSV(
         builder -> builder.withCallbackComparator(ignored -> ByteBuffer::compareTo),
         createMultiDBPopulator(2),
-        CREATE_AND_DUPSORT,
+        FLAGSET_DUPSORT,
         keyType,
         startKey,
         stopKey,
@@ -98,16 +103,7 @@ void testSignedComparatorDupsort(
   @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv")
   void testUnsignedComparatorDupsort(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(
-        builder ->
-            builder.withIteratorComparator(
-                ignored -> AbstractByteBufferProxy::compareLexicographically),
-        createMultiDBPopulator(2),
-        CREATE_AND_DUPSORT,
-        keyType,
-        startKey,
-        stopKey,
-        expectedKV);
+    testCSV(createMultiDBPopulator(2), FLAGSET_DUPSORT, keyType, startKey, stopKey, expectedKV);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
@@ -115,11 +111,8 @@ void testUnsignedComparatorDupsort(
   void testIntegerKey(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        builder ->
-            builder.withIteratorComparator(
-                ignored -> AbstractByteBufferProxy::compareAsIntegerKeys),
         createIntegerDBPopulator(),
-        DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY),
+        FLAGSET_INTEGERKEY,
         keyType,
         startKey,
         stopKey,
@@ -133,11 +126,8 @@ void testIntegerKey(
   void testLongKey(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        builder ->
-            builder.withIteratorComparator(
-                ignored -> AbstractByteBufferProxy::compareAsIntegerKeys),
         createLongDBPopulator(),
-        CREATE_AND_INTEGERKEY,
+        FLAGSET_INTEGERKEY,
         keyType,
         startKey,
         stopKey,
@@ -166,6 +156,58 @@ private void testCSV(
         ByteOrder.BIG_ENDIAN);
   }
 
+  private void testCSV(
+      final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
+      final DbiFlagSet dbiFlags,
+      final String keyType,
+      final String startKey,
+      final String stopKey,
+      final String expectedKV) {
+    testCSV(
+        dbPopulator,
+        dbiFlags,
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        Integer.BYTES,
+        ByteOrder.BIG_ENDIAN);
+  }
+
+  private void testCSV(
+      final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
+      final DbiFlagSet dbiFlags,
+      final String keyType,
+      final String startKey,
+      final String stopKey,
+      final String expectedKV,
+      final int keyLen,
+      final ByteOrder byteOrder) {
+    // First test with our default iterator comparator
+    testCSV(
+        DbiBuilder.Stage2::withDefaultComparator,
+        dbPopulator,
+        dbiFlags,
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        keyLen,
+        byteOrder);
+
+    // Now test with mdp_cmp doing all comparisons, should be the same
+    testCSV(
+        DbiBuilder.Stage2::withNativeComparator,
+        dbPopulator,
+        dbiFlags,
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        keyLen,
+        byteOrder);
+  }
+
   private void testCSV(
       final Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc,
       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
@@ -183,8 +225,7 @@ private void testCSV(
               .setMapSize(256, ByteUnit.KIBIBYTES)
               .setMaxReaders(1)
               .setMaxDbs(1)
-              .setFilePermissions(POSIX_MODE)
-              .setEnvFlags(MDB_NOSUBDIR)
+              .setEnvFlags(EnvFlags.MDB_NOSUBDIR)
               .open(file)) {
 
         final DbiBuilder.Stage2<ByteBuffer> builderStage2 = env.createDbi().setDbName(DB_1);
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 00b923fa..1dd04d50 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -38,8 +38,6 @@ final class TestUtils {
   public static final String DB_3 = "test-db-3";
   public static final String DB_4 = "test-db-2";
 
-  public static final int POSIX_MODE = 0664;
-
   private TestUtils() {}
 
   static byte[] ba(final int value) {
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index ac16774f..096e990b 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -22,6 +22,8 @@
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
+import static org.lmdbjava.DbiFlags.MDB_REVERSEKEY;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 import static org.lmdbjava.GetOp.MDB_SET;
 import static org.lmdbjava.SeekOp.MDB_FIRST;
@@ -29,7 +31,10 @@
 import static org.lmdbjava.SeekOp.MDB_PREV;
 
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import org.agrona.DirectBuffer;
@@ -470,6 +475,122 @@ void tutorial7() {
     env.close();
   }
 
+  /**
+   * In this tutorial we'll look at using keys that are longs. The same approach applies would apply
+   * to int keys.
+   */
+  @Test
+  void tutorial8() {
+    final Path dir = tempDir.createTempDir();
+    final Env<ByteBuffer> env = createSimpleEnv(dir);
+
+    // This time we're going to tell the Dbi that all the keys are integers.
+    // MDB_INTEGERKEY applies to both int and long keys.
+    // LMDB can make optimisations for better performance.
+    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY));
+
+    // MDB_INTEGERKEY requires that the keys are written/read in native order
+    final ByteBuffer key = ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer val = ByteBuffer.allocateDirect(100);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+
+      // Store one key, but many values, and in non-natural order.
+      key.putLong(42L).flip();
+      val.put("val-42".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      key.clear();
+      val.clear();
+      key.putLong(1L).flip();
+      val.put("val-1".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      key.clear();
+      val.clear();
+      key.putLong(Long.MAX_VALUE).flip();
+      val.put(("val-" + Long.MAX_VALUE).getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      key.clear();
+      val.clear();
+      key.putLong(1_000L).flip();
+      val.put("val-1".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      // Get all the keys
+      final List<Long> keys = new ArrayList<>();
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
+          assertThat(kv.key()).isNotNull();
+          assertThat(kv.val()).isNotNull();
+          keys.add(kv.key().order(ByteOrder.nativeOrder()).getLong());
+        }
+      }
+
+      assertThat(keys).containsExactly(1L, 42L, 1_000L, Long.MAX_VALUE);
+
+      txn.commit();
+    }
+    env.close();
+  }
+
+  /** In this tutorial we'll look storing the data in reverse order */
+  @Test
+  void tutorial9() {
+    final Path dir = tempDir.createTempDir();
+    final Env<ByteBuffer> env = createSimpleEnv(dir);
+
+    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_REVERSEKEY));
+
+    final ByteBuffer key = ByteBuffer.allocateDirect(100);
+    final ByteBuffer val = ByteBuffer.allocateDirect(100);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+
+      // Store one key, but many values, and in non-natural order.
+      key.put("tac".getBytes(UTF_8)).flip();
+      val.put("CAT".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      key.clear();
+      val.clear();
+      key.put("god".getBytes(UTF_8)).flip();
+      val.put("DOG".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      key.clear();
+      val.clear();
+      key.put("esroh".getBytes(UTF_8)).flip();
+      val.put("HORSE".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      key.clear();
+      val.clear();
+      key.put("tnahpele".getBytes(UTF_8)).flip();
+      val.put("ELEPHANT".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      // Get all the keys
+      final List<String> keys = new ArrayList<>();
+      final List<String> values = new ArrayList<>();
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
+          assertThat(kv.key()).isNotNull();
+          assertThat(kv.val()).isNotNull();
+          keys.add(UTF_8.decode(kv.key()).toString());
+          values.add(UTF_8.decode(kv.val()).toString());
+        }
+      }
+
+      assertThat(keys).containsExactly("tac", "god", "tnahpele", "esroh");
+      assertThat(values).containsExactly("CAT", "DOG", "ELEPHANT", "HORSE");
+
+      txn.commit();
+    }
+    env.close();
+  }
+
   // You've finished! There are lots of other neat things we could show you (eg
   // how to speed up inserts by appending them in key order, using integer
   // or reverse ordered keys, using Env.DISABLE_CHECKS_PROP etc), but you now

From a5e4cf276c96187feff917201d997cbceef1bb4b Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Sun, 9 Nov 2025 19:23:40 +0000
Subject: [PATCH 56/90] Remove separator comments

---
 src/main/java/org/lmdbjava/ByteBufferProxy.java | 6 ------
 src/main/java/org/lmdbjava/Env.java             | 2 --
 2 files changed, 8 deletions(-)

diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 52bfc924..25218fe4 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -86,8 +86,6 @@ public BufferMustBeDirectException() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -246,8 +244,6 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -292,8 +288,6 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index d6fa7dc2..d43ebd0f 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -688,8 +688,6 @@ public AlreadyOpenException() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
   /**
    * Builder for configuring and opening Env.
    *

From f8e6e076ee0d6b91a039d680426efb4861747ad7 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Sun, 9 Nov 2025 19:32:08 +0000
Subject: [PATCH 57/90] Add more tests to CursorIterableRangeTest

---
 .../org/lmdbjava/CursorIterableRangeTest.java | 66 +++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 46305959..809b5065 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -47,6 +47,8 @@ public final class CursorIterableRangeTest {
       DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_REVERSEKEY);
   private static final DbiFlagSet FLAGSET_INTEGERKEY =
       DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY);
+  private static final DbiFlagSet FLAGSET_INTEGERKEY_DUPSORT =
+      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_DUPSORT);
   private static final DbiFlagSet FLAGSET_REVERSE_INTEGERKEY =
       DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_REVERSEKEY);
 
@@ -121,6 +123,21 @@ void testIntegerKey(
         ByteOrder.nativeOrder());
   }
 
+  @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
+  @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv")
+  void testIntegerKeyDupSort(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        createMultiIntegerDBPopulator(2),
+        FLAGSET_INTEGERKEY_DUPSORT,
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        Integer.BYTES,
+        ByteOrder.nativeOrder());
+  }
+
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testLongKey.csv")
   void testLongKey(
@@ -136,6 +153,21 @@ void testLongKey(
         ByteOrder.nativeOrder());
   }
 
+  @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
+  @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv")
+  void testLongKeyDupSort(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        createMultiLongDBPopulator(2),
+        FLAGSET_INTEGERKEY_DUPSORT,
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        Long.BYTES,
+        ByteOrder.nativeOrder());
+  }
+
   private void testCSV(
       final Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc,
       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
@@ -319,6 +351,40 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiDBPopulator(fina
     };
   }
 
+  private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiIntegerDBPopulator(final int copies) {
+    return (env, dbi) -> {
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+        for (int i = 0; i < copies; i++) {
+          c.put(bbNativeInt(0), bb(1 + i));
+          c.put(bbNativeInt(2), bb(3 + i));
+          c.put(bbNativeInt(4), bb(5 + i));
+          c.put(bbNativeInt(6), bb(7 + i));
+          c.put(bbNativeInt(8), bb(9 + i));
+          c.put(bbNativeInt(-2), bb(-1 + i));
+        }
+        txn.commit();
+      }
+    };
+  }
+
+  private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiLongDBPopulator(final int copies) {
+    return (env, dbi) -> {
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+        for (int i = 0; i < copies; i++) {
+          c.put(bbNativeLong(0), bb(1 + i));
+          c.put(bbNativeLong(2), bb(3 + i));
+          c.put(bbNativeLong(4), bb(5 + i));
+          c.put(bbNativeLong(6), bb(7 + i));
+          c.put(bbNativeLong(8), bb(9 + i));
+          c.put(bbNativeLong(-2), bb(-1 + i));
+        }
+        txn.commit();
+      }
+    };
+  }
+
   private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createIntegerDBPopulator() {
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {

From 6982acad6a4150de8187df2a0d39bb0087e5e1fb Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Sun, 9 Nov 2025 19:33:27 +0000
Subject: [PATCH 58/90] Remove unused test, auto format

---
 .../CursorIterableIntegerDupTest.java         | 593 ------------------
 .../org/lmdbjava/CursorIterableRangeTest.java |   6 +-
 2 files changed, 4 insertions(+), 595 deletions(-)
 delete mode 100644 src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java

diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
deleted file mode 100644
index e751e458..00000000
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ /dev/null
@@ -1,593 +0,0 @@
-/*
- * Copyright © 2016-2025 The LmdbJava Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.lmdbjava;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.lmdbjava.DbiFlags.MDB_CREATE;
-import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
-import static org.lmdbjava.DbiFlags.MDB_INTEGERDUP;
-import static org.lmdbjava.Env.create;
-import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
-import static org.lmdbjava.KeyRange.all;
-import static org.lmdbjava.KeyRange.allBackward;
-import static org.lmdbjava.KeyRange.atLeast;
-import static org.lmdbjava.KeyRange.atLeastBackward;
-import static org.lmdbjava.KeyRange.atMost;
-import static org.lmdbjava.KeyRange.atMostBackward;
-import static org.lmdbjava.KeyRange.closed;
-import static org.lmdbjava.KeyRange.closedBackward;
-import static org.lmdbjava.KeyRange.closedOpen;
-import static org.lmdbjava.KeyRange.closedOpenBackward;
-import static org.lmdbjava.KeyRange.greaterThan;
-import static org.lmdbjava.KeyRange.greaterThanBackward;
-import static org.lmdbjava.KeyRange.lessThan;
-import static org.lmdbjava.KeyRange.lessThanBackward;
-import static org.lmdbjava.KeyRange.open;
-import static org.lmdbjava.KeyRange.openBackward;
-import static org.lmdbjava.KeyRange.openClosed;
-import static org.lmdbjava.KeyRange.openClosedBackward;
-import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.DB_2;
-import static org.lmdbjava.TestUtils.DB_3;
-import static org.lmdbjava.TestUtils.DB_4;
-import static org.lmdbjava.TestUtils.bb;
-import static org.lmdbjava.TestUtils.bbNative;
-import static org.lmdbjava.TestUtils.getNativeInt;
-import static org.lmdbjava.TestUtils.getNativeIntOrLong;
-
-import com.google.common.primitives.UnsignedBytes;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.AbstractMap;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.Deque;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import org.assertj.core.api.Assertions;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtensionContext;
-import org.junit.jupiter.params.Parameter;
-import org.junit.jupiter.params.ParameterizedClass;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.ArgumentsProvider;
-import org.junit.jupiter.params.provider.ArgumentsSource;
-import org.junit.jupiter.params.support.ParameterDeclarations;
-import org.lmdbjava.CursorIterable.KeyVal;
-
-/**
- * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that comparators work
- * with native order integer keys.
- */
-@Disabled // Waiting for the merge of stroomdev66's cursor tests
-@ParameterizedClass(name = "{index}: dbi: {0}")
-@ArgumentsSource(CursorIterableIntegerDupTest.MyArgumentProvider.class)
-public final class CursorIterableIntegerDupTest {
-
-  private static final DbiFlagSet DBI_FLAGS =
-      DbiFlagSet.of(MDB_CREATE, MDB_INTEGERDUP, MDB_DUPSORT);
-  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
-  private static final List<Map.Entry<Integer, Integer>> INPUT_DATA;
-
-  static {
-    // 2 => 21
-    // 2 => 22
-    // 3 => 31
-    // ...
-    // 9 => 92
-    INPUT_DATA = new ArrayList<>();
-    for (int i = 2; i <= 9; i++) {
-      final int val1 = (i * 10) + 1;
-      final int val2 = (i * 10) + 2;
-      INPUT_DATA.add(new AbstractMap.SimpleEntry<>(i, val1));
-      INPUT_DATA.add(new AbstractMap.SimpleEntry<>(i, val2));
-    }
-  }
-
-  private TempDir tempDir;
-  private Env<ByteBuffer> env;
-  private Deque<Map.Entry<Integer, Integer>> expectedEntriesDeque;
-
-  @Parameter public DbiFactory dbiFactory;
-
-  @BeforeEach
-  public void before() throws IOException {
-    tempDir = new TempDir();
-    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env =
-        create(bufferProxy)
-            .setMapSize(256, ByteUnit.KIBIBYTES)
-            .setMaxReaders(1)
-            .setMaxDbs(3)
-            .setEnvFlags(MDB_NOSUBDIR)
-            .open(tempDir.createTempFile());
-
-    populateExpectedEntriesDeque();
-  }
-
-  @AfterEach
-  public void after() {
-    env.close();
-    tempDir.cleanup();
-  }
-
-  @Test
-  public void allBackwardTest() {
-    verify(allBackward(), 8, 6, 4, 2);
-  }
-
-  @Test
-  public void allTest() {
-    verify(all(), 2, 4, 6, 8);
-  }
-
-  @Test
-  public void atLeastBackwardTest() {
-    verify(atLeastBackward(bbNative(5)), 4, 2);
-    verify(atLeastBackward(bbNative(6)), 6, 4, 2);
-    verify(atLeastBackward(bbNative(9)), 8, 6, 4, 2);
-  }
-
-  @Test
-  public void atLeastTest() {
-    verify(atLeast(bbNative(5)), 6, 8);
-    verify(atLeast(bbNative(6)), 6, 8);
-  }
-
-  @Test
-  public void atMostBackwardTest() {
-    verify(atMostBackward(bbNative(5)), 8, 6);
-    verify(atMostBackward(bbNative(6)), 8, 6);
-  }
-
-  @Test
-  public void atMostTest() {
-    verify(atMost(bbNative(5)), 2, 4);
-    verify(atMost(bbNative(6)), 2, 4, 6);
-  }
-
-  private void populateExpectedEntriesDeque() {
-    expectedEntriesDeque = new LinkedList<>();
-    expectedEntriesDeque.addAll(INPUT_DATA);
-  }
-
-  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-      for (Map.Entry<Integer, Integer> entry : INPUT_DATA) {
-        c.put(bbNative(entry.getKey()), bb(entry.getValue()));
-      }
-      txn.commit();
-    }
-    //    try (Txn<ByteBuffer> txn = env.txnRead();
-    //         CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
-    //
-    //      for (final KeyVal<ByteBuffer> kv : c) {
-    //        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
-    //        System.out.print(", ");
-    //      }
-    //      System.out.println();
-    //    }
-  }
-
-  private int[] rangeInc(final int fromInc, final int toInc) {
-    int idx = 0;
-    if (fromInc <= toInc) {
-      // Forwards
-      final int[] arr = new int[toInc - fromInc + 1];
-      for (int i = fromInc; i <= toInc; i++) {
-        arr[idx++] = i;
-      }
-      return arr;
-    } else {
-      // Backwards
-      final int[] arr = new int[fromInc - toInc + 1];
-      for (int i = fromInc; i >= toInc; i--) {
-        arr[idx++] = i;
-      }
-      return arr;
-    }
-  }
-
-  @Test
-  public void closedBackwardTest() {
-    verify(closedBackward(bbNative(7), bbNative(3)), rangeInc(7, 3));
-    verify(closedBackward(bbNative(6), bbNative(2)), rangeInc(6, 2));
-    verify(closedBackward(bbNative(9), bbNative(3)), rangeInc(9, 3));
-  }
-
-  @Test
-  public void closedOpenBackwardTest() {
-    verify(closedOpenBackward(bbNative(8), bbNative(3)), rangeInc(8, 4));
-    verify(closedOpenBackward(bbNative(7), bbNative(2)), rangeInc(7, 3));
-    verify(closedOpenBackward(bbNative(9), bbNative(3)), rangeInc(9, 4));
-  }
-
-  @Test
-  public void closedOpenTest() {
-    verify(closedOpen(bbNative(3), bbNative(8)), rangeInc(3, 7));
-    verify(closedOpen(bbNative(2), bbNative(6)), rangeInc(2, 5));
-  }
-
-  @Test
-  public void closedTest() {
-    verify(closed(bbNative(3), bbNative(7)), rangeInc(3, 7));
-    verify(closed(bbNative(2), bbNative(6)), rangeInc(2, 6));
-    verify(closed(bbNative(1), bbNative(7)), rangeInc(2, 7));
-  }
-
-  @Test
-  public void greaterThanBackwardTest() {
-    verify(greaterThanBackward(bbNative(6)), rangeInc(5, 2));
-    verify(greaterThanBackward(bbNative(7)), rangeInc(6, 2));
-    verify(greaterThanBackward(bbNative(9)), rangeInc(8, 2));
-  }
-
-  @Test
-  public void greaterThanTest() {
-    verify(greaterThan(bbNative(4)), rangeInc(5, 9));
-    verify(greaterThan(bbNative(3)), rangeInc(4, 9));
-  }
-
-  public void iterableOnlyReturnedOnce() {
-    Assertions.assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = getDb();
-              try (Txn<ByteBuffer> txn = env.txnRead();
-                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-                c.iterator(); // ok
-                c.iterator(); // fails
-              }
-            })
-        .isInstanceOf(IllegalStateException.class);
-  }
-
-  @Test
-  public void iterate() {
-    populateExpectedEntriesDeque();
-    final Dbi<ByteBuffer> db = getDb();
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-
-      for (final KeyVal<ByteBuffer> kv : c) {
-        final Map.Entry<Integer, Integer> entry = expectedEntriesDeque.pollFirst();
-        assertThat(entry).isNotNull();
-        //        System.out.println(entry.getKey() + " => " + entry.getValue());
-        assertThat(getNativeInt(kv.key())).isEqualTo(entry.getKey());
-        assertThat(kv.val().getInt()).isEqualTo(entry.getValue());
-      }
-    }
-  }
-
-  public void iteratorOnlyReturnedOnce() {
-    Assertions.assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = getDb();
-              try (Txn<ByteBuffer> txn = env.txnRead();
-                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-                c.iterator(); // ok
-                c.iterator(); // fails
-              }
-            })
-        .isInstanceOf(IllegalStateException.class);
-  }
-
-  @Test
-  public void lessThanBackwardTest() {
-    verify(lessThanBackward(bbNative(5)), 8, 6);
-    verify(lessThanBackward(bbNative(2)), 8, 6, 4);
-  }
-
-  @Test
-  public void lessThanTest() {
-    verify(lessThan(bbNative(5)), 2, 4);
-    verify(lessThan(bbNative(8)), 2, 4, 6);
-  }
-
-  @Test
-  public void openBackwardTest() {
-    verify(openBackward(bbNative(7), bbNative(2)), 6, 4);
-    verify(openBackward(bbNative(8), bbNative(1)), 6, 4, 2);
-    verify(openBackward(bbNative(9), bbNative(4)), 8, 6);
-  }
-
-  @Test
-  public void openClosedBackwardTest() {
-    verify(openClosedBackward(bbNative(7), bbNative(2)), 6, 4, 2);
-    verify(openClosedBackward(bbNative(8), bbNative(4)), 6, 4);
-    verify(openClosedBackward(bbNative(9), bbNative(4)), 8, 6, 4);
-  }
-
-  @Test
-  public void openClosedBackwardTestWithGuava() {
-    final Comparator<byte[]> guava = UnsignedBytes.lexicographicalComparator();
-    final Comparator<ByteBuffer> comparator =
-        (bb1, bb2) -> {
-          final byte[] array1 = new byte[bb1.remaining()];
-          final byte[] array2 = new byte[bb2.remaining()];
-          bb1.mark();
-          bb2.mark();
-          bb1.get(array1);
-          bb2.get(array2);
-          bb1.reset();
-          bb2.reset();
-          return guava.compare(array1, array2);
-        };
-
-    final Dbi<ByteBuffer> guavaDbi =
-        env.createDbi()
-            .setDbName(DB_1)
-            .withIteratorComparator(ignored -> comparator)
-            .setDbiFlags(MDB_CREATE)
-            .open();
-
-    populateDatabase(guavaDbi);
-    verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
-    verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
-  }
-
-  @Test
-  public void openClosedTest() {
-    verify(openClosed(bbNative(3), bbNative(8)), 4, 6, 8);
-    verify(openClosed(bbNative(2), bbNative(6)), 4, 6);
-  }
-
-  @Test
-  public void openTest() {
-    verify(open(bbNative(3), bbNative(7)), 4, 6);
-    verify(open(bbNative(2), bbNative(8)), 4, 6);
-  }
-
-  @Test
-  public void removeOddElements() {
-    final Dbi<ByteBuffer> db = getDb();
-    verify(db, all(), 2, 4, 6, 8);
-    int idx = -1;
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-        while (c.hasNext()) {
-          c.next();
-          idx++;
-          if (idx % 2 == 0) {
-            c.remove();
-          }
-        }
-      }
-      txn.commit();
-    }
-    verify(db, all(), 4, 8);
-  }
-
-  public void nextWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = getDb();
-              try (Txn<ByteBuffer> txn = env.txnRead()) {
-                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-                  env.close();
-                  c.next();
-                }
-              }
-            })
-        .isInstanceOf(Env.AlreadyClosedException.class);
-  }
-
-  public void removeWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = getDb();
-              try (Txn<ByteBuffer> txn = env.txnWrite()) {
-                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-                  final KeyVal<ByteBuffer> keyVal = c.next();
-                  assertThat(keyVal).isNotNull();
-                  env.close();
-                  c.remove();
-                }
-              }
-            })
-        .isInstanceOf(Env.AlreadyClosedException.class);
-  }
-
-  public void hasNextWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = getDb();
-              try (Txn<ByteBuffer> txn = env.txnRead()) {
-                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-                  env.close();
-                  c.hasNext();
-                }
-              }
-            })
-        .isInstanceOf(Env.AlreadyClosedException.class);
-  }
-
-  public void forEachRemainingWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = getDb();
-              try (Txn<ByteBuffer> txn = env.txnRead()) {
-                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-                  env.close();
-                  c.forEachRemaining(keyVal -> {});
-                }
-              }
-            })
-        .isInstanceOf(Env.AlreadyClosedException.class);
-  }
-
-  private void verify(final KeyRange<ByteBuffer> range, final int... expectedKeys) {
-    // Verify using all comparator types
-    final Dbi<ByteBuffer> db = getDb();
-    verify(range, db, expectedKeys);
-  }
-
-  private void verify(
-      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expectedKeys) {
-    verify(range, dbi, expectedKeys);
-  }
-
-  private void verify(
-      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expectedKeys) {
-    final boolean isForward = range.getType().isDirectionForward();
-
-    final List<Integer> expectedValues =
-        Arrays.stream(expectedKeys)
-            .boxed()
-            .flatMap(
-                key -> {
-                  final int base = key * 10;
-                  return isForward ? Stream.of(base + 1, base + 2) : Stream.of(base + 2, base + 1);
-                })
-            .collect(Collectors.toList());
-
-    final List<Integer> results = new ArrayList<>();
-    //    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
-
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
-      for (final KeyVal<ByteBuffer> kv : c) {
-        final int key = getNativeInt(kv.key());
-        final int val = kv.val().getInt();
-        //        System.out.println(key + " => " + val);
-        results.add(val);
-        assertThat(val)
-            .satisfiesAnyOf(
-                v -> assertThat(v).isEqualTo((key * 10) + 1),
-                v -> assertThat(v).isEqualTo((key * 10) + 2));
-      }
-    }
-
-    assertThat(results).hasSize(expectedValues.size());
-    for (int idx = 0; idx < results.size(); idx++) {
-      assertThat(results.get(idx)).isEqualTo(expectedValues.get(idx));
-    }
-  }
-
-  private String rangeToString(final KeyRange<ByteBuffer> range) {
-    final ByteBuffer start = range.getStart();
-    final ByteBuffer stop = range.getStop();
-    return range.getType()
-        + " start: "
-        + (start != null ? getNativeInt(start) : "")
-        + " stop: "
-        + (stop != null ? getNativeInt(stop) : "");
-  }
-
-  private Dbi<ByteBuffer> getDb() {
-    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
-    populateDatabase(dbi);
-    return dbi;
-  }
-
-  private static class DbiFactory {
-    private final String name;
-    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
-
-    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
-      this.name = name;
-      this.factory = factory;
-    }
-
-    @Override
-    public String toString() {
-      return name;
-    }
-  }
-
-  static class MyArgumentProvider implements ArgumentsProvider {
-
-    @Override
-    public Stream<? extends Arguments> provideArguments(
-        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
-      final DbiFactory defaultComparatorDb =
-          new DbiFactory(
-              "defaultComparator",
-              env ->
-                  env.createDbi()
-                      .setDbName(DB_1)
-                      .withDefaultComparator()
-                      .setDbiFlags(DBI_FLAGS)
-                      .open());
-      final DbiFactory nativeComparatorDb =
-          new DbiFactory(
-              "nativeComparator",
-              env ->
-                  env.createDbi()
-                      .setDbName(DB_2)
-                      .withNativeComparator()
-                      .setDbiFlags(DBI_FLAGS)
-                      .open());
-      final DbiFactory callbackComparatorDb =
-          new DbiFactory(
-              "callbackComparator",
-              env ->
-                  env.createDbi()
-                      .setDbName(DB_3)
-                      .withCallbackComparator(MyArgumentProvider::buildComparator)
-                      .setDbiFlags(DBI_FLAGS)
-                      .open());
-      final DbiFactory iteratorComparatorDb =
-          new DbiFactory(
-              "iteratorComparator",
-              env ->
-                  env.createDbi()
-                      .setDbName(DB_4)
-                      .withIteratorComparator(MyArgumentProvider::buildComparator)
-                      .setDbiFlags(DBI_FLAGS)
-                      .open());
-      return Stream.of(
-              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
-          .map(Arguments::of);
-    }
-
-    private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSet) {
-      final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
-      return (o1, o2) -> {
-        if (o1.remaining() != o2.remaining()) {
-          // Make sure LMDB is always giving us consistent key lengths.
-          Assertions.fail(
-              "o1: "
-                  + o1
-                  + " "
-                  + getNativeIntOrLong(o1)
-                  + ", o2: "
-                  + o2
-                  + " "
-                  + getNativeIntOrLong(o2));
-        }
-        return baseComparator.compare(o1, o2);
-      };
-    }
-  }
-}
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 809b5065..8c4868f0 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -351,7 +351,8 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiDBPopulator(fina
     };
   }
 
-  private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiIntegerDBPopulator(final int copies) {
+  private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiIntegerDBPopulator(
+      final int copies) {
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
@@ -368,7 +369,8 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiIntegerDBPopulat
     };
   }
 
-  private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiLongDBPopulator(final int copies) {
+  private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiLongDBPopulator(
+      final int copies) {
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);

From 6740e2bd927bb04280b1f68e2b4a1e8d69fe5589 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 12 Nov 2025 08:57:59 +0000
Subject: [PATCH 59/90] Add tests to stop CodeQL warnings

---
 src/test/java/org/lmdbjava/AbstractFlagSetTest.java |  1 +
 src/test/java/org/lmdbjava/CopyFlagSetTest.java     | 10 ++++++++++
 src/test/java/org/lmdbjava/DbiFlagSetTest.java      | 10 ++++++++++
 src/test/java/org/lmdbjava/EnvFlagSetTest.java      | 10 ++++++++++
 src/test/java/org/lmdbjava/PutFlagSetTest.java      |  9 +++++++++
 src/test/java/org/lmdbjava/TxnFlagSetTest.java      | 10 ++++++++++
 6 files changed, 50 insertions(+)

diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index 5dfe5a0d..bef97911 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -99,6 +99,7 @@ void testAllFlags() {
       final F flagSet = getBuilder().setFlags(flags).build();
       final int flagSetMask = flagSet.getMask();
 
+      // Make sure all the mask values are unique
       assertThat(masks).doesNotContain(flagSetMask);
       masks.add(flagSetMask);
       assertThat(flagSetMask).isEqualTo(MaskedFlag.mask(flags));
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 559bd8ea..ec9005bd 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -19,9 +19,19 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.stream.Collectors;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 class CopyFlagSetTest extends AbstractFlagSetTest<CopyFlags, CopyFlagSet> {
 
+  @Test
+  void test() {
+    // This is here purely to stop CodeQL moaning that this class is unused.
+    // All the actual tests are in the superclass
+    Assertions.assertThat(getAllFlags())
+        .isNotNull();
+  }
+
   @Override
   List<CopyFlags> getAllFlags() {
     return Arrays.stream(CopyFlags.values()).collect(Collectors.toList());
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index be97aea6..ce9c1ec9 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -19,9 +19,19 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.stream.Collectors;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 class DbiFlagSetTest extends AbstractFlagSetTest<DbiFlags, DbiFlagSet> {
 
+  @Test
+  void test() {
+    // This is here purely to stop CodeQL moaning that this class is unused.
+    // All the actual tests are in the superclass
+    Assertions.assertThat(getAllFlags())
+        .isNotNull();
+  }
+
   @Override
   List<DbiFlags> getAllFlags() {
     return Arrays.stream(DbiFlags.values()).collect(Collectors.toList());
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index 35fcc001..1c5110c3 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -19,9 +19,19 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.stream.Collectors;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 class EnvFlagSetTest extends AbstractFlagSetTest<EnvFlags, EnvFlagSet> {
 
+  @Test
+  void test() {
+    // This is here purely to stop CodeQL moaning that this class is unused.
+    // All the actual tests are in the superclass
+    Assertions.assertThat(getAllFlags())
+        .isNotNull();
+  }
+
   @Override
   List<EnvFlags> getAllFlags() {
     return Arrays.stream(EnvFlags.values()).collect(Collectors.toList());
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 9b6f3a09..9cb4504d 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -22,10 +22,19 @@
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 class PutFlagSetTest extends AbstractFlagSetTest<PutFlags, PutFlagSet> {
 
+  @Test
+  void test() {
+    // This is here purely to stop CodeQL moaning that this class is unused.
+    // All the actual tests are in the superclass
+    Assertions.assertThat(getAllFlags())
+        .isNotNull();
+  }
+
   @Override
   List<PutFlags> getAllFlags() {
     return Arrays.stream(PutFlags.values()).collect(Collectors.toList());
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 3ef93195..27e8c4cf 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -19,9 +19,19 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.stream.Collectors;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
 
+  @Test
+  void test() {
+    // This is here purely to stop CodeQL moaning that this class is unused.
+    // All the actual tests are in the superclass
+    Assertions.assertThat(getAllFlags())
+        .isNotNull();
+  }
+
   @Override
   List<TxnFlags> getAllFlags() {
     return Arrays.stream(TxnFlags.values()).collect(Collectors.toList());

From 0103f134b51cd1e93e4e9e18c9e648a1e4dfe201 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 12 Nov 2025 09:01:03 +0000
Subject: [PATCH 60/90] Auto format

---
 src/test/java/org/lmdbjava/CopyFlagSetTest.java | 3 +--
 src/test/java/org/lmdbjava/DbiFlagSetTest.java  | 3 +--
 src/test/java/org/lmdbjava/EnvFlagSetTest.java  | 3 +--
 src/test/java/org/lmdbjava/PutFlagSetTest.java  | 3 +--
 src/test/java/org/lmdbjava/TxnFlagSetTest.java  | 3 +--
 5 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index ec9005bd..96203af9 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -28,8 +28,7 @@ class CopyFlagSetTest extends AbstractFlagSetTest<CopyFlags, CopyFlagSet> {
   void test() {
     // This is here purely to stop CodeQL moaning that this class is unused.
     // All the actual tests are in the superclass
-    Assertions.assertThat(getAllFlags())
-        .isNotNull();
+    Assertions.assertThat(getAllFlags()).isNotNull();
   }
 
   @Override
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index ce9c1ec9..5be7bc60 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -28,8 +28,7 @@ class DbiFlagSetTest extends AbstractFlagSetTest<DbiFlags, DbiFlagSet> {
   void test() {
     // This is here purely to stop CodeQL moaning that this class is unused.
     // All the actual tests are in the superclass
-    Assertions.assertThat(getAllFlags())
-        .isNotNull();
+    Assertions.assertThat(getAllFlags()).isNotNull();
   }
 
   @Override
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index 1c5110c3..24300c1f 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -28,8 +28,7 @@ class EnvFlagSetTest extends AbstractFlagSetTest<EnvFlags, EnvFlagSet> {
   void test() {
     // This is here purely to stop CodeQL moaning that this class is unused.
     // All the actual tests are in the superclass
-    Assertions.assertThat(getAllFlags())
-        .isNotNull();
+    Assertions.assertThat(getAllFlags()).isNotNull();
   }
 
   @Override
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 9cb4504d..93d3aab0 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -31,8 +31,7 @@ class PutFlagSetTest extends AbstractFlagSetTest<PutFlags, PutFlagSet> {
   void test() {
     // This is here purely to stop CodeQL moaning that this class is unused.
     // All the actual tests are in the superclass
-    Assertions.assertThat(getAllFlags())
-        .isNotNull();
+    Assertions.assertThat(getAllFlags()).isNotNull();
   }
 
   @Override
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 27e8c4cf..2d700525 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -28,8 +28,7 @@ class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
   void test() {
     // This is here purely to stop CodeQL moaning that this class is unused.
     // All the actual tests are in the superclass
-    Assertions.assertThat(getAllFlags())
-        .isNotNull();
+    Assertions.assertThat(getAllFlags()).isNotNull();
   }
 
   @Override

From 42495667abd3756392933369cc4d20cfdfb09855 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 12 Nov 2025 09:23:53 +0000
Subject: [PATCH 61/90] Fix typo in javadoc

---
 src/main/java/org/lmdbjava/ByteUnit.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/ByteUnit.java b/src/main/java/org/lmdbjava/ByteUnit.java
index 51dab217..1c37ad24 100644
--- a/src/main/java/org/lmdbjava/ByteUnit.java
+++ b/src/main/java/org/lmdbjava/ByteUnit.java
@@ -15,7 +15,7 @@
  */
 package org.lmdbjava;
 
-/** Simple {@link Enum} for converting various IEC and SI byte units down a number of bytes. */
+/** Simple {@link Enum} for converting various IEC and SI byte units down to a number of bytes. */
 public enum ByteUnit {
 
   /** IEC/SI byte unit for bytes. */

From 35b0a9dacf1f4528f0800c7f17d4584d097e5f1c Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 12 Nov 2025 09:38:15 +0000
Subject: [PATCH 62/90] Tidy code

---
 src/test/java/org/lmdbjava/CursorIterablePerfTest.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 66d83cc5..198ffd28 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -22,7 +22,6 @@
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
 import static org.lmdbjava.TestUtils.bb;
 
-import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
@@ -44,7 +43,7 @@ class CursorIterablePerfTest {
   private Env<ByteBuffer> env;
 
   @BeforeEach
-  public void before() throws IOException {
+  public void before() {
     tempDir = new TempDir();
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env =

From 9a3571876e320fea48702ecc30a1510f2e944959 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 15:22:42 +0000
Subject: [PATCH 63/90] Add in test classes for deprecated methods

---
 src/main/java/org/lmdbjava/DbiBuilder.java    |   4 +-
 src/main/java/org/lmdbjava/Env.java           | 172 ++---
 src/main/java/org/lmdbjava/Verifier.java      |   3 +-
 .../org/lmdbjava/CursorDeprecatedTest.java    | 312 ++++++++
 .../org/lmdbjava/CursorIterableRangeTest.java | 103 +--
 .../java/org/lmdbjava/CursorParamTest.java    |   7 +-
 src/test/java/org/lmdbjava/CursorTest.java    |  87 ++-
 .../java/org/lmdbjava/DbiDeprecatedTest.java  | 675 ++++++++++++++++++
 src/test/java/org/lmdbjava/DbiTest.java       | 108 ++-
 .../java/org/lmdbjava/EnvDeprecatedTest.java  | 383 ++++++++++
 src/test/java/org/lmdbjava/EnvTest.java       |  38 +-
 .../org/lmdbjava/GarbageCollectionTest.java   |   7 +-
 src/test/java/org/lmdbjava/TutorialTest.java  |  36 +-
 src/test/java/org/lmdbjava/TxnTest.java       |  29 +-
 14 files changed, 1710 insertions(+), 254 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/CursorDeprecatedTest.java
 create mode 100644 src/test/java/org/lmdbjava/DbiDeprecatedTest.java
 create mode 100644 src/test/java/org/lmdbjava/EnvDeprecatedTest.java

diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index fcb457ed..f322cb6d 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -170,11 +170,9 @@ public Stage3<T> withCallbackComparator(final ComparatorFactory<T> comparatorFac
     }
 
     /**
+     * <strong>WARNING</strong>: Only use this if you fully understand the risks and implications.
      * <hr>
      *
-     * <p><strong>WARNING</strong>: Only use this if you fully understand the risks and
-     * implications. <hr>
-     *
      * <p>With this option, {@link CursorIterable} will make use of the passed comparator for
      * comparing iteration keys to start/stop keys. It has <strong>NO</strong> bearing on the
      * insert/iteration order of the database (which is controlled by LMDB's own comparators).
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index d43ebd0f..eec1c354 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -16,7 +16,6 @@
 package org.lmdbjava;
 
 import static java.lang.Boolean.getBoolean;
-import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.Objects.requireNonNull;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -135,27 +134,6 @@ public void close() {
     LIB.mdb_env_close(ptr);
   }
 
-  /**
-   * Copies an LMDB environment to the specified destination path.
-   *
-   * <p>This function may be used to make a backup of an existing environment. No lockfile is
-   * created, since it gets recreated at need.
-   *
-   * <p>If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the destination path
-   * must be a directory that exists but contains no files. If {@link EnvFlags#MDB_NOSUBDIR} was
-   * used, the destination path must not exist, but it must be possible to create a file at the
-   * provided path.
-   *
-   * <p>Note: This call can trigger significant file size growth if run in parallel with write
-   * transactions, because it employs a read-only transaction. See long-lived transactions under
-   * "Caveats" in the LMDB native documentation.
-   *
-   * @param path writable destination path as described above
-   */
-  public void copy(final Path path) {
-    copy(path, CopyFlagSet.EMPTY);
-  }
-
   /**
    * Copies an LMDB environment to the specified destination path.
    *
@@ -173,11 +151,12 @@ public void copy(final Path path) {
    *
    * @param path writable destination path as described above
    * @param flags special options for this copy
+   * @deprecated Use {@link Env#copy(Path, CopyFlagSet)}
    */
-  public void copy(final Path path, final CopyFlagSet flags) {
+  @Deprecated
+  public void copy(final File path, final CopyFlags... flags) {
     requireNonNull(path);
-    validatePath(path);
-    checkRc(LIB.mdb_env_copy2(ptr, path.toAbsolutePath().toString(), flags.getMask()));
+    copy(path.toPath(), CopyFlagSet.of(flags));
   }
 
   /**
@@ -196,13 +175,9 @@ public void copy(final Path path, final CopyFlagSet flags) {
    * "Caveats" in the LMDB native documentation.
    *
    * @param path writable destination path as described above
-   * @param flags special options for this copy
-   * @deprecated Use {@link Env#copy(Path, CopyFlagSet)}
    */
-  @Deprecated
-  public void copy(final File path, final CopyFlags... flags) {
-    requireNonNull(path);
-    copy(path.toPath(), CopyFlagSet.of(flags));
+  public void copy(final Path path) {
+    copy(path, CopyFlagSet.EMPTY);
   }
 
   /**
@@ -221,12 +196,12 @@ public void copy(final File path, final CopyFlags... flags) {
    * "Caveats" in the LMDB native documentation.
    *
    * @param path writable destination path as described above
-   * @deprecated Use {@link Env#copy(Path)}
+   * @param flags special options for this copy
    */
-  @Deprecated
-  public void copy(final File path) {
+  public void copy(final Path path, final CopyFlagSet flags) {
     requireNonNull(path);
-    copy(path.toPath(), CopyFlagSet.EMPTY);
+    validatePath(path);
+    checkRc(LIB.mdb_env_copy2(ptr, path.toAbsolutePath().toString(), flags.getMask()));
   }
 
   /**
@@ -243,16 +218,17 @@ public void copy(final File path) {
   public List<byte[]> getDbiNames() {
     final List<byte[]> result = new ArrayList<>();
     // The unnamed DB is special so the names of the named DBs are held as keys in it.
-    final Dbi<T> unnamedDb = openDbi((byte[]) null, DbiFlagSet.EMPTY);
-    try (final Txn<T> txn = txnRead();
-        final Cursor<T> cursor = unnamedDb.openCursor(txn)) {
-      if (!cursor.first()) {
-        return Collections.emptyList();
+    try (final Txn<T> readTxn = txnRead()) {
+      final Dbi<T> unnamedDb = new Dbi<>(this, readTxn, null, proxy, DbiFlagSet.EMPTY);
+      try (final Cursor<T> cursor = unnamedDb.openCursor(readTxn)) {
+        if (!cursor.first()) {
+          return Collections.emptyList();
+        }
+        do {
+          final byte[] name = proxy.getBytes(cursor.key());
+          result.add(name);
+        } while (cursor.next());
       }
-      do {
-        final byte[] name = proxy.getBytes(cursor.key());
-        result.add(name);
-      } while (cursor.next());
     }
     return result;
   }
@@ -336,8 +312,10 @@ public boolean isReadOnly() {
   }
 
   /**
-   * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set) a {@link Dbi} using a
-   * builder.
+   * Returns a builder for creating and opening a {@link Dbi} instance in this {@link Env}.
+   *
+   * <p>The flag {@link DbiFlags#MDB_CREATE} needs to be set on the builder if you need to create a
+   * new database before opening it.
    *
    * @return A new builder instance for creating/opening a {@link Dbi}.
    */
@@ -345,55 +323,17 @@ public DbiBuilder<T> createDbi() {
     return new DbiBuilder<>(this, proxy, readOnly);
   }
 
-  /**
-   * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set) a {@link Dbi} using a
-   * builder.
-   *
-   * <p>For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param dbiFlagSet Flags to open the database with
-   * @return a database that is ready to use
-   */
-  public Dbi<T> openDbi(final String name, final DbiFlagSet dbiFlagSet) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
-    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi = new Dbi<>(this, txn, nameBytes, proxy, dbiFlagSet);
-      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
-      return dbi;
-    }
-  }
-
-  /**
-   * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
-   * invoked from native code.
-   *
-   * <p>For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param dbiFlagSet Flags to open the database with
-   * @return a database that is ready to use
-   */
-  public Dbi<T> openDbi(final byte[] name, final DbiFlagSet dbiFlagSet) {
-    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi = new Dbi<>(this, txn, name, proxy, dbiFlagSet);
-      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
-      return dbi;
-    }
-  }
-
   /**
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} or {@link Env#openDbi(String, DbiFlagSet)}
-   *     Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
-   *     Comparator} that is not invoked from native code.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Convenience method that opens a {@link Dbi} with a UTF-8 database name and default
+   *     {@link Comparator} that is not invoked from native code.
    */
   @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
-    return openDbi(nameBytes, null, false, flags);
+    return createDbi().setDbName(name).withDefaultComparator().setDbiFlags(flags).open();
   }
 
   /**
@@ -402,9 +342,9 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
    *     comparator will be used.
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} Convenience method that opens a {@link Dbi}
-   *     with a UTF-8 database name and associated {@link Comparator} for use by {@link
-   *     CursorIterable} when comparing start/stop keys.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated
+   *     {@link Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
    *     <p>It is very important that the passed comparator behaves in the same way as the
    *     comparator LMDB uses for its insertion order (for the type of data that will be stored in
    *     the database), or you fully understand the implications of them behaving differently.
@@ -415,7 +355,12 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   public Dbi<T> openDbi(
       final String name, final Comparator<T> comparator, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
-    return openDbi(nameBytes, comparator, false, flags);
+    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
+      final Dbi<T> dbi =
+          new Dbi<>(this, txn, nameBytes, comparator, false, proxy, DbiFlagSet.of(flags));
+      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
+      return dbi;
+    }
   }
 
   /**
@@ -425,11 +370,12 @@ public Dbi<T> openDbi(
    * @param nativeCb whether LMDB native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} Convenience method that opens a {@link Dbi}
-   *     with a UTF-8 database name and associated {@link Comparator}. The comparator will be used
-   *     by {@link CursorIterable} when comparing start/stop keys as a minimum. If nativeCb is
-   *     {@code true}, this comparator will also be called by LMDB to determine insertion/iteration
-   *     order. Calling back to a java comparator may significantly impact performance.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated
+   *     {@link Comparator}. The comparator will be used by {@link CursorIterable} when comparing
+   *     start/stop keys as a minimum. If nativeCb is {@code true}, this comparator will also be
+   *     called by LMDB to determine insertion/iteration order. Calling back to a java comparator
+   *     may significantly impact performance.
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -438,15 +384,21 @@ public Dbi<T> openDbi(
       final boolean nativeCb,
       final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
-    return openDbi(nameBytes, comparator, nativeCb, flags);
+    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
+      final Dbi<T> dbi =
+          new Dbi<>(this, txn, nameBytes, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
+      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
+      return dbi;
+    }
   }
 
   /**
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} <hr> Convenience method that opens a {@link
-   *     Dbi} with a default {@link Comparator} that is not invoked from native code.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is
+   *     not invoked from native code.
    */
   @Deprecated()
   public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
@@ -455,11 +407,12 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
 
   /**
    * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param comparator custom iterator comparator (or null to use LMDB default)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} <hr> Convenience method that opens a {@link
-   *     Dbi} with an associated {@link Comparator} that is not invoked from native code.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that
+   *     is not invoked from native code.
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -478,9 +431,9 @@ public Dbi<T> openDbi(
    * @param nativeCb whether native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} <hr> Convenience method that opens a {@link
-   *     Dbi} with an associated {@link Comparator} that may be invoked from native code if
-   *     specified.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that
+   *     may be invoked from native code if specified.
    *     <p>This method will automatically commit the private transaction before returning. This
    *     ensures the <code>Dbi</code> is available in the <code>Env</code>.
    */
@@ -491,7 +444,8 @@ public Dbi<T> openDbi(
       final boolean nativeCb,
       final DbiFlags... flags) {
     try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi = openDbi(txn, name, comparator, nativeCb, flags);
+      final Dbi<T> dbi =
+          new Dbi<>(this, txn, name, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
       txn.commit(); // even RO Txns require a commit to retain Dbi in Env
       return dbi;
     }
@@ -504,8 +458,8 @@ public Dbi<T> openDbi(
    * @param nativeCb whether native LMDB code should call back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} Open the {@link Dbi} using the passed {@link
-   *     Txn}.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Open the {@link Dbi} using the passed {@link Txn}.
    *     <p>The caller must commit the transaction after this method returns in order to retain the
    *     <code>Dbi</code> in the <code>Env</code>.
    *     <p>A {@link Comparator} may be provided when calling this method. Such comparator is
diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index cbe99b81..87351fb0 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -175,7 +175,8 @@ private void createDbis() {
 
   private void deleteDbis() {
     for (final byte[] existingDbiName : env.getDbiNames()) {
-      final Dbi<ByteBuffer> existingDbi = env.openDbi(existingDbiName, DbiFlagSet.EMPTY);
+      final Dbi<ByteBuffer> existingDbi =
+          env.createDbi().setDbName(existingDbiName).withDefaultComparator().open();
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         existingDbi.drop(txn, true);
         txn.commit();
diff --git a/src/test/java/org/lmdbjava/CursorDeprecatedTest.java b/src/test/java/org/lmdbjava/CursorDeprecatedTest.java
new file mode 100644
index 00000000..cff118fa
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorDeprecatedTest.java
@@ -0,0 +1,312 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static java.lang.Long.BYTES;
+import static java.lang.Long.MIN_VALUE;
+import static java.nio.ByteBuffer.allocateDirect;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
+import static org.lmdbjava.ByteUnit.MEBIBYTES;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
+import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
+import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
+import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
+import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
+import static org.lmdbjava.SeekOp.MDB_FIRST;
+import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.bb;
+
+import java.nio.ByteBuffer;
+import java.nio.file.Path;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lmdbjava.Txn.NotReadyException;
+import org.lmdbjava.Txn.ReadOnlyRequiredException;
+
+/**
+ * Tests all the deprecated methods in {@link Cursor}. Essentially a duplicate of {@link
+ * CursorTest}. When all the deprecated methods are deleted we can delete this test class.
+ *
+ * @deprecated Tests all the deprecated methods in {@link Cursor}.
+ */
+@Deprecated
+public class CursorDeprecatedTest {
+
+  private TempDir tempDir;
+  private Env<ByteBuffer> env;
+
+  @BeforeEach
+  void beforeEach() {
+    tempDir = new TempDir();
+    Path file = tempDir.createTempFile();
+    env =
+        create(PROXY_OPTIMAL)
+            .setMapSize(MEBIBYTES.toBytes(1))
+            .setMaxReaders(1)
+            .setMaxDbs(1)
+            .open(file.toFile(), Env.Builder.POSIX_MODE_DEFAULT, MDB_NOSUBDIR);
+  }
+
+  @AfterEach
+  void afterEach() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  @Test
+  void count() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), new PutFlags[] {MDB_APPENDDUP});
+      assertThat(c.count()).isEqualTo(1L);
+      c.put(bb(1), bb(4), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(1), bb(6), new PutFlags[] {MDB_APPENDDUP});
+      assertThat(c.count()).isEqualTo(3L);
+      c.put(bb(2), bb(1), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(2), bb(2), new PutFlags[] {MDB_APPENDDUP});
+      assertThat(c.count()).isEqualTo(2L);
+    }
+  }
+
+  @Test
+  void cursorCannotCloseIfTransactionCommitted() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (Cursor<ByteBuffer> c = db.openCursor(txn); ) {
+                  c.put(bb(1), bb(2), new PutFlags[] {MDB_APPENDDUP});
+                  assertThat(c.count()).isEqualTo(1L);
+                  c.put(bb(1), bb(4), new PutFlags[] {MDB_APPENDDUP});
+                  assertThat(c.count()).isEqualTo(2L);
+                  txn.commit();
+                }
+              }
+            })
+        .isInstanceOf(NotReadyException.class);
+  }
+
+  @Test
+  void cursorFirstLastNextPrev() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), new PutFlags[] {MDB_NOOVERWRITE});
+      c.put(bb(3), bb(4), new PutFlags[0]);
+      c.put(bb(5), bb(6), new PutFlags[0]);
+      c.put(bb(7), bb(8), new PutFlags[0]);
+
+      assertThat(c.first()).isTrue();
+      assertThat(c.key().getInt(0)).isEqualTo(1);
+      assertThat(c.val().getInt(0)).isEqualTo(2);
+
+      assertThat(c.last()).isTrue();
+      assertThat(c.key().getInt(0)).isEqualTo(7);
+      assertThat(c.val().getInt(0)).isEqualTo(8);
+
+      assertThat(c.prev()).isTrue();
+      assertThat(c.key().getInt(0)).isEqualTo(5);
+      assertThat(c.val().getInt(0)).isEqualTo(6);
+
+      assertThat(c.first()).isTrue();
+      assertThat(c.next()).isTrue();
+      assertThat(c.key().getInt(0)).isEqualTo(3);
+      assertThat(c.val().getInt(0)).isEqualTo(4);
+    }
+  }
+
+  @Test
+  void delete() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), MDB_NOOVERWRITE);
+      c.put(bb(3), bb(4), new PutFlags[0]);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(1);
+      assertThat(c.val().getInt()).isEqualTo(2);
+      c.delete();
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(3);
+      assertThat(c.val().getInt()).isEqualTo(4);
+      c.delete();
+      assertThat(c.seek(MDB_FIRST)).isFalse();
+    }
+  }
+
+  @Test
+  void getKeyVal() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(1), bb(4), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(1), bb(6), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(2), bb(1), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(2), bb(2), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(2), bb(3), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(2), bb(4), new PutFlags[] {MDB_APPENDDUP});
+      assertThat(c.get(bb(1), bb(2), MDB_GET_BOTH)).isTrue();
+      assertThat(c.count()).isEqualTo(3L);
+      assertThat(c.get(bb(1), bb(3), MDB_GET_BOTH)).isFalse();
+      assertThat(c.get(bb(2), bb(1), MDB_GET_BOTH)).isTrue();
+      assertThat(c.count()).isEqualTo(4L);
+      assertThat(c.get(bb(2), bb(0), MDB_GET_BOTH)).isFalse();
+    }
+  }
+
+  @Test
+  void putMultiple() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED);
+    final int elemCount = 20;
+
+    final ByteBuffer values = allocateDirect(Integer.BYTES * elemCount);
+    for (int i = 1; i <= elemCount; i++) {
+      values.putInt(i);
+    }
+    values.flip();
+
+    final int key = 100;
+    final ByteBuffer k = bb(key);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.putMultiple(k, values, elemCount, new PutFlags[] {MDB_MULTIPLE});
+      assertThat(c.count()).isEqualTo((long) elemCount);
+    }
+  }
+
+  @Test
+  void putMultipleWithoutMdbMultipleFlag() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+              try (Txn<ByteBuffer> txn = env.txnWrite();
+                  Cursor<ByteBuffer> c = db.openCursor(txn)) {
+                c.putMultiple(bb(100), bb(1), 1, new PutFlags[0]);
+              }
+            })
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+
+  @Test
+  void renewTxRw() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                assertThat(txn.isReadOnly()).isFalse();
+
+                try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+                  c.renew(txn);
+                }
+              }
+            })
+        .isInstanceOf(ReadOnlyRequiredException.class);
+  }
+
+  @Test
+  void repeatedCloseCausesNotError() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = db.openCursor(txn);
+      c.close();
+      c.close();
+    }
+  }
+
+  @Test
+  void reserve() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final ByteBuffer key = bb(5);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      assertThat(db.get(txn, key)).isNull();
+      try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        final ByteBuffer val = c.reserve(key, BYTES * 2, new PutFlags[0]);
+        assertThat(db.get(txn, key)).isNotNull();
+        val.putLong(MIN_VALUE).flip();
+      }
+      txn.commit();
+    }
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final ByteBuffer val = db.get(txn, key);
+      assertThat(val.capacity()).isEqualTo(BYTES * 2);
+      assertThat(val.getLong()).isEqualTo(MIN_VALUE);
+    }
+  }
+
+  @Test
+  void returnValueForNoDupData() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      // ok
+      assertThat(c.put(bb(5), bb(6), new PutFlags[] {MDB_NODUPDATA})).isTrue();
+      assertThat(c.put(bb(5), bb(7), new PutFlags[] {MDB_NODUPDATA})).isTrue();
+      assertThat(c.put(bb(5), bb(6), new PutFlags[] {MDB_NODUPDATA})).isFalse();
+    }
+  }
+
+  @Test
+  void returnValueForNoOverwrite() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      // ok
+      assertThat(c.put(bb(5), bb(6), new PutFlags[] {MDB_NOOVERWRITE})).isTrue();
+      // fails, but gets exist val
+      assertThat(c.put(bb(5), bb(8), new PutFlags[] {MDB_NOOVERWRITE})).isFalse();
+      assertThat(c.val().getInt(0)).isEqualTo(6);
+    }
+  }
+
+  @Test
+  void testCursorByteBufferDuplicate() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        c.put(bb(1), bb(2), new PutFlags[0]);
+        c.put(bb(3), bb(4), new PutFlags[0]);
+      }
+      txn.commit();
+    }
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        c.first();
+        final ByteBuffer key1 = c.key().duplicate();
+        final ByteBuffer val1 = c.val().duplicate();
+
+        c.last();
+        final ByteBuffer key2 = c.key().duplicate();
+        final ByteBuffer val2 = c.val().duplicate();
+
+        assertThat(key1.getInt(0)).isEqualTo(1);
+        assertThat(val1.getInt(0)).isEqualTo(2);
+
+        assertThat(key2.getInt(0)).isEqualTo(3);
+        assertThat(val2.getInt(0)).isEqualTo(4);
+      }
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 8c4868f0..66d534a5 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -16,16 +16,15 @@
 
 package org.lmdbjava;
 
-import static java.nio.ByteBuffer.allocateDirect;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.bbNative;
+import static org.lmdbjava.TestUtils.parseInt;
+import static org.lmdbjava.TestUtils.parseLong;
 
-import java.io.File;
-import java.io.FileReader;
 import java.io.IOException;
-import java.io.Reader;
 import java.io.StringWriter;
 import java.io.UncheckedIOException;
 import java.io.Writer;
@@ -43,14 +42,10 @@ public final class CursorIterableRangeTest {
 
   private static final DbiFlagSet FLAGSET_DUPSORT =
       DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_DUPSORT);
-  private static final DbiFlagSet FLAGSET_REVERSEKEY =
-      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_REVERSEKEY);
   private static final DbiFlagSet FLAGSET_INTEGERKEY =
       DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY);
   private static final DbiFlagSet FLAGSET_INTEGERKEY_DUPSORT =
       DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_DUPSORT);
-  private static final DbiFlagSet FLAGSET_REVERSE_INTEGERKEY =
-      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_REVERSEKEY);
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testSignedComparator.csv")
@@ -295,15 +290,15 @@ private ByteBuffer parseKey(final String key, final int keyLen, final ByteOrder
     if (key != null) {
       if (ByteOrder.nativeOrder().equals(byteOrder)) {
         if (keyLen == Integer.BYTES) {
-          return bbNativeInt(TestUtils.parseInt(key));
+          return bbNative(parseInt(key));
         } else {
-          return bbNativeLong(TestUtils.parseLong(key));
+          return bbNative(parseLong(key));
         }
       } else {
         if (keyLen == Integer.BYTES) {
-          return bb(TestUtils.parseInt(key));
+          return bb(parseInt(key));
         } else {
-          return bb(TestUtils.parseLong(key));
+          return bb(parseLong(key));
         }
       }
     }
@@ -357,12 +352,12 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiIntegerDBPopulat
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
         for (int i = 0; i < copies; i++) {
-          c.put(bbNativeInt(0), bb(1 + i));
-          c.put(bbNativeInt(2), bb(3 + i));
-          c.put(bbNativeInt(4), bb(5 + i));
-          c.put(bbNativeInt(6), bb(7 + i));
-          c.put(bbNativeInt(8), bb(9 + i));
-          c.put(bbNativeInt(-2), bb(-1 + i));
+          c.put(bbNative(0), bb(1 + i));
+          c.put(bbNative(2), bb(3 + i));
+          c.put(bbNative(4), bb(5 + i));
+          c.put(bbNative(6), bb(7 + i));
+          c.put(bbNative(8), bb(9 + i));
+          c.put(bbNative(-2), bb(-1 + i));
         }
         txn.commit();
       }
@@ -375,12 +370,12 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiLongDBPopulator(
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
         for (int i = 0; i < copies; i++) {
-          c.put(bbNativeLong(0), bb(1 + i));
-          c.put(bbNativeLong(2), bb(3 + i));
-          c.put(bbNativeLong(4), bb(5 + i));
-          c.put(bbNativeLong(6), bb(7 + i));
-          c.put(bbNativeLong(8), bb(9 + i));
-          c.put(bbNativeLong(-2), bb(-1 + i));
+          c.put(bbNative(0L), bb(1 + i));
+          c.put(bbNative(2L), bb(3 + i));
+          c.put(bbNative(4L), bb(5 + i));
+          c.put(bbNative(6L), bb(7 + i));
+          c.put(bbNative(8L), bb(9 + i));
+          c.put(bbNative(-2L), bb(-1 + i));
         }
         txn.commit();
       }
@@ -391,11 +386,11 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createIntegerDBPopulator()
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-        c.put(bbNativeInt(0), bb(1));
-        c.put(bbNativeInt(1000), bb(2));
-        c.put(bbNativeInt(1000000), bb(3));
-        c.put(bbNativeInt(-1000000), bb(4));
-        c.put(bbNativeInt(-1000), bb(5));
+        c.put(bbNative(0), bb(1));
+        c.put(bbNative(1000), bb(2));
+        c.put(bbNative(1000000), bb(3));
+        c.put(bbNative(-1000000), bb(4));
+        c.put(bbNative(-1000), bb(5));
         txn.commit();
       }
     };
@@ -405,53 +400,13 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createLongDBPopulator() {
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-        c.put(bbNativeLong(0), bb(1));
-        c.put(bbNativeLong(1000), bb(2));
-        c.put(bbNativeLong(1000000), bb(3));
-        c.put(bbNativeLong(-1000000), bb(4));
-        c.put(bbNativeLong(-1000), bb(5));
+        c.put(bbNative(0L), bb(1));
+        c.put(bbNative(1000L), bb(2));
+        c.put(bbNative(1000000L), bb(3));
+        c.put(bbNative(-1000000L), bb(4));
+        c.put(bbNative(-1000L), bb(5));
         txn.commit();
       }
     };
   }
-
-  private void populateDatabase(
-      final Env<ByteBuffer> env, final Dbi<ByteBuffer> dbi, final int copies) {
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-      for (int i = 0; i < copies; i++) {
-        c.put(bb(0), bb(1 + i));
-        c.put(bb(2), bb(3 + i));
-        c.put(bb(4), bb(5 + i));
-        c.put(bb(6), bb(7 + i));
-        c.put(bb(8), bb(9 + i));
-        c.put(bb(-2), bb(-1 + i));
-      }
-      txn.commit();
-    }
-  }
-
-  private String readFile(final File file) throws IOException {
-    final StringBuilder result = new StringBuilder();
-    try (final Reader reader = new FileReader(file)) {
-      final char[] cbuf = new char[4096];
-      int nread;
-      while ((nread = reader.read(cbuf, 0, cbuf.length)) != -1) {
-        result.append(cbuf, 0, nread);
-      }
-    }
-    return result.toString();
-  }
-
-  static ByteBuffer bbNativeInt(final int value) {
-    final ByteBuffer bb = allocateDirect(Integer.BYTES).order(ByteOrder.nativeOrder());
-    bb.putInt(value).flip();
-    return bb;
-  }
-
-  static ByteBuffer bbNativeLong(final long value) {
-    final ByteBuffer bb = allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
-    bb.putLong(value).flip();
-    return bb;
-  }
 }
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index cc2fdaf3..28f60419 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -94,7 +94,12 @@ protected AbstractBufferRunner(final BufferProxy<T> proxy) {
     public final void execute(final Path tmp) {
       try (Env<T> env = env(tmp)) {
         assertThat(env.getDbiNames()).isEmpty();
-        final Dbi<T> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+        final Dbi<T> db =
+            env.createDbi()
+                .setDbName(DB_1)
+                .withDefaultComparator()
+                .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+                .open();
         assertThat(env.getDbiNames().get(0)).isEqualTo(DB_1.getBytes(UTF_8));
         try (Txn<T> txn = env.txnWrite();
             Cursor<T> c = db.openCursor(txn)) {
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 01af8e10..97f9d706 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -78,7 +78,12 @@ void afterEach() {
   void closedCursorRejectsSubsequentGets() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              final Dbi<ByteBuffer> db =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE)
+                      .open();
               try (Txn<ByteBuffer> txn = env.txnWrite()) {
                 final Cursor<ByteBuffer> c = db.openCursor(txn);
                 c.close();
@@ -175,7 +180,12 @@ void closedEnvRejectsDeleteCall() {
 
   @Test
   void count() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_APPENDDUP);
@@ -193,7 +203,12 @@ void count() {
   void cursorCannotCloseIfTransactionCommitted() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+              final Dbi<ByteBuffer> db =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+                      .open();
               try (Txn<ByteBuffer> txn = env.txnWrite()) {
                 try (Cursor<ByteBuffer> c = db.openCursor(txn); ) {
                   c.put(bb(1), bb(2), MDB_APPENDDUP);
@@ -209,7 +224,8 @@ void cursorCannotCloseIfTransactionCommitted() {
 
   @Test
   void cursorFirstLastNextPrev() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_NOOVERWRITE);
@@ -238,7 +254,12 @@ void cursorFirstLastNextPrev() {
 
   @Test
   void delete() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_NOOVERWRITE);
@@ -257,7 +278,12 @@ void delete() {
 
   @Test
   void getKeyVal() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_APPENDDUP);
@@ -279,7 +305,11 @@ void getKeyVal() {
   @Test
   void putMultiple() {
     final Dbi<ByteBuffer> db =
-        env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED));
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED)
+            .open();
     final int elemCount = 20;
 
     final ByteBuffer values = allocateDirect(Integer.BYTES * elemCount);
@@ -301,7 +331,12 @@ void putMultiple() {
   void putMultipleWithoutMdbMultipleFlag() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+              final Dbi<ByteBuffer> db =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+                      .open();
               try (Txn<ByteBuffer> txn = env.txnWrite();
                   Cursor<ByteBuffer> c = db.openCursor(txn)) {
                 c.putMultiple(bb(100), bb(1), 1);
@@ -312,7 +347,8 @@ void putMultipleWithoutMdbMultipleFlag() {
 
   @Test
   void renewTxRo() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     final Cursor<ByteBuffer> c;
     try (Txn<ByteBuffer> txn = env.txnRead()) {
@@ -332,7 +368,12 @@ void renewTxRo() {
   void renewTxRw() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              final Dbi<ByteBuffer> db =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE)
+                      .open();
               try (Txn<ByteBuffer> txn = env.txnWrite()) {
                 assertThat(txn.isReadOnly()).isFalse();
 
@@ -346,7 +387,12 @@ void renewTxRw() {
 
   @Test
   void repeatedCloseCausesNotError() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final Cursor<ByteBuffer> c = db.openCursor(txn);
       c.close();
@@ -356,7 +402,8 @@ void repeatedCloseCausesNotError() {
 
   @Test
   void reserve() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     final ByteBuffer key = bb(5);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       assertThat(db.get(txn, key)).isNull();
@@ -376,7 +423,12 @@ void reserve() {
 
   @Test
   void returnValueForNoDupData() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       // ok
@@ -388,7 +440,8 @@ void returnValueForNoDupData() {
 
   @Test
   void returnValueForNoOverwrite() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       // ok
@@ -401,7 +454,8 @@ void returnValueForNoOverwrite() {
 
   @Test
   void testCursorByteBufferDuplicate() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
         c.put(bb(1), bb(2));
@@ -431,7 +485,8 @@ void testCursorByteBufferDuplicate() {
   private void doEnvClosedTest(
       final Consumer<Cursor<ByteBuffer>> workBeforeEnvClosed,
       final Consumer<Cursor<ByteBuffer>> workAfterEnvClose) {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     db.put(bb(1), bb(10));
     db.put(bb(2), bb(20));
diff --git a/src/test/java/org/lmdbjava/DbiDeprecatedTest.java b/src/test/java/org/lmdbjava/DbiDeprecatedTest.java
new file mode 100644
index 00000000..7156b963
--- /dev/null
+++ b/src/test/java/org/lmdbjava/DbiDeprecatedTest.java
@@ -0,0 +1,675 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static java.lang.Long.MAX_VALUE;
+import static java.lang.System.getProperty;
+import static java.nio.ByteBuffer.allocateDirect;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static java.util.Collections.nCopies;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.IntStream.range;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
+import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
+import static org.lmdbjava.ByteUnit.MEBIBYTES;
+import static org.lmdbjava.DbiFlags.*;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.GetOp.MDB_SET_KEY;
+import static org.lmdbjava.KeyRange.atMost;
+import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
+import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
+import static org.lmdbjava.TestUtils.*;
+
+import java.nio.ByteBuffer;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.function.IntFunction;
+import java.util.function.ToIntFunction;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lmdbjava.CursorIterable.KeyVal;
+import org.lmdbjava.Dbi.DbFullException;
+import org.lmdbjava.Env.AlreadyClosedException;
+import org.lmdbjava.Env.MapFullException;
+import org.lmdbjava.LmdbNativeException.ConstantDerivedException;
+
+/**
+ * Tests all the deprecated methods in {@link Dbi}. Essentially a duplicate of {@link DbiTest}. When
+ * all the deprecated methods are deleted we can delete this test class.
+ *
+ * @deprecated Tests all the deprecated methods in {@link Dbi}.
+ */
+@Deprecated
+public class DbiDeprecatedTest {
+
+  private TempDir tempDir;
+  private Env<ByteBuffer> env;
+  private TempDir tempDirBa;
+  private Env<byte[]> envBa;
+
+  @BeforeEach
+  void beforeEach() {
+    tempDir = new TempDir();
+    final Path file = tempDir.createTempFile();
+    env =
+        create()
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .open(file.toFile(), MDB_NOSUBDIR);
+    tempDirBa = new TempDir();
+    final Path fileBa = tempDirBa.createTempFile();
+    envBa =
+        create(PROXY_BA)
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .open(fileBa.toFile(), MDB_NOSUBDIR);
+  }
+
+  @AfterEach
+  void afterEach() {
+    env.close();
+    envBa.close();
+    tempDir.cleanup();
+    tempDirBa.cleanup();
+  }
+
+  @Test
+  void close() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              db.put(bb(1), bb(42));
+              db.close();
+              db.put(bb(2), bb(42)); // error
+            })
+        .isInstanceOf(ConstantDerivedException.class);
+  }
+
+  @Test
+  void customComparator() {
+    final Comparator<ByteBuffer> reverseOrder =
+        (o1, o2) -> {
+          final int lexical = PROXY_OPTIMAL.getComparator().compare(o1, o2);
+          if (lexical == 0) {
+            return 0;
+          }
+          return lexical * -1;
+        };
+    doCustomComparator(env, reverseOrder, TestUtils::bb, ByteBuffer::getInt);
+  }
+
+  @Test
+  void customComparatorByteArray() {
+    final Comparator<byte[]> reverseOrder =
+        (o1, o2) -> {
+          final int lexical = PROXY_BA.getComparator().compare(o1, o2);
+          if (lexical == 0) {
+            return 0;
+          }
+          return lexical * -1;
+        };
+    doCustomComparator(envBa, reverseOrder, TestUtils::ba, TestUtils::fromBa);
+  }
+
+  private <T> void doCustomComparator(
+      Env<T> env,
+      Comparator<T> comparator,
+      IntFunction<T> serializer,
+      ToIntFunction<T> deserializer) {
+    final Dbi<T> db = env.openDbi(DB_1, comparator, true, MDB_CREATE);
+    try (Txn<T> txn = env.txnWrite()) {
+      assertThat(db.put(txn, serializer.apply(2), serializer.apply(3))).isTrue();
+      assertThat(db.put(txn, serializer.apply(4), serializer.apply(6))).isTrue();
+      assertThat(db.put(txn, serializer.apply(6), serializer.apply(7))).isTrue();
+      assertThat(db.put(txn, serializer.apply(8), serializer.apply(7))).isTrue();
+      txn.commit();
+    }
+    try (Txn<T> txn = env.txnRead();
+        CursorIterable<T> ci = db.iterate(txn, atMost(serializer.apply(4)))) {
+      final Iterator<KeyVal<T>> iter = ci.iterator();
+      assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(8);
+      assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(6);
+      assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(4);
+    }
+  }
+
+  @Test
+  void dbOpenMaxDatabases() {
+    assertThatThrownBy(
+            () -> {
+              env.openDbi("db1 is OK", MDB_CREATE);
+              env.openDbi("db2 is OK", MDB_CREATE);
+              env.openDbi("db3 fails", MDB_CREATE);
+            })
+        .isInstanceOf(DbFullException.class);
+  }
+
+  @Test
+  void dbiWithComparatorThreadSafety() {
+    doDbiWithComparatorThreadSafety(
+        env, PROXY_OPTIMAL::getComparator, TestUtils::bb, ByteBuffer::getInt);
+  }
+
+  @Test
+  void dbiWithComparatorThreadSafetyByteArray() {
+    doDbiWithComparatorThreadSafety(
+        envBa, PROXY_BA::getComparator, TestUtils::ba, TestUtils::fromBa);
+  }
+
+  private <T> void doDbiWithComparatorThreadSafety(
+      Env<T> env,
+      Function<DbiFlagSet, Comparator<T>> comparator,
+      IntFunction<T> serializer,
+      ToIntFunction<T> deserializer) {
+    final DbiFlags[] flags = new DbiFlags[] {MDB_CREATE, MDB_INTEGERKEY};
+    final Comparator<T> c = comparator.apply(DbiFlagSet.of(flags));
+    final Dbi<T> db = env.openDbi(DB_1, c, true, flags);
+
+    final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
+
+    final ExecutorService pool = Executors.newCachedThreadPool();
+    final AtomicBoolean proceed = new AtomicBoolean(true);
+    final Future<?> reader =
+        pool.submit(
+            () -> {
+              while (proceed.get()) {
+                try (Txn<T> txn = env.txnRead()) {
+                  db.get(txn, serializer.apply(50));
+                }
+              }
+            });
+
+    for (final Integer key : keys) {
+      try (Txn<T> txn = env.txnWrite()) {
+        db.put(txn, serializer.apply(key), serializer.apply(3));
+        txn.commit();
+      }
+    }
+
+    try (Txn<T> txn = env.txnRead();
+        CursorIterable<T> ci = db.iterate(txn)) {
+      final Iterator<KeyVal<T>> iter = ci.iterator();
+      final List<Integer> result = new ArrayList<>();
+      while (iter.hasNext()) {
+        result.add(deserializer.applyAsInt(iter.next().key()));
+      }
+
+      assertThat(result).contains(keys.toArray(new Integer[0]));
+    }
+
+    proceed.set(false);
+    try {
+      reader.get(1, SECONDS);
+      pool.shutdown();
+      pool.awaitTermination(1, SECONDS);
+    } catch (ExecutionException | InterruptedException | TimeoutException e) {
+      throw new IllegalStateException(e);
+    }
+  }
+
+  @Test
+  void drop() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      db.put(txn, bb(1), bb(42));
+      db.put(txn, bb(2), bb(42));
+      assertThat(db.get(txn, bb(1))).isNotNull();
+      assertThat(db.get(txn, bb(2))).isNotNull();
+      db.drop(txn);
+      assertThat(db.get(txn, bb(1))).isNull(); // data gone
+      assertThat(db.get(txn, bb(2))).isNull();
+      db.put(txn, bb(1), bb(42)); // ensure DB still works
+      db.put(txn, bb(2), bb(42));
+      assertThat(db.get(txn, bb(1))).isNotNull();
+      assertThat(db.get(txn, bb(2))).isNotNull();
+    }
+  }
+
+  @Test
+  void dropAndDelete() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null);
+    final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
+    final ByteBuffer dbNameBuffer = allocateDirect(dbNameBytes.length);
+    dbNameBuffer.put(dbNameBytes).flip();
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      assertThat(nameDb.get(txn, dbNameBuffer)).isNotNull();
+      db.drop(txn, true);
+      assertThat(nameDb.get(txn, dbNameBuffer)).isNull();
+      txn.commit();
+    }
+  }
+
+  @Test
+  void dropAndDeleteAnonymousDb() {
+    env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null);
+    final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
+    final ByteBuffer dbNameBuffer = allocateDirect(dbNameBytes.length);
+    dbNameBuffer.put(dbNameBytes).flip();
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      assertThat(nameDb.get(txn, dbNameBuffer)).isNotNull();
+      nameDb.drop(txn, true);
+      assertThat(nameDb.get(txn, dbNameBuffer)).isNull();
+      txn.commit();
+    }
+
+    nameDb.close(); // explicit close after drop is OK
+  }
+
+  @Test
+  void getName() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    assertThat(db.getName()).isEqualTo(DB_1.getBytes(UTF_8));
+  }
+
+  @Test
+  void getNamesWhenDbisPresent() {
+    final byte[] dbHello = new byte[] {'h', 'e', 'l', 'l', 'o'};
+    final byte[] dbWorld = new byte[] {'w', 'o', 'r', 'l', 'd'};
+    env.openDbi(dbHello, MDB_CREATE);
+    env.openDbi(dbWorld, MDB_CREATE);
+    final List<byte[]> dbiNames = env.getDbiNames();
+    assertThat(dbiNames).hasSize(2);
+    assertThat(dbiNames.get(0)).isEqualTo(dbHello);
+    assertThat(dbiNames.get(1)).isEqualTo(dbWorld);
+  }
+
+  @Test
+  void getNamesWhenEmpty() {
+    final List<byte[]> dbiNames = env.getDbiNames();
+    assertThat(dbiNames).isEmpty();
+  }
+
+  @Test
+  void listsFlags() {
+    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY);
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      final List<DbiFlags> flags = dbi.listFlags(txn);
+      assertThat(flags).containsExactlyInAnyOrder(MDB_DUPSORT, MDB_REVERSEKEY);
+    }
+  }
+
+  @Test
+  void putAbortGet() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      db.put(txn, bb(5), bb(5));
+      txn.abort();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      assertThat(db.get(txn, bb(5))).isNull();
+    }
+  }
+
+  @Test
+  void putAndGetAndDeleteWithInternalTx() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    db.put(bb(5), bb(5));
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      final ByteBuffer found = db.get(txn, bb(5));
+      assertThat(found).isNotNull();
+      assertThat(txn.val().getInt()).isEqualTo(5);
+    }
+    assertThat(db.delete(bb(5))).isTrue();
+    assertThat(db.delete(bb(5))).isFalse();
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      assertThat(db.get(txn, bb(5))).isNull();
+    }
+  }
+
+  @Test
+  void putCommitGet() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      db.put(txn, bb(5), bb(5));
+      txn.commit();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final ByteBuffer found = db.get(txn, bb(5));
+      assertThat(found).isNotNull();
+      assertThat(txn.val().getInt()).isEqualTo(5);
+    }
+  }
+
+  @Test
+  void putCommitGetByteArray() {
+    final Path file = tempDir.createTempFile();
+    try (Env<byte[]> envBa =
+        create(PROXY_BA)
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(1)
+            .setMaxDbs(2)
+            .open(file.toFile(), MDB_NOSUBDIR)) {
+      final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
+      try (Txn<byte[]> txn = envBa.txnWrite()) {
+        db.put(txn, ba(5), ba(5));
+        txn.commit();
+      }
+      try (Txn<byte[]> txn = envBa.txnWrite()) {
+        final byte[] found = db.get(txn, ba(5));
+        assertThat(found).isNotNull();
+        assertThat(fromBa(txn.val())).isEqualTo(5);
+      }
+    }
+  }
+
+  @Test
+  void putDelete() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      db.put(txn, bb(5), bb(5));
+      assertThat(db.delete(txn, bb(5))).isTrue();
+
+      assertThat(db.get(txn, bb(5))).isNull();
+      txn.abort();
+    }
+  }
+
+  @Test
+  void putDuplicateDelete() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      db.put(txn, bb(5), bb(5));
+      db.put(txn, bb(5), bb(6));
+      db.put(txn, bb(5), bb(7));
+      assertThat(db.delete(txn, bb(5), bb(6))).isTrue();
+      assertThat(db.delete(txn, bb(5), bb(6))).isFalse();
+      assertThat(db.delete(txn, bb(5), bb(5))).isTrue();
+      assertThat(db.delete(txn, bb(5), bb(5))).isFalse();
+
+      try (Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
+        final ByteBuffer key = bb(5);
+        cursor.get(key, MDB_SET_KEY);
+        assertThat(cursor.count()).isEqualTo(1L);
+      }
+      txn.abort();
+    }
+  }
+
+  @Test
+  void putReserve() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    final ByteBuffer key = bb(5);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      assertThat(db.get(txn, key)).isNull();
+      final ByteBuffer val = db.reserve(txn, key, 32, MDB_NOOVERWRITE);
+      val.putLong(MAX_VALUE);
+      assertThat(db.get(txn, key)).isNotNull();
+      txn.commit();
+    }
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final ByteBuffer val = db.get(txn, key);
+      assertThat(val).isNotNull();
+      assertThat(val.capacity()).isEqualTo(32);
+      assertThat(val.getLong()).isEqualTo(MAX_VALUE);
+      assertThat(val.getLong(8)).isEqualTo(0L);
+    }
+  }
+
+  @Test
+  void putZeroByteValueForNonMdbDupSortDatabase() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final ByteBuffer val = allocateDirect(0);
+      db.put(txn, bb(5), val);
+      txn.commit();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      final ByteBuffer found = db.get(txn, bb(5));
+      assertThat(found).isNotNull();
+      assertThat(txn.val().capacity()).isEqualTo(0);
+    }
+  }
+
+  @Test
+  void returnValueForNoDupData() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      // ok
+      assertThat(db.put(txn, bb(5), bb(6), MDB_NODUPDATA)).isTrue();
+      assertThat(db.put(txn, bb(5), bb(7), MDB_NODUPDATA)).isTrue();
+      assertThat(db.put(txn, bb(5), bb(6), MDB_NODUPDATA)).isFalse();
+    }
+  }
+
+  @Test
+  void returnValueForNoOverwrite() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      // ok
+      assertThat(db.put(txn, bb(5), bb(6), MDB_NOOVERWRITE)).isTrue();
+      // fails, but gets exist val
+      assertThat(db.put(txn, bb(5), bb(8), MDB_NOOVERWRITE)).isFalse();
+      assertThat(txn.val().getInt(0)).isEqualTo(6);
+    }
+  }
+
+  @Test
+  void stats() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    db.put(bb(1), bb(42));
+    db.put(bb(2), bb(42));
+    db.put(bb(3), bb(42));
+    final Stat stat;
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      stat = db.stat(txn);
+    }
+    assertThat(stat).isNotNull();
+    assertThat(stat.branchPages).isEqualTo(0L);
+    assertThat(stat.depth).isEqualTo(1);
+    assertThat(stat.entries).isEqualTo(3L);
+    assertThat(stat.leafPages).isEqualTo(1L);
+    assertThat(stat.overflowPages).isEqualTo(0L);
+    assertThat(stat.pageSize % 4_096).isEqualTo(0);
+  }
+
+  @Test
+  void testMapFullException() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                final ByteBuffer v;
+                try {
+                  v = allocateDirect(1_024 * 1_024 * 1_024);
+                } catch (final OutOfMemoryError e) {
+                  // Travis CI OS X build cannot allocate this much memory, so assume OK
+                  throw new MapFullException();
+                }
+                db.put(txn, bb(1), v);
+              }
+            })
+        .isInstanceOf(MapFullException.class);
+  }
+
+  @Test
+  void testParallelWritesStress() {
+    if (getProperty("os.name").startsWith("Windows")) {
+      return; // Windows VMs run this test too slowly
+    }
+
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    // Travis CI has 1.5 cores for legacy builds
+    nCopies(2, null).parallelStream()
+        .forEach(
+            ignored -> {
+              for (int i = 0; i < 15_000; i++) {
+                db.put(bb(i), bb(i));
+              }
+            });
+  }
+
+  @Test
+  void closedEnvRejectsOpenCall() {
+    assertThatThrownBy(
+            () -> {
+              env.close();
+              env.openDbi(DB_1, MDB_CREATE);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsCloseCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.close());
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsGetCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(
+                  (db, txn) -> {
+                    final ByteBuffer valBuf = db.get(txn, bb(1));
+                    assertThat(valBuf.getInt()).isEqualTo(10);
+                  },
+                  (db, txn) -> db.get(txn, bb(2)));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsPutCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsPutWithTxnCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(
+                  null,
+                  (db, txn) -> {
+                    db.put(txn, bb(5), bb(50));
+                  });
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsIterateCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Dbi::iterate);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsDropCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Dbi::drop);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsDropAndDeleteCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsOpenCursorCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Dbi::openCursor);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsReserveCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsStatCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Dbi::stat);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  private void doEnvClosedTest(
+      final BiConsumer<Dbi<ByteBuffer>, Txn<ByteBuffer>> workBeforeEnvClosed,
+      final BiConsumer<Dbi<ByteBuffer>, Txn<ByteBuffer>> workAfterEnvClose) {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    db.put(bb(1), bb(10));
+    db.put(bb(2), bb(20));
+    db.put(bb(2), bb(30));
+    db.put(bb(4), bb(40));
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+
+      if (workBeforeEnvClosed != null) {
+        workBeforeEnvClosed.accept(db, txn);
+      }
+
+      env.close();
+
+      if (workAfterEnvClose != null) {
+        workAfterEnvClose.accept(db, txn);
+      }
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 553ec02c..9f66e5bb 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -177,9 +177,21 @@ private <T> void doCustomComparator(
   void dbOpenMaxDatabases() {
     assertThatThrownBy(
             () -> {
-              env.openDbi("db1 is OK", MDB_CREATE);
-              env.openDbi("db2 is OK", MDB_CREATE);
-              env.openDbi("db3 fails", MDB_CREATE);
+              env.createDbi()
+                  .setDbName("db1 is OK")
+                  .withDefaultComparator()
+                  .setDbiFlags(MDB_CREATE)
+                  .open();
+              env.createDbi()
+                  .setDbName("db2 is OK")
+                  .withDefaultComparator()
+                  .setDbiFlags(MDB_CREATE)
+                  .open();
+              env.createDbi()
+                  .setDbName("db3 fails")
+                  .withDefaultComparator()
+                  .setDbiFlags(MDB_CREATE)
+                  .open();
             })
         .isInstanceOf(DbFullException.class);
   }
@@ -256,7 +268,8 @@ private <T> void doDbiWithComparatorThreadSafety(
 
   @Test
   void drop() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(1), bb(42));
       db.put(txn, bb(2), bb(42));
@@ -274,8 +287,14 @@ void drop() {
 
   @Test
   void dropAndDelete() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null, DbiFlagSet.EMPTY);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
+    final Dbi<ByteBuffer> nameDb =
+        env.createDbi()
+            .setDbName((byte[]) null)
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlagSet.EMPTY)
+            .open();
     final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
     final ByteBuffer dbNameBuffer = allocateDirect(dbNameBytes.length);
     dbNameBuffer.put(dbNameBytes).flip();
@@ -290,8 +309,8 @@ void dropAndDelete() {
 
   @Test
   void dropAndDeleteAnonymousDb() {
-    env.openDbi(DB_1, MDB_CREATE);
-    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null, DbiFlagSet.EMPTY);
+    env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
+    final Dbi<ByteBuffer> nameDb = env.createDbi().withoutDbName().withDefaultComparator().open();
     final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
     final ByteBuffer dbNameBuffer = allocateDirect(dbNameBytes.length);
     dbNameBuffer.put(dbNameBytes).flip();
@@ -308,7 +327,8 @@ void dropAndDeleteAnonymousDb() {
 
   @Test
   void getName() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     assertThat(db.getName()).isEqualTo(DB_1.getBytes(UTF_8));
   }
 
@@ -316,8 +336,8 @@ void getName() {
   void getNamesWhenDbisPresent() {
     final byte[] dbHello = new byte[] {'h', 'e', 'l', 'l', 'o'};
     final byte[] dbWorld = new byte[] {'w', 'o', 'r', 'l', 'd'};
-    env.openDbi(dbHello, MDB_CREATE);
-    env.openDbi(dbWorld, MDB_CREATE);
+    env.createDbi().setDbName(dbHello).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
+    env.createDbi().setDbName(dbWorld).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     final List<byte[]> dbiNames = env.getDbiNames();
     assertThat(dbiNames).hasSize(2);
     assertThat(dbiNames.get(0)).isEqualTo(dbHello);
@@ -333,7 +353,11 @@ void getNamesWhenEmpty() {
   @Test
   void listsFlags() {
     final Dbi<ByteBuffer> dbi =
-        env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY));
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY)
+            .open();
 
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       final List<DbiFlags> flags = dbi.listFlags(txn);
@@ -343,7 +367,8 @@ void listsFlags() {
 
   @Test
   void putAbortGet() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
@@ -357,7 +382,8 @@ void putAbortGet() {
 
   @Test
   void putAndGetAndDeleteWithInternalTx() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     db.put(bb(5), bb(5));
     try (Txn<ByteBuffer> txn = env.txnRead()) {
@@ -375,7 +401,8 @@ void putAndGetAndDeleteWithInternalTx() {
 
   @Test
   void putCommitGet() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
       txn.commit();
@@ -398,7 +425,8 @@ void putCommitGetByteArray() {
             .setMaxDbs(2)
             .setEnvFlags(MDB_NOSUBDIR)
             .open(file)) {
-      final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
+      final Dbi<byte[]> db =
+          envBa.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
       try (Txn<byte[]> txn = envBa.txnWrite()) {
         db.put(txn, ba(5), ba(5));
         txn.commit();
@@ -413,7 +441,8 @@ void putCommitGetByteArray() {
 
   @Test
   void putDelete() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
@@ -426,7 +455,12 @@ void putDelete() {
 
   @Test
   void putDuplicateDelete() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
@@ -448,7 +482,8 @@ void putDuplicateDelete() {
 
   @Test
   void putReserve() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     final ByteBuffer key = bb(5);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -469,7 +504,8 @@ void putReserve() {
 
   @Test
   void putZeroByteValueForNonMdbDupSortDatabase() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final ByteBuffer val = allocateDirect(0);
       db.put(txn, bb(5), val);
@@ -485,7 +521,12 @@ void putZeroByteValueForNonMdbDupSortDatabase() {
 
   @Test
   void returnValueForNoDupData() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       // ok
       assertThat(db.put(txn, bb(5), bb(6), MDB_NODUPDATA)).isTrue();
@@ -496,7 +537,8 @@ void returnValueForNoDupData() {
 
   @Test
   void returnValueForNoOverwrite() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       // ok
       assertThat(db.put(txn, bb(5), bb(6), MDB_NOOVERWRITE)).isTrue();
@@ -508,7 +550,8 @@ void returnValueForNoOverwrite() {
 
   @Test
   void stats() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     db.put(bb(1), bb(42));
     db.put(bb(2), bb(42));
     db.put(bb(3), bb(42));
@@ -529,7 +572,12 @@ void stats() {
   void testMapFullException() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              final Dbi<ByteBuffer> db =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE)
+                      .open();
               try (Txn<ByteBuffer> txn = env.txnWrite()) {
                 final ByteBuffer v;
                 try {
@@ -550,7 +598,8 @@ void testParallelWritesStress() {
       return; // Windows VMs run this test too slowly
     }
 
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     // Travis CI has 1.5 cores for legacy builds
     nCopies(2, null).parallelStream()
@@ -567,7 +616,11 @@ void closedEnvRejectsOpenCall() {
     assertThatThrownBy(
             () -> {
               env.close();
-              env.openDbi(DB_1, MDB_CREATE);
+              env.createDbi()
+                  .setDbName(DB_1)
+                  .withDefaultComparator()
+                  .setDbiFlags(MDB_CREATE)
+                  .open();
             })
         .isInstanceOf(AlreadyClosedException.class);
   }
@@ -675,7 +728,8 @@ void closedEnvRejectsStatCall() {
   private void doEnvClosedTest(
       final BiConsumer<Dbi<ByteBuffer>, Txn<ByteBuffer>> workBeforeEnvClosed,
       final BiConsumer<Dbi<ByteBuffer>, Txn<ByteBuffer>> workAfterEnvClose) {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     db.put(bb(1), bb(10));
     db.put(bb(2), bb(20));
diff --git a/src/test/java/org/lmdbjava/EnvDeprecatedTest.java b/src/test/java/org/lmdbjava/EnvDeprecatedTest.java
new file mode 100644
index 00000000..da004cc8
--- /dev/null
+++ b/src/test/java/org/lmdbjava/EnvDeprecatedTest.java
@@ -0,0 +1,383 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static java.nio.ByteBuffer.allocateDirect;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.lmdbjava.ByteUnit.KIBIBYTES;
+import static org.lmdbjava.ByteUnit.MEBIBYTES;
+import static org.lmdbjava.CopyFlags.MDB_CP_COMPACT;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.Env.Builder.MAX_READERS_DEFAULT;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.bb;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Random;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lmdbjava.Env.AlreadyClosedException;
+import org.lmdbjava.Env.AlreadyOpenException;
+import org.lmdbjava.Env.Builder;
+import org.lmdbjava.Env.InvalidCopyDestination;
+import org.lmdbjava.Env.MapFullException;
+
+/**
+ * Tests all the deprecated methods in {@link Env}. Essentially a duplicate of {@link EnvTest}. When
+ * all the deprecated methods are deleted we can delete this test class.
+ *
+ * @deprecated Tests all the deprecated methods in {@link Env}.
+ */
+@Deprecated
+public class EnvDeprecatedTest {
+
+  private TempDir tempDir;
+
+  @BeforeEach
+  void beforeEach() {
+    tempDir = new TempDir();
+  }
+
+  @AfterEach
+  void afterEach() {
+    tempDir.cleanup();
+  }
+
+  @Test
+  void byteUnit() {
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        Env.create()
+            .setMaxReaders(1)
+            .setMapSize(MEBIBYTES.toBytes(1))
+            .open(file.toFile(), MDB_NOSUBDIR)) {
+      final EnvInfo info = env.info();
+      assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
+    }
+  }
+
+  @Test
+  void cannotChangeMapSizeAfterOpen() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                builder.setMapSize(1);
+              }
+            })
+        .isInstanceOf(AlreadyOpenException.class);
+  }
+
+  @Test
+  void cannotChangeMaxDbsAfterOpen() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                builder.setMaxDbs(1);
+              }
+            })
+        .isInstanceOf(AlreadyOpenException.class);
+  }
+
+  @Test
+  void cannotChangeMaxReadersAfterOpen() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                builder.setMaxReaders(1);
+              }
+            })
+        .isInstanceOf(AlreadyOpenException.class);
+  }
+
+  @Test
+  void cannotInfoOnceClosed() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Env<ByteBuffer> env =
+                  Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+              env.close();
+              env.info();
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void cannotOpenTwice() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              builder.open(file.toFile(), MDB_NOSUBDIR).close();
+              builder.open(file.toFile(), MDB_NOSUBDIR);
+            })
+        .isInstanceOf(AlreadyOpenException.class);
+  }
+
+  @Test
+  void cannotStatOnceClosed() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Env<ByteBuffer> env =
+                  Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+              env.close();
+              env.stat();
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void cannotSyncOnceClosed() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Env<ByteBuffer> env =
+                  Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+              env.close();
+              env.sync(false);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void copyDirectoryBased() {
+    final Path dest = tempDir.createTempDir();
+    final Path src = tempDir.createTempDir();
+    assertThat(Files.exists(dest)).isTrue();
+    assertThat(Files.isDirectory(dest)).isTrue();
+    assertThat(FileUtil.count(dest)).isEqualTo(0);
+    try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+      env.copy(dest.toFile(), MDB_CP_COMPACT);
+      assertThat(FileUtil.count(dest)).isEqualTo(1);
+    }
+  }
+
+  @Test
+  void copyDirectoryRejectsFileDestination() {
+    assertThatThrownBy(
+            () -> {
+              final Path dest = tempDir.createTempDir();
+              final Path src = tempDir.createTempDir();
+              FileUtil.deleteDir(dest);
+              try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+                env.copy(dest.toFile(), MDB_CP_COMPACT);
+              }
+            })
+        .isInstanceOf(InvalidCopyDestination.class);
+  }
+
+  @Test
+  void copyDirectoryRejectsMissingDestination() {
+    final Path dest = tempDir.createTempDir();
+    final Path src = tempDir.createTempDir();
+    assertThatThrownBy(
+            () -> {
+              try {
+                Files.delete(dest);
+                try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                }
+              } catch (final IOException e) {
+                throw new UncheckedIOException(e);
+              }
+            })
+        .isInstanceOf(InvalidCopyDestination.class);
+  }
+
+  @Test
+  void copyDirectoryRejectsNonEmptyDestination() {
+    final Path dest = tempDir.createTempDir();
+    final Path src = tempDir.createTempDir();
+    assertThatThrownBy(
+            () -> {
+              try {
+                final Path subDir = dest.resolve("hello");
+                Files.createDirectory(subDir);
+                assertThat(Files.isDirectory(subDir)).isTrue();
+                try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                }
+              } catch (final IOException e) {
+                throw new UncheckedIOException(e);
+              }
+            })
+        .isInstanceOf(InvalidCopyDestination.class);
+  }
+
+  @Test
+  void copyFileBased() {
+    final Path dest = tempDir.createTempFile();
+    final Path src = tempDir.createTempFile();
+    assertThat(Files.exists(dest)).isFalse();
+    try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+      env.copy(dest.toFile(), MDB_CP_COMPACT);
+    }
+    assertThat(FileUtil.size(dest)).isGreaterThan(0L);
+  }
+
+  @Test
+  void copyFileRejectsExistingDestination() {
+    final Path dest = tempDir.createTempFile();
+    final Path src = tempDir.createTempFile();
+    assertThatThrownBy(
+            () -> {
+              Files.createFile(dest);
+              assertThat(Files.exists(dest)).isTrue();
+              try (Env<ByteBuffer> env =
+                  Env.create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                env.copy(dest.toFile(), MDB_CP_COMPACT);
+              }
+            })
+        .isInstanceOf(InvalidCopyDestination.class);
+  }
+
+  @Test
+  void createAsFile() {
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        Env.create()
+            .setMapSize(MEBIBYTES.toBytes(1))
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .open(file.toFile(), MDB_NOSUBDIR)) {
+      env.sync(true);
+      assertThat(Files.isRegularFile(file)).isTrue();
+    }
+  }
+
+  @Test
+  void mapFull() {
+    final Path dir = tempDir.createTempDir();
+    assertThatThrownBy(
+            () -> {
+              final byte[] k = new byte[500];
+              final ByteBuffer key = allocateDirect(500);
+              final ByteBuffer val = allocateDirect(1_024);
+              final Random rnd = new Random();
+              try (Env<ByteBuffer> env =
+                  Env.create()
+                      .setMaxReaders(1)
+                      .setMapSize(MEBIBYTES.toBytes(8))
+                      .setMaxDbs(1)
+                      .open(dir.toFile())) {
+                final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                for (; ; ) {
+                  rnd.nextBytes(k);
+                  key.clear();
+                  key.put(k).flip();
+                  val.clear();
+                  db.put(key, val);
+                }
+              }
+            })
+        .isInstanceOf(MapFullException.class);
+  }
+
+  @Test
+  void readOnlySupported() {
+    final Path dir = tempDir.createTempDir();
+    try (Env<ByteBuffer> rwEnv = Env.create().setMaxReaders(1).open(dir.toFile())) {
+      final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
+      rwDb.put(bb(1), bb(42));
+    }
+    try (Env<ByteBuffer> roEnv = Env.create().setMaxReaders(1).open(dir.toFile(), MDB_RDONLY_ENV)) {
+      final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
+      try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
+        assertThat(roDb.get(roTxn, bb(1))).isNotNull();
+      }
+    }
+  }
+
+  @Test
+  void setMapSize() {
+    final Path dir = tempDir.createTempDir();
+    final byte[] k = new byte[500];
+    final ByteBuffer key = allocateDirect(500);
+    final ByteBuffer val = allocateDirect(1_024);
+    final Random rnd = new Random();
+    try (Env<ByteBuffer> env =
+        Env.create()
+            .setMaxReaders(1)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxDbs(1)
+            .open(dir.toFile())) {
+      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+      db.put(bb(1), bb(42));
+      boolean mapFullExThrown = false;
+      try {
+        for (int i = 0; i < 70; i++) {
+          rnd.nextBytes(k);
+          key.clear();
+          key.put(k).flip();
+          val.clear();
+          db.put(key, val);
+        }
+      } catch (final MapFullException mfE) {
+        mapFullExThrown = true;
+      }
+      assertThat(mapFullExThrown).isTrue();
+
+      env.setMapSize(KIBIBYTES.toBytes(1024));
+
+      try (Txn<ByteBuffer> roTxn = env.txnRead()) {
+        final ByteBuffer byteBuffer = db.get(roTxn, bb(1));
+        assertThat(byteBuffer).isNotNull();
+        assertThat(byteBuffer.getInt()).isEqualTo(42);
+      }
+
+      mapFullExThrown = false;
+      try {
+        for (int i = 0; i < 70; i++) {
+          rnd.nextBytes(k);
+          key.clear();
+          key.put(k).flip();
+          val.clear();
+          db.put(key, val);
+        }
+      } catch (final MapFullException mfE) {
+        mapFullExThrown = true;
+      }
+      assertThat(mapFullExThrown).isFalse();
+    }
+  }
+
+  @Test
+  void testDefaultOpen() {
+    final Path dir = tempDir.createTempDir();
+    try (Env<ByteBuffer> env = Env.open(dir.toFile(), 10)) {
+      final EnvInfo info = env.info();
+      assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
+      final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
+      db.put(allocateDirect(1), allocateDirect(1));
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 239a72b1..117ff032 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -361,7 +361,12 @@ void mapFull() {
                       .setMapSize(8, ByteUnit.MEBIBYTES)
                       .setMaxDbs(1)
                       .open(dir)) {
-                final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                final Dbi<ByteBuffer> db =
+                    env.createDbi()
+                        .setDbName(DB_1)
+                        .withDefaultComparator()
+                        .setDbiFlags(MDB_CREATE)
+                        .open();
                 //noinspection InfiniteLoopStatement // Needs infinite loop to fill the env
                 for (; ; ) {
                   rnd.nextBytes(k);
@@ -379,12 +384,19 @@ void mapFull() {
   void readOnlySupported() {
     final Path dir = tempDir.createTempDir();
     try (Env<ByteBuffer> rwEnv = Env.create().setMaxReaders(1).open(dir)) {
-      final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
+      final Dbi<ByteBuffer> rwDb =
+          rwEnv.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
       rwDb.put(bb(1), bb(42));
     }
     try (Env<ByteBuffer> roEnv =
         Env.create().setMaxReaders(1).setEnvFlags(MDB_RDONLY_ENV).open(dir)) {
-      final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1, DbiFlagSet.EMPTY);
+      final Dbi<ByteBuffer> roDb =
+          roEnv
+              .createDbi()
+              .setDbName(DB_1)
+              .withDefaultComparator()
+              .setDbiFlags(DbiFlagSet.EMPTY)
+              .open();
       try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
         assertThat(roDb.get(roTxn, bb(1))).isNotNull();
       }
@@ -400,7 +412,8 @@ void setMapSize() {
     final Random rnd = new Random();
     try (Env<ByteBuffer> env =
         Env.create().setMaxReaders(1).setMapSize(256, ByteUnit.KIBIBYTES).setMaxDbs(1).open(dir)) {
-      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+      final Dbi<ByteBuffer> db =
+          env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
       db.put(bb(1), bb(42));
       boolean mapFullExThrown = false;
@@ -469,7 +482,8 @@ void testDefaultOpen() {
     try (Env<ByteBuffer> env = Env.create().setMapSize(10, ByteUnit.MEBIBYTES).open(dir)) {
       final EnvInfo info = env.info();
       assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
-      final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
+      final Dbi<ByteBuffer> db =
+          env.createDbi().setDbName("test").withDefaultComparator().setDbiFlags(MDB_CREATE).open();
       db.put(allocateDirect(1), allocateDirect(1));
     }
   }
@@ -480,7 +494,12 @@ void testDefaultOpenNoName1() {
     try (Env<ByteBuffer> env = Env.create().setMapSize(10, ByteUnit.MEBIBYTES).open(dir)) {
       final EnvInfo info = env.info();
       assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
-      final Dbi<ByteBuffer> db = env.openDbi((String) null, MDB_CREATE);
+      final Dbi<ByteBuffer> db =
+          env.createDbi()
+              .setDbName((String) null)
+              .withDefaultComparator()
+              .setDbiFlags(MDB_CREATE)
+              .open();
       db.put(bb("abc"), allocateDirect(1));
       db.put(bb("def"), allocateDirect(1));
 
@@ -498,7 +517,12 @@ void testDefaultOpenNoName2() {
     try (Env<ByteBuffer> env = Env.create().setMapSize(10, ByteUnit.MEBIBYTES).open(dir)) {
       final EnvInfo info = env.info();
       assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
-      final Dbi<ByteBuffer> db = env.openDbi((byte[]) null, MDB_CREATE);
+      final Dbi<ByteBuffer> db =
+          env.createDbi()
+              .setDbName((byte[]) null)
+              .withDefaultComparator()
+              .setDbiFlags(MDB_CREATE)
+              .open();
       db.put(bb("abc"), allocateDirect(1));
       db.put(bb("def"), allocateDirect(1));
 
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index e6c8ca88..4aa1245f 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -38,7 +38,12 @@ void buffersNotGarbageCollectedTest() {
     try (final TempDir tempDir = new TempDir()) {
       final Path dir = tempDir.createTempDir();
       try (Env<ByteBuffer> env = Env.create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir)) {
-        final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+        final Dbi<ByteBuffer> db =
+            env.createDbi()
+                .setDbName(DB_NAME)
+                .withDefaultComparator()
+                .setDbiFlags(MDB_CREATE)
+                .open();
 
         try (Txn<ByteBuffer> txn = env.txnWrite()) {
           for (int i = 0; i < 5_000; i++) {
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 096e990b..c2271363 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -96,7 +96,8 @@ void tutorial1() {
 
     // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
     // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_NAME).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     // We want to store some data, so we will need a direct ByteBuffer.
     // Note that LMDB keys cannot exceed maxKeySize bytes (511 bytes by default).
@@ -146,7 +147,8 @@ void tutorial2() {
     final Path dir = tempDir.createTempDir();
     try {
       final Env<ByteBuffer> env = createSimpleEnv(dir);
-      final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+      final Dbi<ByteBuffer> db =
+          env.createDbi().setDbName(DB_NAME).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
       final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
       final ByteBuffer val = ByteBuffer.allocateDirect(700);
 
@@ -222,7 +224,8 @@ void tutorial2() {
   void tutorial3() {
     final Path dir = tempDir.createTempDir();
     final Env<ByteBuffer> env = createSimpleEnv(dir);
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_NAME).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
     final ByteBuffer val = ByteBuffer.allocateDirect(700);
 
@@ -295,7 +298,8 @@ void tutorial3() {
   void tutorial4() {
     final Path dir = tempDir.createTempDir();
     final Env<ByteBuffer> env = createSimpleEnv(dir);
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_NAME).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
@@ -353,7 +357,12 @@ void tutorial5() {
 
     // This time we're going to tell the Dbi it can store > 1 value per key.
     // There are other flags available if we're storing integers etc.
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_NAME)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
 
     // Duplicate support requires both keys and values to be <= max key size.
     final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
@@ -428,7 +437,8 @@ void tutorial7() {
     final Env<DirectBuffer> env =
         Env.create(PROXY_DB).setMapSize(10, ByteUnit.MEBIBYTES).setMaxDbs(1).open(dir);
 
-    final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+    final Dbi<DirectBuffer> db =
+        env.createDbi().setDbName(DB_NAME).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     final ByteBuffer keyBb = ByteBuffer.allocateDirect(env.getMaxKeySize());
     final MutableDirectBuffer key = new UnsafeBuffer(keyBb);
@@ -487,7 +497,12 @@ void tutorial8() {
     // This time we're going to tell the Dbi that all the keys are integers.
     // MDB_INTEGERKEY applies to both int and long keys.
     // LMDB can make optimisations for better performance.
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_NAME)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_INTEGERKEY)
+            .open();
 
     // MDB_INTEGERKEY requires that the keys are written/read in native order
     final ByteBuffer key = ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
@@ -541,7 +556,12 @@ void tutorial9() {
     final Path dir = tempDir.createTempDir();
     final Env<ByteBuffer> env = createSimpleEnv(dir);
 
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_REVERSEKEY));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_NAME)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_REVERSEKEY)
+            .open();
 
     final ByteBuffer key = ByteBuffer.allocateDirect(100);
     final ByteBuffer val = ByteBuffer.allocateDirect(100);
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index b1898cd4..790d81de 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -82,7 +82,12 @@ void afterEach() {
   void largeKeysRejected() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE);
+              final Dbi<ByteBuffer> dbi =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE)
+                      .open();
               final ByteBuffer key = allocateDirect(env.getMaxKeySize() + 1);
               key.limit(key.capacity());
               dbi.put(key, bb(2));
@@ -92,7 +97,8 @@ void largeKeysRejected() {
 
   @Test
   void rangeSearch() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     final ByteBuffer key = allocateDirect(env.getMaxKeySize());
     key.put("cherry".getBytes(UTF_8)).flip();
@@ -126,7 +132,7 @@ void rangeSearch() {
 
   @Test
   void readOnlyTxnAllowedInReadOnlyEnv() {
-    env.openDbi(DB_1, MDB_CREATE);
+    env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Env<ByteBuffer> roEnv =
         create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV).open(file)) {
       assertThat(roEnv.txnRead()).isNotNull();
@@ -137,7 +143,11 @@ void readOnlyTxnAllowedInReadOnlyEnv() {
   void readWriteTxnDeniedInReadOnlyEnv() {
     assertThatThrownBy(
             () -> {
-              env.openDbi(DB_1, MDB_CREATE);
+              env.createDbi()
+                  .setDbName(DB_1)
+                  .withDefaultComparator()
+                  .setDbiFlags(MDB_CREATE)
+                  .open();
               env.close();
               try (Env<ByteBuffer> roEnv =
                   create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV).open(file)) {
@@ -183,8 +193,8 @@ void testCheckWritesAllowed() {
 
   @Test
   void testGetId() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     final AtomicLong txId1 = new AtomicLong();
     final AtomicLong txId2 = new AtomicLong();
 
@@ -419,7 +429,12 @@ void txResetDeniedForReadWriteTransaction() {
   void zeroByteKeysRejected() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE);
+              final Dbi<ByteBuffer> dbi =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE)
+                      .open();
               final ByteBuffer key = allocateDirect(4);
               key.putInt(1);
               assertThat(key.remaining()).isEqualTo(0); // because key.flip() skipped

From 8c19bf43748c6faf334b1e5e8d6e2e0f2e920bbc Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 15:58:02 +0000
Subject: [PATCH 64/90] Add test coverage

---
 src/main/java/org/lmdbjava/Dbi.java           |  4 ++
 src/main/java/org/lmdbjava/Env.java           | 22 +++++-
 .../org/lmdbjava/AbstractFlagSetTest.java     | 15 ++++
 .../java/org/lmdbjava/CopyFlagSetTest.java    |  7 ++
 .../org/lmdbjava/CursorIterableRangeTest.java | 69 +++++++++++--------
 .../java/org/lmdbjava/DbiFlagSetTest.java     |  7 ++
 .../java/org/lmdbjava/EnvFlagSetTest.java     |  7 ++
 src/test/java/org/lmdbjava/EnvTest.java       | 11 ++-
 .../java/org/lmdbjava/PutFlagSetTest.java     |  7 ++
 .../java/org/lmdbjava/TxnFlagSetTest.java     |  7 ++
 src/test/java/org/lmdbjava/VerifierTest.java  | 16 +++++
 11 files changed, 139 insertions(+), 33 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index e5d66568..aff6fff8 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -296,6 +296,10 @@ public String getNameAsString() {
    * @throws RuntimeException if the name can't be decoded.
    */
   public String getNameAsString(final Charset charset) {
+    return getNameAsString(this.name, charset);
+  }
+
+  static String getNameAsString(final byte[] name, final Charset charset) {
     if (name == null) {
       return "";
     } else {
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index eec1c354..3a068ae4 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -37,6 +37,7 @@
 import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
+import java.util.stream.Collectors;
 import jnr.ffi.Pointer;
 import jnr.ffi.byref.IntByReference;
 import jnr.ffi.byref.PointerByReference;
@@ -230,7 +231,26 @@ public List<byte[]> getDbiNames() {
         } while (cursor.next());
       }
     }
-    return result;
+    return Collections.unmodifiableList(result);
+  }
+
+  /**
+   * Obtain the DBI names.
+   *
+   * <p>This method is only compatible with {@link Env}s that use named databases. If an unnamed
+   * {@link Dbi} is being used to store data, this method will attempt to return all such keys from
+   * the unnamed database.
+   *
+   * <p>This method must not be called from concurrent threads.
+   *
+   * @return a list of DBI names (never null)
+   */
+  public List<String> getDbiNames(final Charset charset) {
+    final List<byte[]> dbiNames = getDbiNames();
+    return dbiNames.stream()
+        .map(nameBytes ->
+            Dbi.getNameAsString(nameBytes, charset))
+        .collect(Collectors.toList());
   }
 
   /**
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index bef97911..c2887e93 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -20,9 +20,12 @@
 import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.function.Function;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 public abstract class AbstractFlagSetTest<
@@ -42,6 +45,8 @@ public abstract class AbstractFlagSetTest<
 
   abstract Class<T> getFlagType();
 
+  abstract Function<EnumSet<T>, F> getConstructor();
+
   T getFirst() {
     return getAllFlags().get(0);
   }
@@ -75,6 +80,7 @@ void testSingleFlagSet() {
       assertThat(flagSet.areAnySet(flag)).isTrue();
       assertThat(flagSet.areAnySet(null)).isFalse();
       assertThat(flagSet.areAnySet(getEmptyFlagSet())).isFalse();
+      assertThat(flagSet.isSet(null)).isFalse();
       assertThat(flagSet.isSet(getFirst())).isEqualTo(getFirst() == flag);
       if (getFirst() == flag) {
         assertThat(flagSet.getMask()).isEqualTo(MaskedFlag.mask(getFirst()));
@@ -155,6 +161,15 @@ void testClearBuilder() {
     assertThat(flagSet.isEmpty()).isTrue();
   }
 
+  @Test
+  void testConstructor() {
+    final Function<EnumSet<T>, F> constructor = getConstructor();
+    EnumSet<T> set = EnumSet.allOf(getFlagType());
+    final F flagSet = constructor.apply(set);
+    Assertions.assertThat(flagSet.getFlags())
+        .containsExactlyInAnyOrderElementsOf(getAllFlags());
+  }
+
   private T[] toArray(final int cnt) {
     //noinspection unchecked
     return (T[]) Array.newInstance(getFlagType(), cnt);
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 96203af9..90ced57a 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -17,7 +17,9 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -65,4 +67,9 @@ CopyFlagSet getFlagSet(CopyFlags flag) {
   Class<CopyFlags> getFlagType() {
     return CopyFlags.class;
   }
+
+  @Override
+  Function<EnumSet<CopyFlags>, CopyFlagSet> getConstructor() {
+    return CopyFlagSetImpl::new;
+  }
 }
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 66d534a5..5f88a012 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -31,13 +31,17 @@
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvFileSource;
 import org.lmdbjava.CursorIterable.KeyVal;
 
-/** Test {@link CursorIterable}. */
+/**
+ * Test {@link CursorIterable}.
+ */
 public final class CursorIterableRangeTest {
 
   private static final DbiFlagSet FLAGSET_DUPSORT =
@@ -210,29 +214,36 @@ private void testCSV(
       final String expectedKV,
       final int keyLen,
       final ByteOrder byteOrder) {
-    // First test with our default iterator comparator
-    testCSV(
-        DbiBuilder.Stage2::withDefaultComparator,
-        dbPopulator,
-        dbiFlags,
-        keyType,
-        startKey,
-        stopKey,
-        expectedKV,
-        keyLen,
-        byteOrder);
 
+    // We want to assert that the behaviour of all 4 comparator functions
+    // is identical.
+
+    final List<Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>> comparatorFuncs =
+        new ArrayList<>();
+
+    // First test with our default iterator comparator
+    comparatorFuncs.add(DbiBuilder.Stage2::withDefaultComparator);
     // Now test with mdp_cmp doing all comparisons, should be the same
-    testCSV(
-        DbiBuilder.Stage2::withNativeComparator,
-        dbPopulator,
-        dbiFlags,
-        keyType,
-        startKey,
-        stopKey,
-        expectedKV,
-        keyLen,
-        byteOrder);
+    comparatorFuncs.add(DbiBuilder.Stage2::withNativeComparator);
+    // Now test with the java callback comparator doing all the work
+    comparatorFuncs.add(byteBufferStage2 ->
+        byteBufferStage2.withCallbackComparator(ByteBufferProxy.PROXY_OPTIMAL::getComparator));
+    // Now test with the java comparator for iteration only
+    comparatorFuncs.add(byteBufferStage2 ->
+        byteBufferStage2.withIteratorComparator(ByteBufferProxy.PROXY_OPTIMAL::getComparator));
+
+    for (Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc : comparatorFuncs) {
+      testCSV(
+          comparatorFunc,
+          dbPopulator,
+          dbiFlags,
+          keyType,
+          startKey,
+          stopKey,
+          expectedKV,
+          keyLen,
+          byteOrder);
+    }
   }
 
   private void testCSV(
@@ -248,12 +259,12 @@ private void testCSV(
     try (final TempDir tempDir = new TempDir()) {
       final Path file = tempDir.createTempFile();
       try (final Env<ByteBuffer> env =
-          create()
-              .setMapSize(256, ByteUnit.KIBIBYTES)
-              .setMaxReaders(1)
-              .setMaxDbs(1)
-              .setEnvFlags(EnvFlags.MDB_NOSUBDIR)
-              .open(file)) {
+               create()
+                   .setMapSize(256, ByteUnit.KIBIBYTES)
+                   .setMaxReaders(1)
+                   .setMaxDbs(1)
+                   .setEnvFlags(EnvFlags.MDB_NOSUBDIR)
+                   .open(file)) {
 
         final DbiBuilder.Stage2<ByteBuffer> builderStage2 = env.createDbi().setDbName(DB_1);
         final DbiBuilder.Stage3<ByteBuffer> builderStage3 = comparatorFunc.apply(builderStage2);
@@ -267,7 +278,7 @@ private void testCSV(
 
           final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
           try (Txn<ByteBuffer> txn = env.txnRead();
-              CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
+               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
             for (final KeyVal<ByteBuffer> kv : c) {
               final long key = getLong(kv.key(), byteOrder);
               final long val = getLong(kv.val(), ByteOrder.BIG_ENDIAN);
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index 5be7bc60..f9f591a5 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -17,7 +17,9 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -65,4 +67,9 @@ DbiFlagSet getFlagSet(DbiFlags[] flags) {
   DbiFlagSet getFlagSet(DbiFlags flag) {
     return DbiFlagSet.of(flag);
   }
+
+  @Override
+  Function<EnumSet<DbiFlags>, DbiFlagSet> getConstructor() {
+    return DbiFlagSetImpl::new;
+  }
 }
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index 24300c1f..1124a91d 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -17,7 +17,9 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -65,4 +67,9 @@ EnvFlagSet getFlagSet(EnvFlags flag) {
   Class<EnvFlags> getFlagType() {
     return EnvFlags.class;
   }
+
+  @Override
+  Function<EnumSet<EnvFlags>, EnvFlagSet> getConstructor() {
+    return EnvFlagSetImpl::new;
+  }
 }
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 117ff032..b333f6f8 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -504,10 +504,15 @@ void testDefaultOpenNoName1() {
       db.put(bb("def"), allocateDirect(1));
 
       // As this is the unnamed database it returns all keys in the unnamed db
-      final List<byte[]> dbiNames = env.getDbiNames();
+      final List<byte[]> dbiNamesBytes = env.getDbiNames();
+      assertThat(dbiNamesBytes).hasSize(2);
+      assertThat(dbiNamesBytes.get(0)).isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
+      assertThat(dbiNamesBytes.get(1)).isEqualTo("def".getBytes(Env.DEFAULT_NAME_CHARSET));
+
+      final List<String> dbiNames = env.getDbiNames(Env.DEFAULT_NAME_CHARSET);
       assertThat(dbiNames).hasSize(2);
-      assertThat(dbiNames.get(0)).isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
-      assertThat(dbiNames.get(1)).isEqualTo("def".getBytes(Env.DEFAULT_NAME_CHARSET));
+      assertThat(dbiNames.get(0)).isEqualTo("abc");
+      assertThat(dbiNames.get(1)).isEqualTo("def");
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 93d3aab0..9fe858f0 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -19,7 +19,9 @@
 import java.time.Instant;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import org.assertj.core.api.Assertions;
@@ -69,6 +71,11 @@ Class<PutFlags> getFlagType() {
     return PutFlags.class;
   }
 
+  @Override
+  Function<EnumSet<PutFlags>, PutFlagSet> getConstructor() {
+    return PutFlagSetImpl::new;
+  }
+
   @Test
   public void testAddFlagVsCheckPresence() {
 
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 2d700525..5390ed66 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -17,7 +17,9 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -65,4 +67,9 @@ TxnFlagSet getFlagSet(TxnFlags flag) {
   Class<TxnFlags> getFlagType() {
     return TxnFlags.class;
   }
+
+  @Override
+  Function<EnumSet<TxnFlags>, TxnFlagSet> getConstructor() {
+    return TxnFlagSetImpl::new;
+  }
 }
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index f2d95930..28b48ae4 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -23,6 +23,7 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.concurrent.TimeUnit;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /** Test {@link Verifier}. */
@@ -39,7 +40,22 @@ void verification() {
               .setMapSize(10, ByteUnit.MEBIBYTES)
               .setEnvFlags(MDB_NOSUBDIR)
               .open(file)) {
+
+        // Create a DB to ensure that the verifier can c
+        env.createDbi()
+            .setDbName("db1")
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+
+        Assertions.assertThat(env.getDbiNames(Env.DEFAULT_NAME_CHARSET))
+            .containsExactly("db1");
+
         final Verifier v = new Verifier(env);
+
+        Assertions.assertThat(env.getDbiNames(Env.DEFAULT_NAME_CHARSET))
+            .doesNotContain("db1");
+
         final int seconds = Integer.getInteger("verificationSeconds", 2);
         assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);
       }

From 496e5eaad1b88f350d1b5b6a2a6ea72751f5fb72 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 16:02:01 +0000
Subject: [PATCH 65/90] Add test coverage

---
 src/test/java/org/lmdbjava/EnvTest.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index b333f6f8..13a0bfd1 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -204,6 +204,19 @@ void copyDirectoryBased() {
     }
   }
 
+  @Test
+  void copyDirectoryBased_noFlags() {
+    final Path dest = tempDir.createTempDir();
+    assertThat(Files.exists(dest)).isTrue();
+    assertThat(Files.isDirectory(dest)).isTrue();
+    assertThat(FileUtil.count(dest)).isEqualTo(0);
+    final Path src = tempDir.createTempDir();
+    try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
+      env.copy(dest);
+      assertThat(FileUtil.count(dest)).isEqualTo(1);
+    }
+  }
+
   @Test
   void copyDirectoryRejectsFileDestination() {
     assertThatThrownBy(
@@ -436,6 +449,12 @@ void setMapSize() {
               })
           .isInstanceOf(IllegalArgumentException.class);
 
+      assertThatThrownBy(
+          () -> {
+            env.setMapSize(-1);
+          })
+          .isInstanceOf(IllegalArgumentException.class);
+
       env.setMapSize(1024, ByteUnit.KIBIBYTES);
 
       try (Txn<ByteBuffer> roTxn = env.txnRead()) {

From 7bd33324dae5af17acdc7366f4e3fbc470786d20 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 16:02:17 +0000
Subject: [PATCH 66/90] Auto format

---
 src/main/java/org/lmdbjava/Env.java           |  3 +-
 .../org/lmdbjava/AbstractFlagSetTest.java     |  3 +-
 .../org/lmdbjava/CursorIterableRangeTest.java | 35 ++++++++++---------
 src/test/java/org/lmdbjava/EnvTest.java       |  6 ++--
 src/test/java/org/lmdbjava/VerifierTest.java  |  6 ++--
 5 files changed, 25 insertions(+), 28 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 3a068ae4..af3a6596 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -248,8 +248,7 @@ public List<byte[]> getDbiNames() {
   public List<String> getDbiNames(final Charset charset) {
     final List<byte[]> dbiNames = getDbiNames();
     return dbiNames.stream()
-        .map(nameBytes ->
-            Dbi.getNameAsString(nameBytes, charset))
+        .map(nameBytes -> Dbi.getNameAsString(nameBytes, charset))
         .collect(Collectors.toList());
   }
 
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index c2887e93..4c7efa1c 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -166,8 +166,7 @@ void testConstructor() {
     final Function<EnumSet<T>, F> constructor = getConstructor();
     EnumSet<T> set = EnumSet.allOf(getFlagType());
     final F flagSet = constructor.apply(set);
-    Assertions.assertThat(flagSet.getFlags())
-        .containsExactlyInAnyOrderElementsOf(getAllFlags());
+    Assertions.assertThat(flagSet.getFlags()).containsExactlyInAnyOrderElementsOf(getAllFlags());
   }
 
   private T[] toArray(final int cnt) {
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 5f88a012..ab76d3fc 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -39,9 +39,7 @@
 import org.junit.jupiter.params.provider.CsvFileSource;
 import org.lmdbjava.CursorIterable.KeyVal;
 
-/**
- * Test {@link CursorIterable}.
- */
+/** Test {@link CursorIterable}. */
 public final class CursorIterableRangeTest {
 
   private static final DbiFlagSet FLAGSET_DUPSORT =
@@ -218,21 +216,24 @@ private void testCSV(
     // We want to assert that the behaviour of all 4 comparator functions
     // is identical.
 
-    final List<Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>> comparatorFuncs =
-        new ArrayList<>();
+    final List<Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>>
+        comparatorFuncs = new ArrayList<>();
 
     // First test with our default iterator comparator
     comparatorFuncs.add(DbiBuilder.Stage2::withDefaultComparator);
     // Now test with mdp_cmp doing all comparisons, should be the same
     comparatorFuncs.add(DbiBuilder.Stage2::withNativeComparator);
     // Now test with the java callback comparator doing all the work
-    comparatorFuncs.add(byteBufferStage2 ->
-        byteBufferStage2.withCallbackComparator(ByteBufferProxy.PROXY_OPTIMAL::getComparator));
+    comparatorFuncs.add(
+        byteBufferStage2 ->
+            byteBufferStage2.withCallbackComparator(ByteBufferProxy.PROXY_OPTIMAL::getComparator));
     // Now test with the java comparator for iteration only
-    comparatorFuncs.add(byteBufferStage2 ->
-        byteBufferStage2.withIteratorComparator(ByteBufferProxy.PROXY_OPTIMAL::getComparator));
+    comparatorFuncs.add(
+        byteBufferStage2 ->
+            byteBufferStage2.withIteratorComparator(ByteBufferProxy.PROXY_OPTIMAL::getComparator));
 
-    for (Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc : comparatorFuncs) {
+    for (Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc :
+        comparatorFuncs) {
       testCSV(
           comparatorFunc,
           dbPopulator,
@@ -259,12 +260,12 @@ private void testCSV(
     try (final TempDir tempDir = new TempDir()) {
       final Path file = tempDir.createTempFile();
       try (final Env<ByteBuffer> env =
-               create()
-                   .setMapSize(256, ByteUnit.KIBIBYTES)
-                   .setMaxReaders(1)
-                   .setMaxDbs(1)
-                   .setEnvFlags(EnvFlags.MDB_NOSUBDIR)
-                   .open(file)) {
+          create()
+              .setMapSize(256, ByteUnit.KIBIBYTES)
+              .setMaxReaders(1)
+              .setMaxDbs(1)
+              .setEnvFlags(EnvFlags.MDB_NOSUBDIR)
+              .open(file)) {
 
         final DbiBuilder.Stage2<ByteBuffer> builderStage2 = env.createDbi().setDbName(DB_1);
         final DbiBuilder.Stage3<ByteBuffer> builderStage3 = comparatorFunc.apply(builderStage2);
@@ -278,7 +279,7 @@ private void testCSV(
 
           final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
           try (Txn<ByteBuffer> txn = env.txnRead();
-               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
+              CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
             for (final KeyVal<ByteBuffer> kv : c) {
               final long key = getLong(kv.key(), byteOrder);
               final long val = getLong(kv.val(), ByteOrder.BIG_ENDIAN);
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 13a0bfd1..38d8aa53 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -450,9 +450,9 @@ void setMapSize() {
           .isInstanceOf(IllegalArgumentException.class);
 
       assertThatThrownBy(
-          () -> {
-            env.setMapSize(-1);
-          })
+              () -> {
+                env.setMapSize(-1);
+              })
           .isInstanceOf(IllegalArgumentException.class);
 
       env.setMapSize(1024, ByteUnit.KIBIBYTES);
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 28b48ae4..ee396084 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -48,13 +48,11 @@ void verification() {
             .setDbiFlags(DbiFlags.MDB_CREATE)
             .open();
 
-        Assertions.assertThat(env.getDbiNames(Env.DEFAULT_NAME_CHARSET))
-            .containsExactly("db1");
+        Assertions.assertThat(env.getDbiNames(Env.DEFAULT_NAME_CHARSET)).containsExactly("db1");
 
         final Verifier v = new Verifier(env);
 
-        Assertions.assertThat(env.getDbiNames(Env.DEFAULT_NAME_CHARSET))
-            .doesNotContain("db1");
+        Assertions.assertThat(env.getDbiNames(Env.DEFAULT_NAME_CHARSET)).doesNotContain("db1");
 
         final int seconds = Integer.getInteger("verificationSeconds", 2);
         assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);

From 06523f92d02d788c0cda1cf4a28466ff740a278a Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 16:18:09 +0000
Subject: [PATCH 67/90] Add more tests

---
 src/test/java/org/lmdbjava/EnvTest.java | 88 +++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 38d8aa53..a54225d8 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -23,6 +23,7 @@
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.Builder.MAX_READERS_DEFAULT;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.EnvFlags.MDB_NOTLS;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.bb;
@@ -32,8 +33,10 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Collection;
 import java.util.List;
 import java.util.Random;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -557,4 +560,89 @@ void testDefaultOpenNoName2() {
       assertThat(dbiNames.get(1)).isEqualTo("def".getBytes(Env.DEFAULT_NAME_CHARSET));
     }
   }
+
+  @Test
+  void addEnvFlag() {
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+             Env.create()
+                 .setMapSize(1, ByteUnit.MEBIBYTES)
+                 .setMaxDbs(1)
+                 .setMaxReaders(1)
+                 .addEnvFlag(MDB_NOSUBDIR)
+                 .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
+                 .open(file)) {
+      env.sync(true);
+      assertThat(Files.isRegularFile(file)).isTrue();
+    }
+  }
+
+  @Test
+  void addEnvFlags() {
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+             Env.create()
+                 .setMapSize(1, ByteUnit.MEBIBYTES)
+                 .setMaxDbs(1)
+                 .setMaxReaders(1)
+                 .addEnvFlags(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS))
+                 .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
+                 .addEnvFlag(null) // no-op
+                 .addEnvFlags(null) // no-op
+                 .open(file)) {
+      env.sync(true);
+      assertThat(Files.isRegularFile(file)).isTrue();
+    }
+  }
+
+  @Test
+  void setEnvFlags_null1() {
+    final Path file = tempDir.createTempFile();
+    // MDB_NOSUBDIR is cleared out so it will error as file is a file not a dir
+    Assertions.assertThatThrownBy(() -> {
+      try (Env<ByteBuffer> env =
+               Env.create()
+                   .setMapSize(1, ByteUnit.MEBIBYTES)
+                   .setMaxDbs(1)
+                   .setMaxReaders(1)
+                   .addEnvFlag(MDB_NOSUBDIR)
+                   .setEnvFlags((Collection<EnvFlags>) null) // Clears the flags
+                   .open(file)) {
+      }
+    }).isInstanceOf(LmdbNativeException.class);
+  }
+
+  @Test
+  void setEnvFlags_null2() {
+    final Path file = tempDir.createTempFile();
+    // MDB_NOSUBDIR is cleared out so it will error as file is a file not a dir
+    Assertions.assertThatThrownBy(() -> {
+      try (Env<ByteBuffer> env =
+               Env.create()
+                   .setMapSize(1, ByteUnit.MEBIBYTES)
+                   .setMaxDbs(1)
+                   .setMaxReaders(1)
+                   .addEnvFlag(MDB_NOSUBDIR)
+                   .setEnvFlags((EnvFlags) null) // Clears the flags
+                   .open(file)) {
+      }
+    }).isInstanceOf(LmdbNativeException.class);
+  }
+
+  @Test
+  void setEnvFlags_null3() {
+    final Path file = tempDir.createTempFile();
+    // MDB_NOSUBDIR is cleared out so it will error as file is a file not a dir
+    Assertions.assertThatThrownBy(() -> {
+      try (Env<ByteBuffer> env =
+               Env.create()
+                   .setMapSize(1, ByteUnit.MEBIBYTES)
+                   .setMaxDbs(1)
+                   .setMaxReaders(1)
+                   .addEnvFlag(MDB_NOSUBDIR)
+                   .setEnvFlags((EnvFlagSet) null) // Clears the flags
+                   .open(file)) {
+      }
+    }).isInstanceOf(LmdbNativeException.class);
+  }
 }

From fe4133869e80afd01f6bba37f2650887eab8e156 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 16:39:46 +0000
Subject: [PATCH 68/90] Add test coverage

---
 .../org/lmdbjava/AbstractFlagSetTest.java     |   7 ++
 src/test/java/org/lmdbjava/EnvTest.java       | 101 +++++++++---------
 2 files changed, 59 insertions(+), 49 deletions(-)

diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index 4c7efa1c..54f168cc 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -90,7 +90,14 @@ void testSingleFlagSet() {
       }
       assertThat(flagSet.toString()).isNotNull();
       assertThat(flag.name()).isNotNull();
+      assertThat(flag.isSet(flag)).isTrue();
+      assertThat(flag.isSet(null)).isFalse();
       assertThat(flagSet.getMaskWith(null)).isEqualTo(flagSet.getMask());
+      assertThat(flag.isEmpty()).isFalse();
+      assertThat(flag.size()).isEqualTo(1);
+
+      assertThat(flag.getFlags()).containsExactlyElementsOf(getFlagSet(flag).getFlags());
+      assertThat(flag.getMask()).isEqualTo(getFlagSet(flag).getMask());
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index a54225d8..3f60076a 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -565,13 +565,13 @@ void testDefaultOpenNoName2() {
   void addEnvFlag() {
     final Path file = tempDir.createTempFile();
     try (Env<ByteBuffer> env =
-             Env.create()
-                 .setMapSize(1, ByteUnit.MEBIBYTES)
-                 .setMaxDbs(1)
-                 .setMaxReaders(1)
-                 .addEnvFlag(MDB_NOSUBDIR)
-                 .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
-                 .open(file)) {
+        Env.create()
+            .setMapSize(1, ByteUnit.MEBIBYTES)
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .addEnvFlag(MDB_NOSUBDIR)
+            .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
+            .open(file)) {
       env.sync(true);
       assertThat(Files.isRegularFile(file)).isTrue();
     }
@@ -581,15 +581,15 @@ void addEnvFlag() {
   void addEnvFlags() {
     final Path file = tempDir.createTempFile();
     try (Env<ByteBuffer> env =
-             Env.create()
-                 .setMapSize(1, ByteUnit.MEBIBYTES)
-                 .setMaxDbs(1)
-                 .setMaxReaders(1)
-                 .addEnvFlags(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS))
-                 .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
-                 .addEnvFlag(null) // no-op
-                 .addEnvFlags(null) // no-op
-                 .open(file)) {
+        Env.create()
+            .setMapSize(1, ByteUnit.MEBIBYTES)
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .addEnvFlags(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS))
+            .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
+            .addEnvFlag(null) // no-op
+            .addEnvFlags(null) // no-op
+            .open(file)) {
       env.sync(true);
       assertThat(Files.isRegularFile(file)).isTrue();
     }
@@ -599,50 +599,53 @@ void addEnvFlags() {
   void setEnvFlags_null1() {
     final Path file = tempDir.createTempFile();
     // MDB_NOSUBDIR is cleared out so it will error as file is a file not a dir
-    Assertions.assertThatThrownBy(() -> {
-      try (Env<ByteBuffer> env =
-               Env.create()
-                   .setMapSize(1, ByteUnit.MEBIBYTES)
-                   .setMaxDbs(1)
-                   .setMaxReaders(1)
-                   .addEnvFlag(MDB_NOSUBDIR)
-                   .setEnvFlags((Collection<EnvFlags>) null) // Clears the flags
-                   .open(file)) {
-      }
-    }).isInstanceOf(LmdbNativeException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              try (Env<ByteBuffer> env =
+                  Env.create()
+                      .setMapSize(1, ByteUnit.MEBIBYTES)
+                      .setMaxDbs(1)
+                      .setMaxReaders(1)
+                      .addEnvFlag(MDB_NOSUBDIR)
+                      .setEnvFlags((Collection<EnvFlags>) null) // Clears the flags
+                      .open(file)) {}
+            })
+        .isInstanceOf(LmdbNativeException.class);
   }
 
   @Test
   void setEnvFlags_null2() {
     final Path file = tempDir.createTempFile();
     // MDB_NOSUBDIR is cleared out so it will error as file is a file not a dir
-    Assertions.assertThatThrownBy(() -> {
-      try (Env<ByteBuffer> env =
-               Env.create()
-                   .setMapSize(1, ByteUnit.MEBIBYTES)
-                   .setMaxDbs(1)
-                   .setMaxReaders(1)
-                   .addEnvFlag(MDB_NOSUBDIR)
-                   .setEnvFlags((EnvFlags) null) // Clears the flags
-                   .open(file)) {
-      }
-    }).isInstanceOf(LmdbNativeException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              try (Env<ByteBuffer> env =
+                  Env.create()
+                      .setMapSize(1, ByteUnit.MEBIBYTES)
+                      .setMaxDbs(1)
+                      .setMaxReaders(1)
+                      .addEnvFlag(MDB_NOSUBDIR)
+                      .setEnvFlags((EnvFlags) null) // Clears the flags
+                      .open(file)) {}
+            })
+        .isInstanceOf(LmdbNativeException.class);
   }
 
   @Test
   void setEnvFlags_null3() {
     final Path file = tempDir.createTempFile();
     // MDB_NOSUBDIR is cleared out so it will error as file is a file not a dir
-    Assertions.assertThatThrownBy(() -> {
-      try (Env<ByteBuffer> env =
-               Env.create()
-                   .setMapSize(1, ByteUnit.MEBIBYTES)
-                   .setMaxDbs(1)
-                   .setMaxReaders(1)
-                   .addEnvFlag(MDB_NOSUBDIR)
-                   .setEnvFlags((EnvFlagSet) null) // Clears the flags
-                   .open(file)) {
-      }
-    }).isInstanceOf(LmdbNativeException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              try (Env<ByteBuffer> env =
+                  Env.create()
+                      .setMapSize(1, ByteUnit.MEBIBYTES)
+                      .setMaxDbs(1)
+                      .setMaxReaders(1)
+                      .addEnvFlag(MDB_NOSUBDIR)
+                      .setEnvFlags((EnvFlagSet) null) // Clears the flags
+                      .open(file)) {}
+            })
+        .isInstanceOf(LmdbNativeException.class);
   }
 }

From 38eac0d5b4791ae40c2ee23d093819a7c26f02ad Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 17:42:58 +0000
Subject: [PATCH 69/90] Add ByteBufProxyTest, refactor some test classes

---
 .../java/org/lmdbjava/ByteBufProxyTest.java   | 150 ++++++++++++++++++
 .../org/lmdbjava/ByteBufferProxyTest.java     |  61 ++++++-
 .../lmdbjava/ComparatorIntegerKeyTest.java    |  73 +++++----
 .../java/org/lmdbjava/ComparatorResult.java   |  25 +++
 .../java/org/lmdbjava/ComparatorTest.java     | 113 +++++++------
 src/test/java/org/lmdbjava/CompareType.java   |   8 +
 src/test/java/org/lmdbjava/TestUtils.java     |   7 +
 7 files changed, 347 insertions(+), 90 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/ByteBufProxyTest.java
 create mode 100644 src/test/java/org/lmdbjava/ComparatorResult.java
 create mode 100644 src/test/java/org/lmdbjava/CompareType.java

diff --git a/src/test/java/org/lmdbjava/ByteBufProxyTest.java b/src/test/java/org/lmdbjava/ByteBufProxyTest.java
new file mode 100644
index 00000000..245c7b4d
--- /dev/null
+++ b/src/test/java/org/lmdbjava/ByteBufProxyTest.java
@@ -0,0 +1,150 @@
+package org.lmdbjava;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.PooledByteBufAllocator;
+import java.nio.ByteOrder;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Random;
+import java.util.Set;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class ByteBufProxyTest {
+
+  @Test
+  public void verifyComparators_int() {
+    final Random random = new Random(203948);
+    final ByteBufProxy byteBufProxy = new ByteBufProxy(PooledByteBufAllocator.DEFAULT);
+    final ByteBuf buffer1native = byteBufProxy.allocate().capacity(Integer.BYTES);
+    final ByteBuf buffer2native = byteBufProxy.allocate().capacity(Integer.BYTES);
+    final ByteBuf buffer1be = byteBufProxy.allocate().capacity(Integer.BYTES);
+    final ByteBuf buffer2be = byteBufProxy.allocate().capacity(Integer.BYTES);
+    final int[] values = random.ints().filter(i -> i >= 0).limit(5_000_000).toArray();
+
+    final LinkedHashMap<CompareType, Comparator<ByteBuf>> comparators = new LinkedHashMap<>();
+    comparators.put(CompareType.INTEGER_KEY, ByteBufProxy::compareAsIntegerKeys);
+    comparators.put(CompareType.LEXICOGRAPHIC, ByteBufProxy::compareLexicographically);
+
+    final LinkedHashMap<CompareType, ComparatorResult> results =
+        new LinkedHashMap<>(comparators.size());
+    final Set<ComparatorResult> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      resetBuffer(buffer1native);
+      resetBuffer(buffer2native);
+      resetBuffer(buffer1be);
+      resetBuffer(buffer2be);
+
+      final int val1 = values[i - 1];
+      final int val2 = values[i];
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        buffer1native.writeIntLE(val1);
+        buffer2native.writeIntLE(val2);
+      } else {
+        buffer1native.writeInt(val1);
+        buffer2native.writeInt(val2);
+      }
+      buffer1be.writeInt(val1);
+      buffer2be.writeInt(val2);
+
+      Assertions.assertThat(buffer1native.readableBytes()).isEqualTo(Integer.BYTES);
+      Assertions.assertThat(buffer2native.readableBytes()).isEqualTo(Integer.BYTES);
+      Assertions.assertThat(buffer1be.readableBytes()).isEqualTo(Integer.BYTES);
+      Assertions.assertThat(buffer2be.readableBytes()).isEqualTo(Integer.BYTES);
+
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach(
+          (compareType, comparator) -> {
+            final ComparatorResult result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (compareType == CompareType.INTEGER_KEY) {
+              result = TestUtils.compare(comparator, buffer1native, buffer2native);
+            } else {
+              result = TestUtils.compare(comparator, buffer1be, buffer2be);
+            }
+            results.put(compareType, result);
+            uniqueResults.add(result);
+          });
+
+      if (uniqueResults.size() != 1) {
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+
+  @Test
+  public void verifyComparators_long() {
+    final Random random = new Random(203948);
+    final ByteBufProxy byteBufProxy = new ByteBufProxy(PooledByteBufAllocator.DEFAULT);
+    final ByteBuf buffer1native = byteBufProxy.allocate().capacity(Long.BYTES);
+    final ByteBuf buffer2native = byteBufProxy.allocate().capacity(Long.BYTES);
+    final ByteBuf buffer1be = byteBufProxy.allocate().capacity(Long.BYTES);
+    final ByteBuf buffer2be = byteBufProxy.allocate().capacity(Long.BYTES);
+    final long[] values = random.longs().filter(i -> i >= 0).limit(5_000_000).toArray();
+
+    final LinkedHashMap<CompareType, Comparator<ByteBuf>> comparators = new LinkedHashMap<>();
+    comparators.put(CompareType.INTEGER_KEY, ByteBufProxy::compareAsIntegerKeys);
+    comparators.put(CompareType.LEXICOGRAPHIC, ByteBufProxy::compareLexicographically);
+
+    final LinkedHashMap<CompareType, ComparatorResult> results =
+        new LinkedHashMap<>(comparators.size());
+    final Set<ComparatorResult> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      resetBuffer(buffer1native);
+      resetBuffer(buffer2native);
+      resetBuffer(buffer1be);
+      resetBuffer(buffer2be);
+
+      final long val1 = values[i - 1];
+      final long val2 = values[i];
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        buffer1native.writeLongLE(val1);
+        buffer2native.writeLongLE(val2);
+      } else {
+        buffer1native.writeLong(val1);
+        buffer2native.writeLong(val2);
+      }
+      buffer1be.writeLong(val1);
+      buffer2be.writeLong(val2);
+
+      Assertions.assertThat(buffer1native.readableBytes()).isEqualTo(Long.BYTES);
+      Assertions.assertThat(buffer2native.readableBytes()).isEqualTo(Long.BYTES);
+      Assertions.assertThat(buffer1be.readableBytes()).isEqualTo(Long.BYTES);
+      Assertions.assertThat(buffer2be.readableBytes()).isEqualTo(Long.BYTES);
+
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach(
+          (compareType, comparator) -> {
+            final ComparatorResult result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (compareType == CompareType.INTEGER_KEY) {
+              result = TestUtils.compare(comparator, buffer1native, buffer2native);
+            } else {
+              result = TestUtils.compare(comparator, buffer1be, buffer2be);
+            }
+            results.put(compareType, result);
+            uniqueResults.add(result);
+          });
+
+      if (uniqueResults.size() != 1) {
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+
+  private static void resetBuffer(ByteBuf buffer1native) {
+    buffer1native.resetReaderIndex();
+    buffer1native.resetWriterIndex();
+  }
+}
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index b72393dc..2e4ed823 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -191,7 +191,66 @@ public void comparatorPerformance() {
   }
 
   @Test
-  public void verifyComparators() {
+  public void verifyComparators_int() {
+    final Random random = new Random(203948);
+    final ByteBuffer buffer1native =
+        ByteBuffer.allocateDirect(Integer.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer2native =
+        ByteBuffer.allocateDirect(Integer.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer1be = ByteBuffer.allocateDirect(Integer.BYTES).order(BIG_ENDIAN);
+    final ByteBuffer buffer2be = ByteBuffer.allocateDirect(Integer.BYTES).order(BIG_ENDIAN);
+    buffer1native.limit(Integer.BYTES);
+    buffer2native.limit(Integer.BYTES);
+    buffer1be.limit(Integer.BYTES);
+    buffer2be.limit(Integer.BYTES);
+    final int[] values = random.ints().filter(i -> i >= 0).limit(5_000_000).toArray();
+    //    System.out.println("stats: " + Arrays.stream(values)
+    //        .summaryStatistics()
+    //        .toString());
+
+    final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
+    comparators.put(
+        "compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
+    comparators.put(
+        "compareLexicographically",
+        ByteBufferProxy.AbstractByteBufferProxy::compareLexicographically);
+
+    final LinkedHashMap<String, Integer> results = new LinkedHashMap<>(comparators.size());
+    final Set<Integer> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      final int val1 = values[i - 1];
+      final int val2 = values[i];
+      buffer1native.putInt(0, val1);
+      buffer2native.putInt(0, val2);
+      buffer1be.putInt(0, val1);
+      buffer2be.putInt(0, val2);
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach(
+          (name, comparator) -> {
+            final int result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (name.equals("compareAsIntegerKeys")) {
+              result = comparator.compare(buffer1native, buffer2native);
+            } else {
+              result = comparator.compare(buffer1be, buffer2be);
+            }
+            results.put(name, result);
+            uniqueResults.add(result);
+          });
+
+      if (uniqueResults.size() != 1) {
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+
+  @Test
+  public void verifyComparators_long() {
     final Random random = new Random(203948);
     final ByteBuffer buffer1native =
         ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
index dbe00fa0..66aaaede 100644
--- a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -20,10 +20,9 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
+import static org.lmdbjava.ComparatorResult.EQUAL_TO;
+import static org.lmdbjava.ComparatorResult.GREATER_THAN;
+import static org.lmdbjava.ComparatorResult.LESS_THAN;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 
 import io.netty.buffer.ByteBuf;
@@ -57,40 +56,50 @@ private static byte[] buffer(final int... bytes) {
     return array;
   }
 
+  private ComparatorResult compare(
+      final ComparatorRunner comparatorRunner, final long o1, final long o2) {
+    return ComparatorResult.get(comparatorRunner.compare(o1, o2));
+  }
+
+  private ComparatorResult compare(
+      final ComparatorRunner comparatorRunner, final int o1, final int o2) {
+    return ComparatorResult.get(comparatorRunner.compare(o1, o2));
+  }
+
   @ParameterizedTest
   @MethodSource("comparatorProvider")
   void testLong(final ComparatorRunner comparator) {
 
-    assertThat(get(comparator.compare(0L, 0L))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(Long.MAX_VALUE, Long.MAX_VALUE))).isEqualTo(EQUAL_TO);
+    assertThat(compare(comparator, 0L, 0L)).isEqualTo(EQUAL_TO);
+    assertThat(compare(comparator, Long.MAX_VALUE, Long.MAX_VALUE)).isEqualTo(EQUAL_TO);
 
-    assertThat(get(comparator.compare(0L, 1L))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(0L, Long.MAX_VALUE))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(0L, 10L))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(10L, 100L))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(10L, 100L))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(10L, 1000L))).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 0L, 1L)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 0L, Long.MAX_VALUE)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 0L, 10L)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 10L, 100L)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 10L, 100L)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 10L, 1000L)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(1L, 0L))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(Long.MAX_VALUE, 0L))).isEqualTo(GREATER_THAN);
+    assertThat(compare(comparator, 1L, 0L)).isEqualTo(GREATER_THAN);
+    assertThat(compare(comparator, Long.MAX_VALUE, 0L)).isEqualTo(GREATER_THAN);
   }
 
   @ParameterizedTest
   @MethodSource("comparatorProvider")
   void testInt(final ComparatorRunner comparator) {
 
-    assertThat(get(comparator.compare(0, 0))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(Integer.MAX_VALUE, Integer.MAX_VALUE))).isEqualTo(EQUAL_TO);
+    assertThat(compare(comparator, 0, 0)).isEqualTo(EQUAL_TO);
+    assertThat(compare(comparator, Integer.MAX_VALUE, Integer.MAX_VALUE)).isEqualTo(EQUAL_TO);
 
-    assertThat(get(comparator.compare(0, 1))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(0, Integer.MAX_VALUE))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(0, 10))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(10, 100))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(10, 100))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(10, 1000))).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 0, 1)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 0, Integer.MAX_VALUE)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 0, 10)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 10, 100)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 10, 100)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 10, 1000)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(1, 0))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(Integer.MAX_VALUE, 0))).isEqualTo(GREATER_THAN);
+    assertThat(compare(comparator, 1, 0)).isEqualTo(GREATER_THAN);
+    assertThat(compare(comparator, Integer.MAX_VALUE, 0)).isEqualTo(GREATER_THAN);
   }
 
   @ParameterizedTest
@@ -105,8 +114,8 @@ void testRandomLong(final ComparatorRunner runner) {
       final long long1 = values[i - 1];
       final long long2 = values[i];
       // Make sure the comparator under test gives the same outcome as just comparing two longs
-      final ComparatorTest.ComparatorResult result = get(runner.compare(long1, long2));
-      final ComparatorTest.ComparatorResult expectedResult = get(Long.compare(long1, long2));
+      final ComparatorResult result = ComparatorResult.get(runner.compare(long1, long2));
+      final ComparatorResult expectedResult = ComparatorResult.get(Long.compare(long1, long2));
 
       assertThat(result)
           .withFailMessage(
@@ -121,8 +130,8 @@ void testRandomLong(final ComparatorRunner runner) {
                       + result)
           .isEqualTo(expectedResult);
 
-      final ComparatorTest.ComparatorResult result2 = get(runner.compare(long2, long1));
-      final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+      final ComparatorResult result2 = ComparatorResult.get(runner.compare(long2, long1));
+      final ComparatorResult expectedResult2 = expectedResult.opposite();
 
       assertThat(result)
           .withFailMessage(
@@ -151,8 +160,8 @@ void testRandomInt(final ComparatorRunner runner) {
       final int int1 = values[i - 1];
       final int int2 = values[i];
       // Make sure the comparator under test gives the same outcome as just comparing two ints
-      final ComparatorTest.ComparatorResult result = get(runner.compare(int1, int2));
-      final ComparatorTest.ComparatorResult expectedResult = get(Integer.compare(int1, int2));
+      final ComparatorResult result = ComparatorResult.get(runner.compare(int1, int2));
+      final ComparatorResult expectedResult = ComparatorResult.get(Integer.compare(int1, int2));
 
       assertThat(result)
           .withFailMessage(
@@ -167,8 +176,8 @@ void testRandomInt(final ComparatorRunner runner) {
                       + result)
           .isEqualTo(expectedResult);
 
-      final ComparatorTest.ComparatorResult result2 = get(runner.compare(int2, int1));
-      final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+      final ComparatorResult result2 = ComparatorResult.get(runner.compare(int2, int1));
+      final ComparatorResult expectedResult2 = expectedResult.opposite();
 
       assertThat(result)
           .withFailMessage(
diff --git a/src/test/java/org/lmdbjava/ComparatorResult.java b/src/test/java/org/lmdbjava/ComparatorResult.java
new file mode 100644
index 00000000..ac7feb12
--- /dev/null
+++ b/src/test/java/org/lmdbjava/ComparatorResult.java
@@ -0,0 +1,25 @@
+package org.lmdbjava;
+
+/** Converts an integer result code into its contractual meaning. */
+enum ComparatorResult {
+  LESS_THAN,
+  EQUAL_TO,
+  GREATER_THAN;
+
+  static ComparatorResult get(final int comparatorResult) {
+    if (comparatorResult == 0) {
+      return EQUAL_TO;
+    }
+    return comparatorResult < 0 ? LESS_THAN : GREATER_THAN;
+  }
+
+  ComparatorResult opposite() {
+    if (this == LESS_THAN) {
+      return GREATER_THAN;
+    } else if (this == GREATER_THAN) {
+      return LESS_THAN;
+    } else {
+      return EQUAL_TO;
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index f255ec2a..fbde37c3 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -22,10 +22,9 @@
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
+import static org.lmdbjava.ComparatorResult.EQUAL_TO;
+import static org.lmdbjava.ComparatorResult.GREATER_THAN;
+import static org.lmdbjava.ComparatorResult.LESS_THAN;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 
 import com.google.common.primitives.SignedBytes;
@@ -87,52 +86,52 @@ private static byte[] buffer(final int... bytes) {
   @ParameterizedTest
   @ArgumentsSource(MyArgumentProvider.class)
   void atLeastOneBufferHasEightBytes(final ComparatorRunner comparator) {
-    assertThat(get(comparator.compare(HLLLLLLL, LLLLLLLL))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LLLLLLLL, HLLLLLLL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, HLLLLLLL, LLLLLLLL)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LLLLLLLL, HLLLLLLL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(LHLLLLLL, LLLLLLLL))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LLLLLLLL, LHLLLLLL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, LHLLLLLL, LLLLLLLL)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LLLLLLLL, LHLLLLLL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(LLLLLLLL, LLLLLLLX))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, LLLLLLLL, LLLLLLLX)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LLLLLLLX, LLLLLLLL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(HLLLLLLL, HLLLLLLX))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(HLLLLLLX, HLLLLLLL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, HLLLLLLL, HLLLLLLX)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, HLLLLLLX, HLLLLLLL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(HLLLLLLX, LHLLLLLL))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LHLLLLLL, HLLLLLLX))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, HLLLLLLX, LHLLLLLL)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LHLLLLLL, HLLLLLLX)).isEqualTo(LESS_THAN);
   }
 
   @ParameterizedTest
   @ArgumentsSource(MyArgumentProvider.class)
   void buffersOfTwoBytes(final ComparatorRunner comparator) {
-    assertThat(get(comparator.compare(LL, XX))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(XX, LL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, LL, XX)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, XX, LL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(LL, LX))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LX, LL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, LL, LX)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LX, LL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(LH, LX))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LX, HL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, LH, LX)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LX, HL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(HX, LL))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LH, HX))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, HX, LL)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LH, HX)).isEqualTo(LESS_THAN);
   }
 
   @ParameterizedTest
   @ArgumentsSource(MyArgumentProvider.class)
   void equalBuffers(final ComparatorRunner comparator) {
-    assertThat(get(comparator.compare(LL, LL))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(HX, HX))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(LH, LH))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(LL, LL))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(LX, LX))).isEqualTo(EQUAL_TO);
-
-    assertThat(get(comparator.compare(HLLLLLLL, HLLLLLLL))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(HLLLLLLX, HLLLLLLX))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(LHLLLLLL, LHLLLLLL))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(LLLLLLLL, LLLLLLLL))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLX))).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LL, LL)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, HX, HX)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LH, LH)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LL, LL)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LX, LX)).isEqualTo(EQUAL_TO);
+
+    assertThat(TestUtils.compare(comparator, HLLLLLLL, HLLLLLLL)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, HLLLLLLX, HLLLLLLX)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LHLLLLLL, LHLLLLLL)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LLLLLLLL, LLLLLLLL)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LLLLLLLX, LLLLLLLX)).isEqualTo(EQUAL_TO);
   }
 
   /** Tests {@link ByteArrayProxy}. */
@@ -257,32 +256,32 @@ public int compare(final byte[] o1, final byte[] o2) {
     }
   }
 
-  /** Converts an integer result code into its contractual meaning. */
-  enum ComparatorResult {
-    LESS_THAN,
-    EQUAL_TO,
-    GREATER_THAN;
-
-    static ComparatorResult get(final int comparatorResult) {
-      if (comparatorResult == 0) {
-        return EQUAL_TO;
-      }
-      return comparatorResult < 0 ? LESS_THAN : GREATER_THAN;
-    }
-
-    ComparatorResult opposite() {
-      if (this == LESS_THAN) {
-        return GREATER_THAN;
-      } else if (this == GREATER_THAN) {
-        return LESS_THAN;
-      } else {
-        return EQUAL_TO;
-      }
-    }
-  }
+  //  /** Converts an integer result code into its contractual meaning. */
+  //  enum ComparatorResult {
+  //    LESS_THAN,
+  //    EQUAL_TO,
+  //    GREATER_THAN;
+  //
+  //    static ComparatorResult get(final int comparatorResult) {
+  //      if (comparatorResult == 0) {
+  //        return EQUAL_TO;
+  //      }
+  //      return comparatorResult < 0 ? LESS_THAN : GREATER_THAN;
+  //    }
+  //
+  //    ComparatorResult opposite() {
+  //      if (this == LESS_THAN) {
+  //        return GREATER_THAN;
+  //      } else if (this == GREATER_THAN) {
+  //        return LESS_THAN;
+  //      } else {
+  //        return EQUAL_TO;
+  //      }
+  //    }
+  //  }
 
   /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
-  private interface ComparatorRunner {
+  private interface ComparatorRunner extends Comparator<byte[]> {
 
     /**
      * Convert the passed byte arrays into the proxy's relevant buffer type and then invoke the
diff --git a/src/test/java/org/lmdbjava/CompareType.java b/src/test/java/org/lmdbjava/CompareType.java
new file mode 100644
index 00000000..22023815
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CompareType.java
@@ -0,0 +1,8 @@
+package org.lmdbjava;
+
+enum CompareType {
+  /** int and long keys */
+  INTEGER_KEY,
+  LEXICOGRAPHIC,
+  ;
+}
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 1dd04d50..a15dc6b2 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -24,6 +24,7 @@
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.charset.StandardCharsets;
+import java.util.Comparator;
 import java.util.Objects;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -195,4 +196,10 @@ static <T, R> R getWithWriteTxn(final Env<T> env, final Function<Txn<T>, R> work
       return work.apply(readTxn);
     }
   }
+
+  static <T> ComparatorResult compare(final Comparator<T> comparator, final T o1, final T o2) {
+    Objects.requireNonNull(comparator);
+    final int result = comparator.compare(o1, o2);
+    return ComparatorResult.get(result);
+  }
 }

From 53ac34d8ca049a8730d552868afc2982fc5a765e Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 17:45:26 +0000
Subject: [PATCH 70/90] Add missing licences

---
 src/test/java/org/lmdbjava/ByteBufProxyTest.java | 15 +++++++++++++++
 src/test/java/org/lmdbjava/ComparatorResult.java | 15 +++++++++++++++
 src/test/java/org/lmdbjava/CompareType.java      | 15 +++++++++++++++
 3 files changed, 45 insertions(+)

diff --git a/src/test/java/org/lmdbjava/ByteBufProxyTest.java b/src/test/java/org/lmdbjava/ByteBufProxyTest.java
index 245c7b4d..92a6b493 100644
--- a/src/test/java/org/lmdbjava/ByteBufProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufProxyTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import io.netty.buffer.ByteBuf;
diff --git a/src/test/java/org/lmdbjava/ComparatorResult.java b/src/test/java/org/lmdbjava/ComparatorResult.java
index ac7feb12..56140752 100644
--- a/src/test/java/org/lmdbjava/ComparatorResult.java
+++ b/src/test/java/org/lmdbjava/ComparatorResult.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 /** Converts an integer result code into its contractual meaning. */
diff --git a/src/test/java/org/lmdbjava/CompareType.java b/src/test/java/org/lmdbjava/CompareType.java
index 22023815..bd40bbf4 100644
--- a/src/test/java/org/lmdbjava/CompareType.java
+++ b/src/test/java/org/lmdbjava/CompareType.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 enum CompareType {

From 5ad4f0c7ee1daa7ce704970a9a95087b08a1801f Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 17:58:25 +0000
Subject: [PATCH 71/90] Add test assert

---
 src/test/java/org/lmdbjava/AbstractFlagSetTest.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index 54f168cc..a886d9e1 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -97,6 +97,7 @@ void testSingleFlagSet() {
       assertThat(flag.size()).isEqualTo(1);
 
       assertThat(flag.getFlags()).containsExactlyElementsOf(getFlagSet(flag).getFlags());
+      assertThat(flag.getFlags()).hasSize(1);
       assertThat(flag.getMask()).isEqualTo(getFlagSet(flag).getMask());
     }
   }

From a0503d3dc2eadf9ee603b19c43d1d061875d03d8 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 12:53:14 +0000
Subject: [PATCH 72/90] Add TxnDeprecatedTest for more coverage

---
 .../java/org/lmdbjava/TxnDeprecatedTest.java  | 119 ++++++++++++++++++
 src/test/java/org/lmdbjava/TxnTest.java       |  18 +++
 2 files changed, 137 insertions(+)
 create mode 100644 src/test/java/org/lmdbjava/TxnDeprecatedTest.java

diff --git a/src/test/java/org/lmdbjava/TxnDeprecatedTest.java b/src/test/java/org/lmdbjava/TxnDeprecatedTest.java
new file mode 100644
index 00000000..c497ff84
--- /dev/null
+++ b/src/test/java/org/lmdbjava/TxnDeprecatedTest.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.lmdbjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
+
+import java.nio.ByteBuffer;
+import java.nio.file.Path;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lmdbjava.Env.AlreadyClosedException;
+import org.lmdbjava.Txn.IncompatibleParent;
+
+/**
+ * Tests all the deprecated txn related methods in {@link Env}. Essentially a duplicate of {@link TxnTest}. When
+ * all the deprecated methods are deleted we can delete this test class.
+ *
+ * @deprecated Tests all the deprecated txn related methods in {@link Env}.
+ */
+@Deprecated
+public final class TxnDeprecatedTest {
+
+  private Path file;
+  private Env<ByteBuffer> env;
+
+  private TempDir tempDir;
+
+  @BeforeEach
+  void beforeEach() {
+    tempDir = new TempDir();
+    file = tempDir.createTempFile();
+    env =
+        create()
+            .setMapSize(256, ByteUnit.KIBIBYTES)
+            .setMaxReaders(1)
+            .setMaxDbs(2)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
+  }
+
+  @AfterEach
+  void afterEach() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  @Test
+  public void txParent() {
+    try (Txn<ByteBuffer> txRoot = env.txnWrite();
+        Txn<ByteBuffer> txChild = env.txn(txRoot, new TxnFlags[0])) {
+      assertThat(txRoot.getParent()).isNull();
+      assertThat(txChild.getParent()).isEqualTo(txRoot);
+    }
+  }
+
+  @Test
+  public void txParent2() {
+    try (Txn<ByteBuffer> txRoot = env.txnWrite();
+         Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlags[]) null)) {
+      assertThat(txRoot.getParent()).isNull();
+      assertThat(txChild.getParent()).isEqualTo(txRoot);
+    }
+  }
+
+  @Test
+  void txParentDeniedIfEnvClosed() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txRoot = env.txnWrite();
+                  Txn<ByteBuffer> txChild = env.txn(txRoot, new TxnFlags[0])) {
+                env.close();
+                assertThat(txChild.getParent()).isEqualTo(txRoot);
+              }
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void txParentROChildRWIncompatible() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txRoot = env.txnRead()) {
+                env.txn(txRoot, new TxnFlags[0]); // error
+              }
+            })
+        .isInstanceOf(IncompatibleParent.class);
+  }
+
+  @Test
+  void txParentRWChildROIncompatible() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txRoot = env.txnWrite()) {
+                TxnFlags[] flags = new TxnFlags[]{MDB_RDONLY_TXN};
+                env.txn(txRoot, flags); // error
+              }
+            })
+        .isInstanceOf(IncompatibleParent.class);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 790d81de..5936d4de 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -321,6 +321,24 @@ public void txParent() {
     }
   }
 
+  @Test
+  public void txParent2() {
+    try (Txn<ByteBuffer> txRoot = env.txnWrite();
+         Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlagSet) null)) {
+      assertThat(txRoot.getParent()).isNull();
+      assertThat(txChild.getParent()).isEqualTo(txRoot);
+    }
+  }
+
+  @Test
+  public void txParent3() {
+    try (Txn<ByteBuffer> txRoot = env.txnWrite();
+         Txn<ByteBuffer> txChild = env.txn(txRoot, TxnFlagSet.EMPTY)) {
+      assertThat(txRoot.getParent()).isNull();
+      assertThat(txChild.getParent()).isEqualTo(txRoot);
+    }
+  }
+
   @Test
   void txParentDeniedIfEnvClosed() {
     assertThatThrownBy(

From 29d5ba2cc1ef9acfa1d8e806cbfbd9926ec15393 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 12:53:40 +0000
Subject: [PATCH 73/90] Auto format

---
 src/test/java/org/lmdbjava/TxnDeprecatedTest.java | 8 ++++----
 src/test/java/org/lmdbjava/TxnTest.java           | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/test/java/org/lmdbjava/TxnDeprecatedTest.java b/src/test/java/org/lmdbjava/TxnDeprecatedTest.java
index c497ff84..387e9fef 100644
--- a/src/test/java/org/lmdbjava/TxnDeprecatedTest.java
+++ b/src/test/java/org/lmdbjava/TxnDeprecatedTest.java
@@ -31,8 +31,8 @@
 import org.lmdbjava.Txn.IncompatibleParent;
 
 /**
- * Tests all the deprecated txn related methods in {@link Env}. Essentially a duplicate of {@link TxnTest}. When
- * all the deprecated methods are deleted we can delete this test class.
+ * Tests all the deprecated txn related methods in {@link Env}. Essentially a duplicate of {@link
+ * TxnTest}. When all the deprecated methods are deleted we can delete this test class.
  *
  * @deprecated Tests all the deprecated txn related methods in {@link Env}.
  */
@@ -75,7 +75,7 @@ public void txParent() {
   @Test
   public void txParent2() {
     try (Txn<ByteBuffer> txRoot = env.txnWrite();
-         Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlags[]) null)) {
+        Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlags[]) null)) {
       assertThat(txRoot.getParent()).isNull();
       assertThat(txChild.getParent()).isEqualTo(txRoot);
     }
@@ -110,7 +110,7 @@ void txParentRWChildROIncompatible() {
     assertThatThrownBy(
             () -> {
               try (Txn<ByteBuffer> txRoot = env.txnWrite()) {
-                TxnFlags[] flags = new TxnFlags[]{MDB_RDONLY_TXN};
+                TxnFlags[] flags = new TxnFlags[] {MDB_RDONLY_TXN};
                 env.txn(txRoot, flags); // error
               }
             })
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 5936d4de..7dd9ca71 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -324,7 +324,7 @@ public void txParent() {
   @Test
   public void txParent2() {
     try (Txn<ByteBuffer> txRoot = env.txnWrite();
-         Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlagSet) null)) {
+        Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlagSet) null)) {
       assertThat(txRoot.getParent()).isNull();
       assertThat(txChild.getParent()).isEqualTo(txRoot);
     }
@@ -333,7 +333,7 @@ public void txParent2() {
   @Test
   public void txParent3() {
     try (Txn<ByteBuffer> txRoot = env.txnWrite();
-         Txn<ByteBuffer> txChild = env.txn(txRoot, TxnFlagSet.EMPTY)) {
+        Txn<ByteBuffer> txChild = env.txn(txRoot, TxnFlagSet.EMPTY)) {
       assertThat(txRoot.getParent()).isNull();
       assertThat(txChild.getParent()).isEqualTo(txRoot);
     }

From 1312e102ec343a776e8329531cc40f4723a31e21 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 13:03:52 +0000
Subject: [PATCH 74/90] Add tests for XxxFlags.isSet

---
 .../java/org/lmdbjava/CopyFlagSetTest.java    | 15 +++++++++++++++
 .../java/org/lmdbjava/DbiFlagSetTest.java     | 17 +++++++++++++++++
 .../java/org/lmdbjava/EnvFlagSetTest.java     | 17 +++++++++++++++++
 .../java/org/lmdbjava/PutFlagSetTest.java     | 17 +++++++++++++++++
 .../java/org/lmdbjava/TxnFlagSetTest.java     | 19 +++++++++++++++++--
 5 files changed, 83 insertions(+), 2 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 90ced57a..2bbf08e2 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -15,6 +15,8 @@
  */
 package org.lmdbjava;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
@@ -72,4 +74,17 @@ Class<CopyFlags> getFlagType() {
   Function<EnumSet<CopyFlags>, CopyFlagSet> getConstructor() {
     return CopyFlagSetImpl::new;
   }
+
+  /**
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
+   * doesn't seem to notice it.
+   */
+  @Test
+  void testIsSet() {
+    assertThat(CopyFlags.MDB_CP_COMPACT.isSet(CopyFlags.MDB_CP_COMPACT))
+        .isTrue();
+    //noinspection ConstantValue
+    assertThat(CopyFlags.MDB_CP_COMPACT.isSet(null))
+        .isFalse();
+  }
 }
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index f9f591a5..c727f21c 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -15,6 +15,8 @@
  */
 package org.lmdbjava;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
@@ -72,4 +74,19 @@ DbiFlagSet getFlagSet(DbiFlags flag) {
   Function<EnumSet<DbiFlags>, DbiFlagSet> getConstructor() {
     return DbiFlagSetImpl::new;
   }
+
+  /**
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
+   * doesn't seem to notice it.
+   */
+  @Test
+  void testIsSet() {
+    assertThat(DbiFlags.MDB_CREATE.isSet(DbiFlags.MDB_CREATE))
+        .isTrue();
+    assertThat(DbiFlags.MDB_CREATE.isSet(DbiFlags.MDB_REVERSEKEY))
+        .isFalse();
+    //noinspection ConstantValue
+    assertThat(DbiFlags.MDB_CREATE.isSet(null))
+        .isFalse();
+  }
 }
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index 1124a91d..e1835818 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -15,6 +15,8 @@
  */
 package org.lmdbjava;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
@@ -72,4 +74,19 @@ Class<EnvFlags> getFlagType() {
   Function<EnumSet<EnvFlags>, EnvFlagSet> getConstructor() {
     return EnvFlagSetImpl::new;
   }
+
+  /**
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
+   * doesn't seem to notice it.
+   */
+  @Test
+  void testIsSet() {
+    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(EnvFlags.MDB_RDONLY_ENV))
+        .isTrue();
+    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(EnvFlags.MDB_WRITEMAP))
+        .isFalse();
+    //noinspection ConstantValue
+    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(null))
+        .isFalse();
+  }
 }
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 9fe858f0..0213cde2 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -15,6 +15,8 @@
  */
 package org.lmdbjava;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import java.time.Duration;
 import java.time.Instant;
 import java.util.Arrays;
@@ -76,6 +78,21 @@ Function<EnumSet<PutFlags>, PutFlagSet> getConstructor() {
     return PutFlagSetImpl::new;
   }
 
+  /**
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
+   * doesn't seem to notice it.
+   */
+  @Test
+  void testIsSet() {
+    assertThat(PutFlags.MDB_APPEND.isSet(PutFlags.MDB_APPEND))
+        .isTrue();
+    assertThat(PutFlags.MDB_APPEND.isSet(PutFlags.MDB_MULTIPLE))
+        .isFalse();
+    //noinspection ConstantValue
+    assertThat(PutFlags.MDB_APPEND.isSet(null))
+        .isFalse();
+  }
+
   @Test
   public void testAddFlagVsCheckPresence() {
 
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 5390ed66..7be45289 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -15,13 +15,15 @@
  */
 package org.lmdbjava;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
+
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
 import java.util.List;
 import java.util.function.Function;
 import java.util.stream.Collectors;
-import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
@@ -30,7 +32,7 @@ class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
   void test() {
     // This is here purely to stop CodeQL moaning that this class is unused.
     // All the actual tests are in the superclass
-    Assertions.assertThat(getAllFlags()).isNotNull();
+    assertThat(getAllFlags()).isNotNull();
   }
 
   @Override
@@ -72,4 +74,17 @@ Class<TxnFlags> getFlagType() {
   Function<EnumSet<TxnFlags>, TxnFlagSet> getConstructor() {
     return TxnFlagSetImpl::new;
   }
+
+  /**
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
+   * doesn't seem to notice it.
+   */
+  @Test
+  void testIsSet() {
+    assertThat(MDB_RDONLY_TXN.isSet(MDB_RDONLY_TXN))
+        .isTrue();
+    //noinspection ConstantValue
+    assertThat(MDB_RDONLY_TXN.isSet(null))
+        .isFalse();
+  }
 }

From 0216c92fe95b221e86bc8f885dd3211613cafc03 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 13:10:34 +0000
Subject: [PATCH 75/90] Add more test coverage

---
 .../java/org/lmdbjava/CopyFlagSetTest.java    | 10 ++--
 .../org/lmdbjava/CursorDeprecatedTest.java    | 44 +++++++++++++++--
 src/test/java/org/lmdbjava/CursorTest.java    | 48 +++++++++++++++++++
 .../java/org/lmdbjava/DbiFlagSetTest.java     | 13 ++---
 .../java/org/lmdbjava/EnvFlagSetTest.java     | 13 ++---
 .../java/org/lmdbjava/PutFlagSetTest.java     | 13 ++---
 .../java/org/lmdbjava/TxnFlagSetTest.java     | 10 ++--
 7 files changed, 112 insertions(+), 39 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 2bbf08e2..7606682b 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -76,15 +76,13 @@ Function<EnumSet<CopyFlags>, CopyFlagSet> getConstructor() {
   }
 
   /**
-   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
-   * doesn't seem to notice it.
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but
+   * the coverage check doesn't seem to notice it.
    */
   @Test
   void testIsSet() {
-    assertThat(CopyFlags.MDB_CP_COMPACT.isSet(CopyFlags.MDB_CP_COMPACT))
-        .isTrue();
+    assertThat(CopyFlags.MDB_CP_COMPACT.isSet(CopyFlags.MDB_CP_COMPACT)).isTrue();
     //noinspection ConstantValue
-    assertThat(CopyFlags.MDB_CP_COMPACT.isSet(null))
-        .isFalse();
+    assertThat(CopyFlags.MDB_CP_COMPACT.isSet(null)).isFalse();
   }
 }
diff --git a/src/test/java/org/lmdbjava/CursorDeprecatedTest.java b/src/test/java/org/lmdbjava/CursorDeprecatedTest.java
index cff118fa..a4528577 100644
--- a/src/test/java/org/lmdbjava/CursorDeprecatedTest.java
+++ b/src/test/java/org/lmdbjava/CursorDeprecatedTest.java
@@ -138,7 +138,7 @@ void cursorFirstLastNextPrev() {
   }
 
   @Test
-  void delete() {
+  void delete1() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
@@ -147,11 +147,49 @@ void delete() {
       assertThat(c.seek(MDB_FIRST)).isTrue();
       assertThat(c.key().getInt()).isEqualTo(1);
       assertThat(c.val().getInt()).isEqualTo(2);
-      c.delete();
+      c.delete(new PutFlags[0]);
       assertThat(c.seek(MDB_FIRST)).isTrue();
       assertThat(c.key().getInt()).isEqualTo(3);
       assertThat(c.val().getInt()).isEqualTo(4);
-      c.delete();
+      c.delete(new PutFlags[0]);
+      assertThat(c.seek(MDB_FIRST)).isFalse();
+    }
+  }
+
+  @Test
+  void delete2() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), MDB_NOOVERWRITE);
+      c.put(bb(3), bb(4), new PutFlags[0]);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(1);
+      assertThat(c.val().getInt()).isEqualTo(2);
+      c.delete((PutFlags[]) null);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(3);
+      assertThat(c.val().getInt()).isEqualTo(4);
+      c.delete((PutFlags[]) null);
+      assertThat(c.seek(MDB_FIRST)).isFalse();
+    }
+  }
+
+  @Test
+  void delete3() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), MDB_NOOVERWRITE);
+      c.put(bb(3), bb(4), new PutFlags[0]);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(1);
+      assertThat(c.val().getInt()).isEqualTo(2);
+      c.delete((PutFlags) null);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(3);
+      assertThat(c.val().getInt()).isEqualTo(4);
+      c.delete((PutFlags) null);
       assertThat(c.seek(MDB_FIRST)).isFalse();
     }
   }
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 97f9d706..81f5ca2b 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -276,6 +276,54 @@ void delete() {
     }
   }
 
+  @Test
+  void delete2() {
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), MDB_NOOVERWRITE);
+      c.put(bb(3), bb(4));
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(1);
+      assertThat(c.val().getInt()).isEqualTo(2);
+      c.delete(PutFlags.EMPTY);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(3);
+      assertThat(c.val().getInt()).isEqualTo(4);
+      c.delete(PutFlags.EMPTY);
+      assertThat(c.seek(MDB_FIRST)).isFalse();
+    }
+  }
+
+  @Test
+  void delete3() {
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), MDB_NOOVERWRITE);
+      c.put(bb(3), bb(4));
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(1);
+      assertThat(c.val().getInt()).isEqualTo(2);
+      c.delete((PutFlagSet) null);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(3);
+      assertThat(c.val().getInt()).isEqualTo(4);
+      c.delete((PutFlagSet) null);
+      assertThat(c.seek(MDB_FIRST)).isFalse();
+    }
+  }
+
   @Test
   void getKeyVal() {
     final Dbi<ByteBuffer> db =
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index c727f21c..460ca0f2 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -76,17 +76,14 @@ Function<EnumSet<DbiFlags>, DbiFlagSet> getConstructor() {
   }
 
   /**
-   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
-   * doesn't seem to notice it.
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but
+   * the coverage check doesn't seem to notice it.
    */
   @Test
   void testIsSet() {
-    assertThat(DbiFlags.MDB_CREATE.isSet(DbiFlags.MDB_CREATE))
-        .isTrue();
-    assertThat(DbiFlags.MDB_CREATE.isSet(DbiFlags.MDB_REVERSEKEY))
-        .isFalse();
+    assertThat(DbiFlags.MDB_CREATE.isSet(DbiFlags.MDB_CREATE)).isTrue();
+    assertThat(DbiFlags.MDB_CREATE.isSet(DbiFlags.MDB_REVERSEKEY)).isFalse();
     //noinspection ConstantValue
-    assertThat(DbiFlags.MDB_CREATE.isSet(null))
-        .isFalse();
+    assertThat(DbiFlags.MDB_CREATE.isSet(null)).isFalse();
   }
 }
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index e1835818..a06334af 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -76,17 +76,14 @@ Function<EnumSet<EnvFlags>, EnvFlagSet> getConstructor() {
   }
 
   /**
-   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
-   * doesn't seem to notice it.
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but
+   * the coverage check doesn't seem to notice it.
    */
   @Test
   void testIsSet() {
-    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(EnvFlags.MDB_RDONLY_ENV))
-        .isTrue();
-    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(EnvFlags.MDB_WRITEMAP))
-        .isFalse();
+    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(EnvFlags.MDB_RDONLY_ENV)).isTrue();
+    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(EnvFlags.MDB_WRITEMAP)).isFalse();
     //noinspection ConstantValue
-    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(null))
-        .isFalse();
+    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(null)).isFalse();
   }
 }
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 0213cde2..e6a86a96 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -79,18 +79,15 @@ Function<EnumSet<PutFlags>, PutFlagSet> getConstructor() {
   }
 
   /**
-   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
-   * doesn't seem to notice it.
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but
+   * the coverage check doesn't seem to notice it.
    */
   @Test
   void testIsSet() {
-    assertThat(PutFlags.MDB_APPEND.isSet(PutFlags.MDB_APPEND))
-        .isTrue();
-    assertThat(PutFlags.MDB_APPEND.isSet(PutFlags.MDB_MULTIPLE))
-        .isFalse();
+    assertThat(PutFlags.MDB_APPEND.isSet(PutFlags.MDB_APPEND)).isTrue();
+    assertThat(PutFlags.MDB_APPEND.isSet(PutFlags.MDB_MULTIPLE)).isFalse();
     //noinspection ConstantValue
-    assertThat(PutFlags.MDB_APPEND.isSet(null))
-        .isFalse();
+    assertThat(PutFlags.MDB_APPEND.isSet(null)).isFalse();
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 7be45289..37068202 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -76,15 +76,13 @@ Function<EnumSet<TxnFlags>, TxnFlagSet> getConstructor() {
   }
 
   /**
-   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
-   * doesn't seem to notice it.
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but
+   * the coverage check doesn't seem to notice it.
    */
   @Test
   void testIsSet() {
-    assertThat(MDB_RDONLY_TXN.isSet(MDB_RDONLY_TXN))
-        .isTrue();
+    assertThat(MDB_RDONLY_TXN.isSet(MDB_RDONLY_TXN)).isTrue();
     //noinspection ConstantValue
-    assertThat(MDB_RDONLY_TXN.isSet(null))
-        .isFalse();
+    assertThat(MDB_RDONLY_TXN.isSet(null)).isFalse();
   }
 }

From 8b60f29869827d74863a5034fa34b5d3a04c8c8c Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 15:13:25 +0000
Subject: [PATCH 76/90] Change FlagSet args to be requireNonNull

---
 src/main/java/org/lmdbjava/Cursor.java     | 24 +++---
 src/main/java/org/lmdbjava/Dbi.java        | 11 +--
 src/main/java/org/lmdbjava/Env.java        |  1 +
 src/main/java/org/lmdbjava/Txn.java        | 10 ++-
 src/test/java/org/lmdbjava/CursorTest.java | 89 ++++++++++++++++++----
 src/test/java/org/lmdbjava/TxnTest.java    | 10 ++-
 6 files changed, 105 insertions(+), 40 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 09c461e2..0e320930 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -294,6 +294,7 @@ public boolean put(final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       requireNonNull(val);
+      requireNonNull(flags);
       env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
@@ -301,13 +302,11 @@ public boolean put(final T key, final T val, final PutFlagSet flags) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(val);
-    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
-    final int rc =
-        LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), putFlagSet.getMask());
+    final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flags.getMask());
     if (rc == MDB_KEYEXIST) {
-      if (putFlagSet.isSet(MDB_NOOVERWRITE)) {
+      if (flags.isSet(MDB_NOOVERWRITE)) {
         kv.valOut(); // marked as in,out in LMDB C docs
-      } else if (!putFlagSet.isSet(MDB_NODUPDATA)) {
+      } else if (!flags.isSet(MDB_NODUPDATA)) {
         checkRc(rc);
       }
       return false;
@@ -375,15 +374,14 @@ public void putMultiple(final T key, final T val, final int elements, final PutF
       env.checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
+      if (!flags.isSet(MDB_MULTIPLE)) {
+        throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
+      }
     }
-    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
-    if (SHOULD_CHECK && !putFlagSet.isSet(MDB_MULTIPLE)) {
-      throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
-    }
+
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer dataPtr = txn.kv().valInMulti(val, elements);
-    final int rc =
-        LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, putFlagSet.getMask());
+    final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, flags.getMask());
     checkRc(rc);
     ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(dataPtr);
@@ -466,6 +464,7 @@ public T reserve(final T key, final int size) {
   public T reserve(final T key, final int size, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
+      requireNonNull(flags);
       env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
@@ -473,9 +472,8 @@ public T reserve(final T key, final int size, final PutFlagSet flags) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(size);
-    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
     // This is inconsistent with putMultiple which require MDB_MULTIPLE to be in the set.
-    final int flagsMask = putFlagSet.getMaskWith(MDB_RESERVE);
+    final int flagsMask = flags.getMaskWith(MDB_RESERVE);
     checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flagsMask));
     kv.valOut();
     ReferenceUtil.reachabilityFence0(transientKey);
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index aff6fff8..e36cc2e1 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -83,13 +83,14 @@ public final class Dbi<T> {
         throw new IllegalArgumentException("Is nativeCb is true, you must supply a comparator");
       }
       requireNonNull(txn);
+      requireNonNull(dbiFlagSet);
       txn.checkReady();
     }
     this.env = env;
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
     this.proxy = proxy;
     this.comparator = comparator;
-    this.dbiFlagSet = dbiFlagSet == null ? DbiFlagSet.EMPTY : dbiFlagSet;
+    this.dbiFlagSet = dbiFlagSet;
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
     checkRc(LIB.mdb_dbi_open(txn.pointer(), name, this.dbiFlagSet.getMask(), dbiPtr));
     ptr = dbiPtr.getPointer(0);
@@ -457,20 +458,20 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet
       requireNonNull(txn);
       requireNonNull(key);
       requireNonNull(val);
+      requireNonNull(flags);
       env.checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final PutFlagSet flagSet = flags != null ? flags : PutFlagSet.empty();
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(val);
     final int rc =
         LIB.mdb_put(
-            txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flagSet.getMask());
+            txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flags.getMask());
     if (rc == MDB_KEYEXIST) {
-      if (flagSet.isSet(MDB_NOOVERWRITE)) {
+      if (flags.isSet(MDB_NOOVERWRITE)) {
         txn.kv().valOut(); // marked as in,out in LMDB C docs
-      } else if (!flagSet.isSet(MDB_NODUPDATA)) {
+      } else if (!flags.isSet(MDB_NODUPDATA)) {
         checkRc(rc);
       }
       return false;
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index af3a6596..0d4afe7e 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -201,6 +201,7 @@ public void copy(final Path path) {
    */
   public void copy(final Path path, final CopyFlagSet flags) {
     requireNonNull(path);
+    requireNonNull(flags);
     validatePath(path);
     checkRc(LIB.mdb_env_copy2(ptr, path.toAbsolutePath().toString(), flags.getMask()));
   }
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 432b47a8..7e9aacf9 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -27,6 +27,7 @@
 import static org.lmdbjava.Txn.State.RESET;
 import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
+import java.util.Objects;
 import jnr.ffi.Pointer;
 
 /**
@@ -42,14 +43,15 @@ public final class Txn<T> implements AutoCloseable {
   private final Pointer ptr;
   private final boolean readOnly;
   private final Env<T> env;
-  private final TxnFlagSet flags;
   private State state;
 
   Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlagSet flags) {
-    this.flags = flags != null ? flags : TxnFlagSet.EMPTY;
+    if (SHOULD_CHECK) {
+      Objects.requireNonNull(flags);
+    }
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
-    this.readOnly = this.flags.isSet(MDB_RDONLY_TXN);
+    this.readOnly = flags.isSet(MDB_RDONLY_TXN);
     if (env.isReadOnly() && !this.readOnly) {
       throw new EnvIsReadOnly();
     }
@@ -60,7 +62,7 @@ public final class Txn<T> implements AutoCloseable {
     }
     final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
     final Pointer txnParentPtr = parent == null ? null : parent.ptr;
-    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, this.flags.getMask(), txnPtr));
+    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, flags.getMask(), txnPtr));
     ptr = txnPtr.getPointer(0);
 
     state = READY;
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 81f5ca2b..deb75622 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -41,6 +41,7 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.function.Consumer;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -179,7 +180,7 @@ void closedEnvRejectsDeleteCall() {
   }
 
   @Test
-  void count() {
+  void countWithDupsort() {
     final Dbi<ByteBuffer> db =
         env.createDbi()
             .setDbName(DB_1)
@@ -199,6 +200,30 @@ void count() {
     }
   }
 
+  @Test
+  void countWithoutDupsort() {
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      assertThat(c.put(bb(1), bb(2), MDB_NOOVERWRITE)).isTrue();
+      assertThat(c.put(bb(1), bb(4))).isTrue();
+      assertThat(c.put(bb(1), bb(6), PutFlagSet.EMPTY)).isTrue();
+      assertThat(c.put(bb(1), bb(8), MDB_NOOVERWRITE)).isFalse();
+      assertThat(c.put(bb(2), bb(1), MDB_NOOVERWRITE)).isTrue();
+      assertThat(c.put(bb(2), bb(2))).isTrue();
+      Assertions.assertThatThrownBy(
+              () -> {
+                c.put(bb(2), bb(2), (PutFlagSet) null);
+              })
+          .isInstanceOf(NullPointerException.class);
+      assertThat(c.put(bb(2), bb(2))).isTrue();
+
+      final Stat stat = db.stat(txn);
+      assertThat(stat.entries).isEqualTo(2);
+    }
+  }
+
   @Test
   void cursorCannotCloseIfTransactionCommitted() {
     assertThatThrownBy(
@@ -377,20 +402,56 @@ void putMultiple() {
 
   @Test
   void putMultipleWithoutMdbMultipleFlag() {
-    assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db =
-                  env.createDbi()
-                      .setDbName(DB_1)
-                      .withDefaultComparator()
-                      .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
-                      .open();
-              try (Txn<ByteBuffer> txn = env.txnWrite();
-                  Cursor<ByteBuffer> c = db.openCursor(txn)) {
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      assertThatThrownBy(
+              () -> {
                 c.putMultiple(bb(100), bb(1), 1);
-              }
-            })
-        .isInstanceOf(IllegalArgumentException.class);
+              })
+          .isInstanceOf(IllegalArgumentException.class);
+    }
+  }
+
+  @Test
+  void putMultipleWithoutMdbMultipleFlag2() {
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      assertThatThrownBy(
+              () -> {
+                c.putMultiple(bb(100), bb(1), 1, PutFlags.EMPTY);
+              })
+          .isInstanceOf(IllegalArgumentException.class);
+    }
+  }
+
+  @Test
+  void putMultipleWithoutMdbMultipleFlag3() {
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      assertThatThrownBy(
+              () -> {
+                c.putMultiple(bb(100), bb(1), 1, (PutFlagSet) null);
+              })
+          .isInstanceOf(NullPointerException.class);
+    }
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 7dd9ca71..7210b613 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -323,10 +323,12 @@ public void txParent() {
 
   @Test
   public void txParent2() {
-    try (Txn<ByteBuffer> txRoot = env.txnWrite();
-        Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlagSet) null)) {
-      assertThat(txRoot.getParent()).isNull();
-      assertThat(txChild.getParent()).isEqualTo(txRoot);
+    try (Txn<ByteBuffer> txRoot = env.txnWrite()) {
+      assertThatThrownBy(
+              () -> {
+                env.txn(txRoot, (TxnFlagSet) null);
+              })
+          .isInstanceOf(NullPointerException.class);
     }
   }
 

From e53956d8bcf8f2fe8c3d071374c8871ab6c5bf5f Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 15:29:13 +0000
Subject: [PATCH 77/90] Add requireNonNull checks to Dbi

---
 src/main/java/org/lmdbjava/Dbi.java     |  3 ++
 src/test/java/org/lmdbjava/DbiTest.java | 72 +++++++++++++++++++++++++
 2 files changed, 75 insertions(+)

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index e36cc2e1..f5d76ba1 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -78,11 +78,14 @@ public final class Dbi<T> {
       final boolean nativeCb,
       final BufferProxy<T> proxy,
       final DbiFlagSet dbiFlagSet) {
+
     if (SHOULD_CHECK) {
       if (nativeCb && comparator == null) {
         throw new IllegalArgumentException("Is nativeCb is true, you must supply a comparator");
       }
+      requireNonNull(env);
       requireNonNull(txn);
+      requireNonNull(proxy);
       requireNonNull(dbiFlagSet);
       txn.checkReady();
     }
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 9f66e5bb..fa4cbc83 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -120,6 +120,78 @@ void close() {
         .isInstanceOf(ConstantDerivedException.class);
   }
 
+  @Test
+  void constructorArgsNullEnv() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                new Dbi<>(
+                    null,
+                    txn,
+                    "foo".getBytes(Env.DEFAULT_NAME_CHARSET),
+                    PROXY_OPTIMAL,
+                    DbiFlagSet.EMPTY);
+              }
+            })
+        .isInstanceOf(NullPointerException.class);
+  }
+
+  @Test
+  void constructorArgsNullTxn() {
+    assertThatThrownBy(
+            () -> {
+              new Dbi<>(
+                  env,
+                  null,
+                  "foo".getBytes(Env.DEFAULT_NAME_CHARSET),
+                  PROXY_OPTIMAL,
+                  DbiFlagSet.EMPTY);
+            })
+        .isInstanceOf(NullPointerException.class);
+  }
+
+  @Test
+  void constructorArgsNullProxy() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                new Dbi<>(
+                    env, txn, "foo".getBytes(Env.DEFAULT_NAME_CHARSET), null, DbiFlagSet.EMPTY);
+              }
+            })
+        .isInstanceOf(NullPointerException.class);
+  }
+
+  @Test
+  void constructorArgsNullFlags() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                new Dbi<>(env, txn, "foo".getBytes(Env.DEFAULT_NAME_CHARSET), PROXY_OPTIMAL, null);
+              }
+            })
+        .isInstanceOf(NullPointerException.class);
+  }
+
+  @Test
+  void constructorArgsNullNativeCallbackComparator() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                new Dbi<>(
+                    env,
+                    txn,
+                    "foo".getBytes(Env.DEFAULT_NAME_CHARSET),
+                    null,
+                    true,
+                    PROXY_OPTIMAL,
+                    DbiFlagSet.EMPTY);
+              }
+            })
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Is nativeCb is true, you must supply a comparator");
+  }
+
   @Test
   void customComparator() {
     final Comparator<ByteBuffer> reverseOrder =

From 654a5bcd622b81996c61116b4374492f25a5b3b2 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 16:36:30 +0000
Subject: [PATCH 78/90] Add more coverage

---
 src/main/java/org/lmdbjava/CopyFlags.java |  2 +-
 src/main/java/org/lmdbjava/Dbi.java       | 10 +++
 src/main/java/org/lmdbjava/DbiFlags.java  |  2 +-
 src/main/java/org/lmdbjava/Env.java       | 92 +++++++++++++++--------
 src/main/java/org/lmdbjava/EnvFlags.java  |  2 +-
 src/main/java/org/lmdbjava/PutFlags.java  |  2 +-
 src/main/java/org/lmdbjava/TxnFlags.java  |  2 +-
 src/test/java/org/lmdbjava/DbiTest.java   |  8 ++
 src/test/java/org/lmdbjava/EnvTest.java   | 92 ++++++++++++++++++++++-
 9 files changed, 173 insertions(+), 39 deletions(-)

diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index d2d7b0e2..e3677baf 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -43,7 +43,7 @@ public Set<CopyFlags> getFlags() {
 
   @Override
   public boolean isSet(final CopyFlags flag) {
-    return flag != null && mask == flag.getMask();
+    return this == flag;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index f5d76ba1..d2afdf8f 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -281,6 +281,16 @@ public byte[] getName() {
     return name == null ? null : Arrays.copyOf(name, name.length);
   }
 
+  /**
+   * Convert the passed name into bytes using the default {@link Charset}.
+   *
+   * @param name The name to convert.
+   * @return The name as a byte[] or null if name is null.
+   */
+  public static byte[] getNameBytes(final String name) {
+    return name == null ? null : name.getBytes(Env.DEFAULT_NAME_CHARSET);
+  }
+
   /**
    * Obtains the name of this database, using the {@link Env#DEFAULT_NAME_CHARSET} {@link Charset}.
    *
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index e1e66a31..9426db0f 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -101,7 +101,7 @@ public Set<DbiFlags> getFlags() {
 
   @Override
   public boolean isSet(final DbiFlags flag) {
-    return flag != null && mask == flag.getMask();
+    return this == flag;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 0d4afe7e..4bc6cca8 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -73,18 +73,24 @@ public final class Env<T> implements AutoCloseable {
   private final BufferProxy<T> proxy;
   private final Pointer ptr;
   private final boolean readOnly;
+  private final Path path;
+  private final EnvFlagSet envFlagSet;
 
   private Env(
       final BufferProxy<T> proxy,
       final Pointer ptr,
       final boolean readOnly,
-      final boolean noSubDir) {
+      final boolean noSubDir,
+      final Path path,
+      final EnvFlagSet envFlagSet) {
     this.proxy = proxy;
     this.readOnly = readOnly;
     this.noSubDir = noSubDir;
     this.ptr = ptr;
     // cache max key size to avoid further JNI calls
     this.maxKeySize = LIB.mdb_env_get_maxkeysize(ptr);
+    this.path = path;
+    this.envFlagSet = envFlagSet;
   }
 
   /**
@@ -353,7 +359,7 @@ public DbiBuilder<T> createDbi() {
    */
   @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
-    return createDbi().setDbName(name).withDefaultComparator().setDbiFlags(flags).open();
+    return openDbi(Dbi.getNameBytes(name), null, false, flags);
   }
 
   /**
@@ -374,13 +380,7 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   @Deprecated()
   public Dbi<T> openDbi(
       final String name, final Comparator<T> comparator, final DbiFlags... flags) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
-    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi =
-          new Dbi<>(this, txn, nameBytes, comparator, false, proxy, DbiFlagSet.of(flags));
-      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
-      return dbi;
-    }
+    return openDbi(Dbi.getNameBytes(name), comparator, false, flags);
   }
 
   /**
@@ -403,13 +403,7 @@ public Dbi<T> openDbi(
       final Comparator<T> comparator,
       final boolean nativeCb,
       final DbiFlags... flags) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
-    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi =
-          new Dbi<>(this, txn, nameBytes, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
-      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
-      return dbi;
-    }
+    return openDbi(Dbi.getNameBytes(name), comparator, nativeCb, flags);
   }
 
   /**
@@ -422,7 +416,7 @@ public Dbi<T> openDbi(
    */
   @Deprecated()
   public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
-    return createDbi().setDbName(name).withDefaultComparator().setDbiFlags(flags).open();
+    return openDbi(name, null, false, flags);
   }
 
   /**
@@ -437,12 +431,7 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
   @Deprecated()
   public Dbi<T> openDbi(
       final byte[] name, final Comparator<T> comparator, final DbiFlags... flags) {
-    requireNonNull(comparator);
-    return createDbi()
-        .setDbName(name)
-        .withIteratorComparator(ignored -> comparator)
-        .setDbiFlags(flags)
-        .open();
+    return openDbi(name, comparator, false, flags);
   }
 
   /**
@@ -640,6 +629,29 @@ public int readerCheck() {
     return resultPtr.intValue();
   }
 
+  /** For testing use. */
+  EnvFlagSet getEnvFlagSet() {
+    return envFlagSet;
+  }
+
+  @Override
+  public String toString() {
+    return "Env{"
+        + "closed="
+        + closed
+        + ", maxKeySize="
+        + maxKeySize
+        + ", noSubDir="
+        + noSubDir
+        + ", readOnly="
+        + readOnly
+        + ", path="
+        + path
+        + ", envFlagSet="
+        + envFlagSet
+        + '}';
+  }
+
   /** Object has already been closed and the operation is therefore prohibited. */
   public static final class AlreadyClosedException extends LmdbException {
 
@@ -754,7 +766,7 @@ public Env<T> open(final Path path) {
         final boolean readOnly = flags.isSet(MDB_RDONLY_ENV);
         final boolean noSubDir = flags.isSet(MDB_NOSUBDIR);
         checkRc(LIB.mdb_env_open(ptr, path.toAbsolutePath().toString(), flags.getMask(), mode));
-        return new Env<>(proxy, ptr, readOnly, noSubDir);
+        return new Env<>(proxy, ptr, readOnly, noSubDir, path, flags);
       } catch (final LmdbNativeException e) {
         LIB.mdb_env_close(ptr);
         throw e;
@@ -846,7 +858,7 @@ public Builder<T> setFilePermissions(final int mode) {
     public Builder<T> setEnvFlags(final Collection<EnvFlags> envFlags) {
       flagSetBuilder.clear();
       if (envFlags != null) {
-        envFlags.stream().filter(Objects::nonNull).forEach(envFlags::add);
+        envFlags.stream().filter(Objects::nonNull).forEach(flagSetBuilder::addFlag);
       }
       return this;
     }
@@ -884,23 +896,37 @@ public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
     /**
      * Adds a single {@link EnvFlags} to any existing flags.
      *
-     * @param dbiFlag The flag to add to any existing flags. A null value is a no-op.
+     * @param envFlag The flag to add to any existing flags. A null value is a no-op.
+     * @return this builder instance.
+     */
+    public Builder<T> addEnvFlag(final EnvFlags envFlag) {
+      this.flagSetBuilder.addFlag(envFlag);
+      return this;
+    }
+
+    /**
+     * Adds the contents of an {@link EnvFlagSet} to any existing flags.
+     *
+     * @param envFlagSet The set of flags to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
      */
-    public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
-      this.flagSetBuilder.addFlag(dbiFlag);
+    public Builder<T> addEnvFlags(final EnvFlagSet envFlagSet) {
+      if (envFlagSet != null) {
+        flagSetBuilder.addFlags(envFlagSet.getFlags());
+      }
       return this;
     }
 
     /**
-     * Adds a set of {@link EnvFlags} to any existing flags.
+     * Adds a {@link Collection} of {@link EnvFlags} to any existing flags.
      *
-     * @param dbiFlagSet The set of flags to add to any existing flags. A null value is a no-op.
+     * @param envFlags The {@link Collection} of flags to add to any existing flags. A null value is
+     *     a no-op.
      * @return this builder instance.
      */
-    public Builder<T> addEnvFlags(final EnvFlagSet dbiFlagSet) {
-      if (dbiFlagSet != null) {
-        flagSetBuilder.addFlags(dbiFlagSet.getFlags());
+    public Builder<T> addEnvFlags(final Collection<EnvFlags> envFlags) {
+      if (envFlags != null) {
+        flagSetBuilder.addFlags(envFlags);
       }
       return this;
     }
diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index 7fb4a29b..1d5c9214 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -155,7 +155,7 @@ public Set<EnvFlags> getFlags() {
 
   @Override
   public boolean isSet(final EnvFlags flag) {
-    return flag != null && mask == flag.getMask();
+    return this == flag;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/PutFlags.java b/src/main/java/org/lmdbjava/PutFlags.java
index 03fa916a..2c400bae 100644
--- a/src/main/java/org/lmdbjava/PutFlags.java
+++ b/src/main/java/org/lmdbjava/PutFlags.java
@@ -60,7 +60,7 @@ public Set<PutFlags> getFlags() {
 
   @Override
   public boolean isSet(PutFlags flag) {
-    return flag != null && mask == flag.getMask();
+    return this == flag;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index 94112957..866e1f65 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -42,7 +42,7 @@ public Set<TxnFlags> getFlags() {
 
   @Override
   public boolean isSet(final TxnFlags flag) {
-    return flag != null && mask == flag.getMask();
+    return this == flag;
   }
 
   @Override
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index fa4cbc83..575937f5 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -821,4 +821,12 @@ private void doEnvClosedTest(
       }
     }
   }
+
+  @Test
+  void getNameBytes() {
+    //noinspection ConstantValue
+    assertThat(Dbi.getNameBytes(null)).isNull();
+    ;
+    assertThat(Dbi.getNameBytes("foo")).isEqualTo("foo".getBytes(Env.DEFAULT_NAME_CHARSET));
+  }
 }
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 3f60076a..69a5ea4e 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -23,6 +23,7 @@
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.Builder.MAX_READERS_DEFAULT;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.EnvFlags.MDB_NOSYNC;
 import static org.lmdbjava.EnvFlags.MDB_NOTLS;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.TestUtils.DB_1;
@@ -33,7 +34,9 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Random;
 import org.assertj.core.api.Assertions;
@@ -90,6 +93,20 @@ void cannotChangeMapSizeAfterOpen() {
         .isInstanceOf(AlreadyOpenException.class);
   }
 
+  @Test
+  void cannotChangePermissionsAfterOpen() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder =
+                  Env.create().setFilePermissions(0666).setEnvFlags(MDB_NOSUBDIR);
+              try (Env<ByteBuffer> ignored = builder.setEnvFlags(MDB_NOSUBDIR).open(file)) {
+                builder.setFilePermissions(0664);
+              }
+            })
+        .isInstanceOf(AlreadyOpenException.class);
+  }
+
   @Test
   void cannotChangeMaxDbsAfterOpen() {
     assertThatThrownBy(
@@ -168,6 +185,16 @@ void negativeMapSize() {
         .isInstanceOf(IllegalArgumentException.class);
   }
 
+  @Test
+  void negativeMapSize2() {
+    assertThatThrownBy(
+            () -> {
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              builder.setMapSize(-1, ByteUnit.MEBIBYTES);
+            })
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+
   @Test
   void cannotStatOnceClosed() {
     assertThatThrownBy(
@@ -574,6 +601,8 @@ void addEnvFlag() {
             .open(file)) {
       env.sync(true);
       assertThat(Files.isRegularFile(file)).isTrue();
+      assertThat(env.getEnvFlagSet().getFlags())
+          .containsExactlyInAnyOrderElementsOf(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS).getFlags());
     }
   }
 
@@ -588,10 +617,71 @@ void addEnvFlags() {
             .addEnvFlags(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS))
             .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
             .addEnvFlag(null) // no-op
-            .addEnvFlags(null) // no-op
+            .addEnvFlags((EnvFlagSet) null) // no-op
+            .addEnvFlags((Collection<EnvFlags>) null) // no-op
+            .open(file)) {
+      env.sync(true);
+      assertThat(env.getEnvFlagSet().getFlags())
+          .containsExactlyInAnyOrderElementsOf(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS).getFlags());
+      assertThat(Files.isRegularFile(file)).isTrue();
+    }
+  }
+
+  @Test
+  void addEnvFlags2() {
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        Env.create()
+            .setMapSize(1, ByteUnit.MEBIBYTES)
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .addEnvFlags(Arrays.asList(MDB_NOSUBDIR, MDB_NOTLS))
+            .addEnvFlags(Collections.singleton(MDB_NOSYNC))
+            .open(file)) {
+      env.sync(true);
+      assertThat(env.getEnvFlagSet().getFlags())
+          .containsExactlyInAnyOrderElementsOf(
+              EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS, MDB_NOSYNC).getFlags());
+      assertThat(Files.isRegularFile(file)).isTrue();
+    }
+  }
+
+  @Test
+  void setEnvFlags() {
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        Env.create()
+            .setMapSize(1, ByteUnit.MEBIBYTES)
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .setEnvFlags((EnvFlagSet) null) // No-op
+            .setEnvFlags((EnvFlags) null) // No-op
+            .setEnvFlags((EnvFlags[]) null) // No-op
+            .setEnvFlags((Collection<EnvFlags>) null) // No-op
+            .setEnvFlags(MDB_NOSYNC) // Will be overwritten
+            .setEnvFlags(Arrays.asList(MDB_NOSUBDIR, MDB_NOTLS))
             .open(file)) {
       env.sync(true);
       assertThat(Files.isRegularFile(file)).isTrue();
+      assertThat(env.getEnvFlagSet().getFlags())
+          .containsExactlyInAnyOrderElementsOf(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS).getFlags());
+    }
+  }
+
+  @Test
+  void setEnvFlags2() {
+    final Path dir = tempDir.createTempDir();
+    try (Env<ByteBuffer> env =
+        Env.create()
+            .setMapSize(1, ByteUnit.MEBIBYTES)
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .setEnvFlags(MDB_NOSUBDIR, MDB_NOTLS)
+            .setEnvFlags(Collections.emptySet()) // Clears them
+            .open(dir)) {
+      env.sync(true);
+      assertThat(env.getEnvFlagSet().getFlags()).isEmpty();
+      assertThat(Files.isDirectory(dir));
     }
   }
 

From 850c4e2d1ec533c8c9fffc799131a457729744cd Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 17:29:17 +0000
Subject: [PATCH 79/90] Add DirectBufferProxyTest

---
 .../org/lmdbjava/DirectBufferProxyTest.java   | 114 ++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 src/test/java/org/lmdbjava/DirectBufferProxyTest.java

diff --git a/src/test/java/org/lmdbjava/DirectBufferProxyTest.java b/src/test/java/org/lmdbjava/DirectBufferProxyTest.java
new file mode 100644
index 00000000..73389c0d
--- /dev/null
+++ b/src/test/java/org/lmdbjava/DirectBufferProxyTest.java
@@ -0,0 +1,114 @@
+package org.lmdbjava;
+
+import java.nio.ByteOrder;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Random;
+import java.util.Set;
+import org.agrona.DirectBuffer;
+import org.agrona.MutableDirectBuffer;
+import org.agrona.concurrent.UnsafeBuffer;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class DirectBufferProxyTest {
+
+  @Test
+  public void verifyComparators_int() {
+    final Random random = new Random(203948);
+    final MutableDirectBuffer buffer1native = new UnsafeBuffer(new byte[Integer.BYTES]);
+    final MutableDirectBuffer buffer2native = new UnsafeBuffer(new byte[Integer.BYTES]);
+    final MutableDirectBuffer buffer1be = new UnsafeBuffer(new byte[Integer.BYTES]);
+    final MutableDirectBuffer buffer2be = new UnsafeBuffer(new byte[Integer.BYTES]);
+    final int[] values = random.ints().filter(i -> i >= 0).limit(5_000_000).toArray();
+
+    final LinkedHashMap<CompareType, Comparator<DirectBuffer>> comparators = new LinkedHashMap<>();
+    comparators.put(CompareType.INTEGER_KEY, DirectBufferProxy::compareAsIntegerKeys);
+    comparators.put(CompareType.LEXICOGRAPHIC, DirectBufferProxy::compareLexicographically);
+
+    final LinkedHashMap<CompareType, ComparatorResult> results =
+        new LinkedHashMap<>(comparators.size());
+    final Set<ComparatorResult> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      final int val1 = values[i - 1];
+      final int val2 = values[i];
+      buffer1native.putInt(0, val1, ByteOrder.nativeOrder());
+      buffer2native.putInt(0, val2, ByteOrder.nativeOrder());
+      buffer1be.putInt(0, val1, ByteOrder.BIG_ENDIAN);
+      buffer2be.putInt(0, val2, ByteOrder.BIG_ENDIAN);
+
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach(
+          (compareType, comparator) -> {
+            final ComparatorResult result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (compareType == CompareType.INTEGER_KEY) {
+              result = TestUtils.compare(comparator, buffer1native, buffer2native);
+            } else {
+              result = TestUtils.compare(comparator, buffer1be, buffer2be);
+            }
+            results.put(compareType, result);
+            uniqueResults.add(result);
+          });
+
+      if (uniqueResults.size() != 1) {
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+
+  @Test
+  public void verifyComparators_long() {
+    final Random random = new Random(203948);
+    final MutableDirectBuffer buffer1native = new UnsafeBuffer(new byte[Long.BYTES]);
+    final MutableDirectBuffer buffer2native = new UnsafeBuffer(new byte[Long.BYTES]);
+    final MutableDirectBuffer buffer1be = new UnsafeBuffer(new byte[Long.BYTES]);
+    final MutableDirectBuffer buffer2be = new UnsafeBuffer(new byte[Long.BYTES]);
+    final long[] values = random.longs().filter(i -> i >= 0).limit(5_000_000).toArray();
+
+    final LinkedHashMap<CompareType, Comparator<DirectBuffer>> comparators = new LinkedHashMap<>();
+    comparators.put(CompareType.INTEGER_KEY, DirectBufferProxy::compareAsIntegerKeys);
+    comparators.put(CompareType.LEXICOGRAPHIC, DirectBufferProxy::compareLexicographically);
+
+    final LinkedHashMap<CompareType, ComparatorResult> results =
+        new LinkedHashMap<>(comparators.size());
+    final Set<ComparatorResult> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      final long val1 = values[i - 1];
+      final long val2 = values[i];
+      buffer1native.putLong(0, val1, ByteOrder.nativeOrder());
+      buffer2native.putLong(0, val2, ByteOrder.nativeOrder());
+      buffer1be.putLong(0, val1, ByteOrder.BIG_ENDIAN);
+      buffer2be.putLong(0, val2, ByteOrder.BIG_ENDIAN);
+
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach(
+          (compareType, comparator) -> {
+            final ComparatorResult result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (compareType == CompareType.INTEGER_KEY) {
+              result = TestUtils.compare(comparator, buffer1native, buffer2native);
+            } else {
+              result = TestUtils.compare(comparator, buffer1be, buffer2be);
+            }
+            results.put(compareType, result);
+            uniqueResults.add(result);
+          });
+
+      if (uniqueResults.size() != 1) {
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+}

From 8eb95d05da415557cfd6efc6b491fe9ea1f0cbb0 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 19 Nov 2025 11:43:02 +1100
Subject: [PATCH 80/90] Support musl system library and LmdbJava Native
 0.9.33-3 (#280)

---
 pom.xml                                       |  2 +-
 src/main/java/org/lmdbjava/TargetName.java    | 19 ++++++++++++++++++-
 .../java/org/lmdbjava/TargetNameTest.java     |  8 ++++++--
 3 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/pom.xml b/pom.xml
index e7772ad9..2e2ed69d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -38,7 +38,7 @@
     <jnr-ffi.version>2.2.18</jnr-ffi.version>
     <junit.version>5.14.1</junit.version>
     <license-maven-plugin.version>4.6</license-maven-plugin.version>
-    <lmdbjava-native.version>0.9.33-2</lmdbjava-native.version>
+    <lmdbjava-native.version>0.9.33-3</lmdbjava-native.version>
     <maven-clean-plugin.version>3.5.0</maven-clean-plugin.version>
     <maven-compiler-plugin.version>3.14.1</maven-compiler-plugin.version>
     <maven-dependency-plugin.version>3.9.0</maven-dependency-plugin.version>
diff --git a/src/main/java/org/lmdbjava/TargetName.java b/src/main/java/org/lmdbjava/TargetName.java
index e3bb5db0..ef22bd20 100644
--- a/src/main/java/org/lmdbjava/TargetName.java
+++ b/src/main/java/org/lmdbjava/TargetName.java
@@ -18,6 +18,10 @@
 import static java.lang.System.getProperty;
 import static java.util.Locale.ENGLISH;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
 /**
  * Determines the name of the target LMDB native library.
  *
@@ -160,6 +164,19 @@ private static String resolveOs(final String os) {
   }
 
   private static String resolveToolchain(final String os) {
-    return check(os, "Mac OS") ? "none" : "gnu";
+    if (check(os, "Mac OS")) {
+      return "none";
+    }
+    return isMuslLibc() ? "musl" : "gnu";
+  }
+
+  private static boolean isMuslLibc() {
+    try {
+      return Files.lines(Paths.get("/proc/self/maps"))
+          .filter(line -> line.contains("libc"))
+          .anyMatch(line -> line.contains("musl"));
+    } catch (final IOException e) {
+      return false;
+    }
   }
 }
diff --git a/src/test/java/org/lmdbjava/TargetNameTest.java b/src/test/java/org/lmdbjava/TargetNameTest.java
index 04caea83..775b56d8 100644
--- a/src/test/java/org/lmdbjava/TargetNameTest.java
+++ b/src/test/java/org/lmdbjava/TargetNameTest.java
@@ -41,9 +41,13 @@ void customEmbedded() {
 
   @Test
   void embeddedNameResolution() {
-    embed("aarch64-linux-gnu.so", "aarch64", "Linux");
+    // Note: Linux resolution now detects musl vs glibc at runtime
+    // These tests verify the resolution logic but actual toolchain depends on system
+    final String linuxToolchain = TargetName.resolveFilename(NONE, NONE, "x86_64", "Linux")
+        .contains("-musl.") ? "musl" : "gnu";
+    embed("aarch64-linux-" + linuxToolchain + ".so", "aarch64", "Linux");
     embed("aarch64-macos-none.so", "aarch64", "Mac OS");
-    embed("x86_64-linux-gnu.so", "x86_64", "Linux");
+    embed("x86_64-linux-" + linuxToolchain + ".so", "x86_64", "Linux");
     embed("x86_64-macos-none.so", "x86_64", "Mac OS");
     embed("x86_64-windows-gnu.dll", "x86_64", "Windows");
   }

From 3136919e7d221477b03518d35f3085582d50b10f Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 20 Nov 2025 12:29:11 +1100
Subject: [PATCH 81/90] Improve musl detection (#280)

---
 src/main/java/org/lmdbjava/TargetName.java | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/main/java/org/lmdbjava/TargetName.java b/src/main/java/org/lmdbjava/TargetName.java
index ef22bd20..fde95e6f 100644
--- a/src/main/java/org/lmdbjava/TargetName.java
+++ b/src/main/java/org/lmdbjava/TargetName.java
@@ -21,6 +21,7 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
+import java.util.stream.Stream;
 
 /**
  * Determines the name of the target LMDB native library.
@@ -171,10 +172,8 @@ private static String resolveToolchain(final String os) {
   }
 
   private static boolean isMuslLibc() {
-    try {
-      return Files.lines(Paths.get("/proc/self/maps"))
-          .filter(line -> line.contains("libc"))
-          .anyMatch(line -> line.contains("musl"));
+    try (Stream<String> lines = Files.lines(Paths.get("/proc/self/maps"))) {
+      return lines.anyMatch(line -> line.contains("/ld-musl"));
     } catch (final IOException e) {
       return false;
     }

From 1800dd6670740fabceee25fd6490f9ad9b88b47b Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 20 Nov 2025 17:12:48 +0000
Subject: [PATCH 82/90] Improve javadoc, format code

---
 src/main/java/org/lmdbjava/DbiBuilder.java     | 3 ++-
 src/test/java/org/lmdbjava/TargetNameTest.java | 6 ++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index f322cb6d..29bbb8f5 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -302,7 +302,8 @@ public Stage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
      * Use the supplied transaction to open the {@link Dbi}.
      *
      * <p>The caller MUST commit the transaction after calling {@link Stage3#open()}, in order to
-     * retain the <code>Dbi</code> in the <code>Env</code>.
+     * retain the <code>Dbi</code> in the <code>Env</code>. The caller is also responsible for
+     * closing the transaction.
      *
      * <p>If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for
      * the purpose of creating and opening the {@link Dbi}, then closed. Therefore, if you already
diff --git a/src/test/java/org/lmdbjava/TargetNameTest.java b/src/test/java/org/lmdbjava/TargetNameTest.java
index 775b56d8..6c0a8f44 100644
--- a/src/test/java/org/lmdbjava/TargetNameTest.java
+++ b/src/test/java/org/lmdbjava/TargetNameTest.java
@@ -43,8 +43,10 @@ void customEmbedded() {
   void embeddedNameResolution() {
     // Note: Linux resolution now detects musl vs glibc at runtime
     // These tests verify the resolution logic but actual toolchain depends on system
-    final String linuxToolchain = TargetName.resolveFilename(NONE, NONE, "x86_64", "Linux")
-        .contains("-musl.") ? "musl" : "gnu";
+    final String linuxToolchain =
+        TargetName.resolveFilename(NONE, NONE, "x86_64", "Linux").contains("-musl.")
+            ? "musl"
+            : "gnu";
     embed("aarch64-linux-" + linuxToolchain + ".so", "aarch64", "Linux");
     embed("aarch64-macos-none.so", "aarch64", "Mac OS");
     embed("x86_64-linux-" + linuxToolchain + ".so", "x86_64", "Linux");

From 83c3a62afe2868b2c93fd7d61b39fc3d57b92a97 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 20 Nov 2025 17:34:39 +0000
Subject: [PATCH 83/90] Add missing @Override, remove commented code

---
 .../java/org/lmdbjava/ComparatorTest.java     | 25 +------------------
 1 file changed, 1 insertion(+), 24 deletions(-)

diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index fbde37c3..5a1ddb62 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -256,30 +256,6 @@ public int compare(final byte[] o1, final byte[] o2) {
     }
   }
 
-  //  /** Converts an integer result code into its contractual meaning. */
-  //  enum ComparatorResult {
-  //    LESS_THAN,
-  //    EQUAL_TO,
-  //    GREATER_THAN;
-  //
-  //    static ComparatorResult get(final int comparatorResult) {
-  //      if (comparatorResult == 0) {
-  //        return EQUAL_TO;
-  //      }
-  //      return comparatorResult < 0 ? LESS_THAN : GREATER_THAN;
-  //    }
-  //
-  //    ComparatorResult opposite() {
-  //      if (this == LESS_THAN) {
-  //        return GREATER_THAN;
-  //      } else if (this == GREATER_THAN) {
-  //        return LESS_THAN;
-  //      } else {
-  //        return EQUAL_TO;
-  //      }
-  //    }
-  //  }
-
   /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
   private interface ComparatorRunner extends Comparator<byte[]> {
 
@@ -291,6 +267,7 @@ private interface ComparatorRunner extends Comparator<byte[]> {
      * @param o2 rhs buffer content
      * @return as per {@link Comparable}
      */
+    @Override
     int compare(byte[] o1, byte[] o2);
   }
 }

From d047260ce48a5b935fa81f8e3836a905352eafb8 Mon Sep 17 00:00:00 2001
From: BP Alex <718596+bp-alex@users.noreply.github.com>
Date: Tue, 13 Jan 2026 16:30:50 +1100
Subject: [PATCH 84/90] Add missing copyright header

---
 .../java/org/lmdbjava/DirectBufferProxyTest.java  | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/test/java/org/lmdbjava/DirectBufferProxyTest.java b/src/test/java/org/lmdbjava/DirectBufferProxyTest.java
index 73389c0d..fc01e801 100644
--- a/src/test/java/org/lmdbjava/DirectBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/DirectBufferProxyTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2026 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.nio.ByteOrder;

From f2962f4a15bf9d9a3073d97e9eb0f309dc123fdc Mon Sep 17 00:00:00 2001
From: BP Alex <718596+bp-alex@users.noreply.github.com>
Date: Tue, 13 Jan 2026 16:44:20 +1100
Subject: [PATCH 85/90] POM auto-formatting

---
 pom.xml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/pom.xml b/pom.xml
index 2e2ed69d..ccc7e9f0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright © 2016-2025 The LmdbJava Open Source Project
+    Copyright © 2016-2026 The LmdbJava Open Source Project
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -218,19 +218,19 @@
             </goals>
             <configuration>
               <rules>
-                <dependencyConvergence />
+                <dependencyConvergence/>
                 <requireMavenVersion>
                   <version>[${maven.enforcer.mvn},)</version>
                 </requireMavenVersion>
                 <requireJavaVersion>
                   <version>[${maven.enforcer.java},)</version>
                 </requireJavaVersion>
-                <requireNoRepositories />
-                <requirePluginVersions />
+                <requireNoRepositories/>
+                <requirePluginVersions/>
                 <requireReleaseDeps>
                   <onlyWhenRelease>true</onlyWhenRelease>
                 </requireReleaseDeps>
-                <requireUpperBoundDeps />
+                <requireUpperBoundDeps/>
               </rules>
             </configuration>
           </execution>

From 50612662a85fd0e7a450aa8e7c57dcbf3cc924d1 Mon Sep 17 00:00:00 2001
From: BP Alex <718596+bp-alex@users.noreply.github.com>
Date: Tue, 13 Jan 2026 17:32:17 +1100
Subject: [PATCH 86/90] Update native to 0.9.33-4 (#280)

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index ccc7e9f0..20a47038 100644
--- a/pom.xml
+++ b/pom.xml
@@ -38,7 +38,7 @@
     <jnr-ffi.version>2.2.18</jnr-ffi.version>
     <junit.version>5.14.1</junit.version>
     <license-maven-plugin.version>4.6</license-maven-plugin.version>
-    <lmdbjava-native.version>0.9.33-3</lmdbjava-native.version>
+    <lmdbjava-native.version>0.9.33-4</lmdbjava-native.version>
     <maven-clean-plugin.version>3.5.0</maven-clean-plugin.version>
     <maven-compiler-plugin.version>3.14.1</maven-compiler-plugin.version>
     <maven-dependency-plugin.version>3.9.0</maven-dependency-plugin.version>

From 8abdbecebdc0a7f550bac17aaed3df2e41088ccd Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 26 Jan 2026 21:56:22 +0000
Subject: [PATCH 87/90] Bump org.assertj:assertj-core from 3.27.6 to 3.27.7

Bumps [org.assertj:assertj-core](https://github.com/assertj/assertj) from 3.27.6 to 3.27.7.
- [Release notes](https://github.com/assertj/assertj/releases)
- [Commits](https://github.com/assertj/assertj/compare/assertj-build-3.27.6...assertj-build-3.27.7)

---
updated-dependencies:
- dependency-name: org.assertj:assertj-core
  dependency-version: 3.27.7
  dependency-type: direct:development
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 20a47038..b0724fbc 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   <properties>
     <!-- Agrona 1.23+ requires Java 17+ -->
     <agrona.version>1.22.0</agrona.version>
-    <assertj.version>3.27.6</assertj.version>
+    <assertj.version>3.27.7</assertj.version>
     <buildnumber-maven-plugin.version>3.2.1</buildnumber-maven-plugin.version>
     <central-publishing-maven-plugin.version>0.9.0</central-publishing-maven-plugin.version>
     <fmt-maven-plugin.version>2.29</fmt-maven-plugin.version>

From 0de591af0657fdf7fa8f0f9927b1c03002927708 Mon Sep 17 00:00:00 2001
From: BP Alex <718596+bp-alex@users.noreply.github.com>
Date: Fri, 30 Jan 2026 09:23:53 +1100
Subject: [PATCH 88/90] Update native to 0.9.33-5 (#280)

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 20a47038..4af065d9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -38,7 +38,7 @@
     <jnr-ffi.version>2.2.18</jnr-ffi.version>
     <junit.version>5.14.1</junit.version>
     <license-maven-plugin.version>4.6</license-maven-plugin.version>
-    <lmdbjava-native.version>0.9.33-4</lmdbjava-native.version>
+    <lmdbjava-native.version>0.9.33-5</lmdbjava-native.version>
     <maven-clean-plugin.version>3.5.0</maven-clean-plugin.version>
     <maven-compiler-plugin.version>3.14.1</maven-compiler-plugin.version>
     <maven-dependency-plugin.version>3.9.0</maven-dependency-plugin.version>

From fc1bcbd9b4ee8806fd309033dcbf31838f3faf38 Mon Sep 17 00:00:00 2001
From: BP Alex <718596+bp-alex@users.noreply.github.com>
Date: Fri, 6 Feb 2026 09:17:06 +1100
Subject: [PATCH 89/90] Improve error message for unsupported OS (#283)

---
 src/main/java/org/lmdbjava/TargetName.java | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/lmdbjava/TargetName.java b/src/main/java/org/lmdbjava/TargetName.java
index fde95e6f..49a65dea 100644
--- a/src/main/java/org/lmdbjava/TargetName.java
+++ b/src/main/java/org/lmdbjava/TargetName.java
@@ -134,10 +134,12 @@ private static String err(final String reason) {
     return reason
         + " (please set system property "
         + LMDB_NATIVE_LIB_PROP
-        + " to the path of an external LMDB native library or property "
+        + " to the path of an external LMDB native library,"
+        + " or simply 'lmdb' if LMDB is installed in standard system paths;"
+        + " alternatively set property "
         + LMDB_EMBEDDED_LIB_PROP
-        + " to the name of an LmdbJava embedded"
-        + " library; os.arch='"
+        + " to the name of an LmdbJava embedded library;"
+        + " os.arch='"
         + ARCH
         + "' os.name='"
         + OS

From cc2f24a405478c76da10540a803d295aa7fefdbe Mon Sep 17 00:00:00 2001
From: BP Alex <718596+bp-alex@users.noreply.github.com>
Date: Fri, 6 Feb 2026 09:45:32 +1100
Subject: [PATCH 90/90] Deploy releases on tag push, snapshots on branch push

Prevents double deployment during release:prepare by checking
POM version before deploying. Branch pushes only deploy if
version contains -SNAPSHOT; tag pushes only deploy if it does not.
---
 .github/workflows/maven.yml | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 38f6472b..0df7cef5 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -3,6 +3,7 @@ name: Maven Build and Deployment
 on:
   push:
     branches: [ master ]
+    tags: [ 'lmdbjava-*' ]
   pull_request:
     branches: [ master ]
 
@@ -84,7 +85,14 @@ jobs:
         gpg-private-key: ${{ secrets.gpg_private_key }}
         gpg-passphrase: MAVEN_GPG_PASSPHRASE
 
+    - name: Get project version
+      id: version
+      run: echo "version=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout)" >> $GITHUB_OUTPUT
+
     - name: Publish Maven package
+      if: |
+        (github.ref_type == 'branch' && contains(steps.version.outputs.version, '-SNAPSHOT')) ||
+        (github.ref_type == 'tag' && !contains(steps.version.outputs.version, '-SNAPSHOT'))
       run: mvn -B -Pcentral-deploy deploy -DskipTests
       env:
         MAVEN_GPG_PASSPHRASE: ${{ secrets.gpg_passphrase }}