Merge branch 'master' into mdb_cmp

lmdbjava · stroomdev66 · Mar 6, 2025 · Mar 6, 2025 · Mar 6, 2025 · Mar 6, 2025
commit f606e7ee85bd5511a58e172940225a93a20d4bb3
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
@@ -188,7 +188,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)) {
      if (!cursor.first()) {
@@ -508,7 +508,7 @@
    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)
@@ -644,6 +644,8 @@
      * @return an environment ready for use
      */
     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.
       requireNonNull(path);
       if (opened) {
         throw new AlreadyOpenException();
@@ -675,6 +677,7 @@
      * @return an environment ready for use
      */
     public Env<T> open(final File path, final EnvFlags... flags) {
+      // TODO make constant
       return open(path, 0664, flags);
     }
 

diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -59,10 +59,20 @@ 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) {
     return mask1 | mask2;
   }
 
+  /**
+   * Fetch the integer mask for the 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 Collection<M> flags) {
     if (flags == null || flags.isEmpty()) {
       return EMPTY_MASK;

diff --git a/src/main/java/org/lmdbjava/ReferenceUtil.java b/src/main/java/org/lmdbjava/ReferenceUtil.java
@@ -44,11 +44,7 @@ private ReferenceUtil() {}
    *     Vladimir Ivanov on reachabilityFence implementation</a>
    */
   public static void reachabilityFence0(final Object ref) {
-    if (ref != null) {
-      //noinspection EmptySynchronizedStatement
-      synchronized (ref) {
-        // Empty synchronized is ok: https://stackoverflow.com/a/31933260/1151521
-      }
-    }
+    // Empty method body is intentional - the method call itself at bytecode level
+    // extends the object's live range per HotSpot JIT behavior
   }
 }
diff --git a/src/main/resources/org/lmdbjava/aarch64-linux-gnu.so b/src/main/resources/org/lmdbjava/aarch64-linux-gnu.so
diff --git a/src/main/resources/org/lmdbjava/aarch64-macos-none.so b/src/main/resources/org/lmdbjava/aarch64-macos-none.so
diff --git a/src/main/resources/org/lmdbjava/x86_64-linux-gnu.so b/src/main/resources/org/lmdbjava/x86_64-linux-gnu.so
diff --git a/src/main/resources/org/lmdbjava/x86_64-macos-none.so b/src/main/resources/org/lmdbjava/x86_64-macos-none.so
diff --git a/src/main/resources/org/lmdbjava/x86_64-windows-gnu.dll b/src/main/resources/org/lmdbjava/x86_64-windows-gnu.dll
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -47,10 +47,8 @@
 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.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
 import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
 import org.lmdbjava.Env.ReadersFullException;
 
@@ -61,20 +59,23 @@
 
   static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
-
-  @Test(expected = BufferMustBeDirectException.class)
-  public void buffersMustBeDirect() throws IOException {
-    final File path = tmp.newFolder();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(path)) {
-      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
-    }
+  @Test
+  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
+                }
+              });
+        })
+        .isInstanceOf(BufferMustBeDirectException.class);
   }
 
   @Test
@@ -98,9 +99,9 @@
   @Test
   void fieldNeverFound() {
     assertThatThrownBy(
-            () -> {
-              findField(Exception.class, "notARealField");
-            })
+        () -> {
+          findField(Exception.class, "notARealField");
+        })
         .isInstanceOf(LmdbException.class);
   }
 
@@ -157,7 +158,7 @@
    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())
@@ -234,7 +235,9 @@
       });
 
       if (uniqueResults.size() != 1) {
-        Assert.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/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -15,60 +15,44 @@
  */
 package org.lmdbjava;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import java.util.Collections;
 import java.util.HashSet;
-import org.junit.Test;
+import org.junit.jupiter.api.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));
+        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, is(copyFlagSet2));
-        assertThat(copyFlagSet, not(CopyFlagSet.of(CopyFlags.MDB_CP_COMPACT)));
-        assertThat(copyFlagSet, not(CopyFlagSet.builder()
+        assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
+        assertThat(copyFlagSet).isNotEqualTo(CopyFlagSet.of(CopyFlags.MDB_CP_COMPACT));
+        assertThat(copyFlagSet).isNotEqualTo(CopyFlagSet.builder()
             .setFlag(CopyFlags.MDB_CP_COMPACT)
-            .build()));
+            .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));
+        assertThat(copyFlagSet.getMask()).isEqualTo(MaskedFlag.mask(copyFlag));
+        assertThat(copyFlagSet.size()).isEqualTo(1);
         for (CopyFlags flag : copyFlagSet) {
-            assertThat(
-                    copyFlagSet.isSet(flag),
-                    is(true));
+            assertThat(copyFlagSet.isSet(flag)).isEqualTo(true);
         }
 
         final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
             .setFlag(copyFlag)
             .build();
-        assertThat(copyFlagSet, is(copyFlagSet2));
+        assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
     }
 
     @Test
@@ -77,27 +61,19 @@ public void testBuilder() {
         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));
+        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),
-                    is(true));
+            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, is(copyFlagSet2));
-        assertThat(copyFlagSet, is(copyFlagSet3));
+        assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
+        assertThat(copyFlagSet).isEqualTo(copyFlagSet3);
     }
 }