diff --git a/src/main/java/it/cavallium/dbengine/database/memory/LLMemoryDictionary.java b/src/main/java/it/cavallium/dbengine/database/memory/LLMemoryDictionary.java index 845cbb7..2992eb3 100644 --- a/src/main/java/it/cavallium/dbengine/database/memory/LLMemoryDictionary.java +++ b/src/main/java/it/cavallium/dbengine/database/memory/LLMemoryDictionary.java @@ -154,7 +154,11 @@ public class LLMemoryDictionary implements LLDictionary { return Mono.usingWhen(keyMono, key -> Mono.usingWhen(valueMono, value -> Mono - .fromCallable(() -> mainDb.put(k(key), k(value))) + .fromCallable(() -> { + var k = k(key); + var v = k(value); + return mainDb.put(k, v); + }) .transform(result -> this.transformResult(result, resultType)) .onErrorMap(cause -> new IOException("Failed to read", cause)), value -> Mono.fromRunnable(value::close) diff --git a/src/test/java/it/cavallium/dbengine/DbTestUtils.java b/src/test/java/it/cavallium/dbengine/DbTestUtils.java index 449b9c1..1b5206d 100644 --- a/src/test/java/it/cavallium/dbengine/DbTestUtils.java +++ b/src/test/java/it/cavallium/dbengine/DbTestUtils.java @@ -42,6 +42,17 @@ import reactor.core.scheduler.Schedulers; public class DbTestUtils { + + public static final String BIG_STRING = generateBigString(); + + private static String generateBigString() { + var sb = new StringBuilder(); + for (int i = 0; i < 1024; i++) { + sb.append("0123456789"); + } + return sb.toString(); + } + public static record TestAllocator(PooledBufferAllocator allocator) {} public static TestAllocator newAllocator() { @@ -52,8 +63,6 @@ public class DbTestUtils { testAllocator.allocator().close(); } - public static final AtomicInteger dbId = new AtomicInteger(0); - @SuppressWarnings("SameParameterValue") private static long getUsedMemory(PooledBufferAllocator allocator, boolean printStats) { allocator.trimCurrentThreadCache(); @@ -64,47 +73,20 @@ public class DbTestUtils { return usedMemory; } - public static Flux tempDb(TestAllocator alloc, Function> action) { - return Flux.usingWhen(openTempDb(alloc), + public static Flux tempDb(TemporaryDbGenerator temporaryDbGenerator, + TestAllocator alloc, + Function> action) { + return Flux.usingWhen( + temporaryDbGenerator.openTempDb(alloc), tempDb -> action.apply(tempDb.db()), - DbTestUtils::closeTempDb + temporaryDbGenerator::closeTempDb ); } public static record TempDb(TestAllocator allocator, LLDatabaseConnection connection, LLKeyValueDatabase db, Path path) {} - public static Mono openTempDb(TestAllocator alloc) { - boolean canUseNettyDirect = computeCanUseNettyDirect(); - return Mono.defer(() -> { - var wrkspcPath = Path.of("/tmp/.cache/tempdb-" + dbId.incrementAndGet() + "/"); - return Mono - .fromCallable(() -> { - if (Files.exists(wrkspcPath)) { - Files.walk(wrkspcPath).sorted(Comparator.reverseOrder()).forEach(file -> { - try { - Files.delete(file); - } catch (IOException ex) { - throw new CompletionException(ex); - } - }); - } - Files.createDirectories(wrkspcPath); - return null; - }) - .subscribeOn(Schedulers.boundedElastic()) - .then(new LLLocalDatabaseConnection(alloc.allocator(), wrkspcPath).connect()) - .flatMap(conn -> conn - .getDatabase("testdb", - List.of(Column.dictionary("testmap"), Column.special("ints"), Column.special("longs")), - new DatabaseOptions(Map.of(), true, false, true, false, true, canUseNettyDirect, canUseNettyDirect, -1) - ) - .map(db -> new TempDb(alloc, conn, db, wrkspcPath)) - ); - }); - } - - private static boolean computeCanUseNettyDirect() { + static boolean computeCanUseNettyDirect() { boolean canUse = true; if (!PlatformDependent.hasUnsafe()) { System.err.println("Warning! Unsafe is not available!" @@ -124,22 +106,6 @@ public class DbTestUtils { return canUse; } - public static Mono closeTempDb(TempDb tempDb) { - return tempDb.db().close().then(tempDb.connection().disconnect()).then(Mono.fromCallable(() -> { - ensureNoLeaks(tempDb.allocator().allocator(), false); - if (Files.exists(tempDb.path())) { - Files.walk(tempDb.path()).sorted(Comparator.reverseOrder()).forEach(file -> { - try { - Files.delete(file); - } catch (IOException ex) { - throw new CompletionException(ex); - } - }); - } - return null; - }).subscribeOn(Schedulers.boundedElastic())).then(); - } - public static void ensureNoLeaks(PooledBufferAllocator allocator, boolean printStats) { if (allocator != null) { assertEquals(0L, getUsedMemory(allocator, printStats)); @@ -157,16 +123,16 @@ public class DbTestUtils { } - public enum DbType { + public enum MapType { MAP, HASH_MAP } public static DatabaseStageMap> tempDatabaseMapDictionaryMap( LLDictionary dictionary, - DbType dbType, + MapType mapType, int keyBytes) { - if (dbType == DbType.MAP) { + if (mapType == MapType.MAP) { return DatabaseMapDictionary.simple(dictionary, SerializerFixedBinaryLength.utf8(dictionary.getAllocator(), keyBytes), Serializer.utf8(dictionary.getAllocator()) diff --git a/src/test/java/it/cavallium/dbengine/LocalTemporaryDbGenerator.java b/src/test/java/it/cavallium/dbengine/LocalTemporaryDbGenerator.java new file mode 100644 index 0000000..fd47fc0 --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/LocalTemporaryDbGenerator.java @@ -0,0 +1,73 @@ +package it.cavallium.dbengine; + +import static it.cavallium.dbengine.DbTestUtils.ensureNoLeaks; + +import it.cavallium.dbengine.DbTestUtils.TempDb; +import it.cavallium.dbengine.DbTestUtils.TestAllocator; +import it.cavallium.dbengine.client.DatabaseOptions; +import it.cavallium.dbengine.database.Column; +import it.cavallium.dbengine.database.LLKeyValueDatabase; +import it.cavallium.dbengine.database.disk.LLLocalDatabaseConnection; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Comparator; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletionException; +import java.util.concurrent.atomic.AtomicInteger; +import reactor.core.publisher.Mono; +import reactor.core.scheduler.Schedulers; + +public class LocalTemporaryDbGenerator implements TemporaryDbGenerator { + + private static final AtomicInteger dbId = new AtomicInteger(0); + + @Override + public Mono openTempDb(TestAllocator allocator) { + boolean canUseNettyDirect = DbTestUtils.computeCanUseNettyDirect(); + return Mono.defer(() -> { + var wrkspcPath = Path.of("/tmp/.cache/tempdb-" + dbId.incrementAndGet() + "/"); + return Mono + .fromCallable(() -> { + if (Files.exists(wrkspcPath)) { + Files.walk(wrkspcPath).sorted(Comparator.reverseOrder()).forEach(file -> { + try { + Files.delete(file); + } catch (IOException ex) { + throw new CompletionException(ex); + } + }); + } + Files.createDirectories(wrkspcPath); + return null; + }) + .subscribeOn(Schedulers.boundedElastic()) + .then(new LLLocalDatabaseConnection(allocator.allocator(), wrkspcPath).connect()) + .flatMap(conn -> conn + .getDatabase("testdb", + List.of(Column.dictionary("testmap"), Column.special("ints"), Column.special("longs")), + new DatabaseOptions(Map.of(), true, false, true, false, true, canUseNettyDirect, canUseNettyDirect, -1) + ) + .map(db -> new TempDb(allocator, conn, db, wrkspcPath)) + ); + }); + } + + @Override + public Mono closeTempDb(TempDb tempDb) { + return tempDb.db().close().then(tempDb.connection().disconnect()).then(Mono.fromCallable(() -> { + ensureNoLeaks(tempDb.allocator().allocator(), false); + if (Files.exists(tempDb.path())) { + Files.walk(tempDb.path()).sorted(Comparator.reverseOrder()).forEach(file -> { + try { + Files.delete(file); + } catch (IOException ex) { + throw new CompletionException(ex); + } + }); + } + return null; + }).subscribeOn(Schedulers.boundedElastic())).then(); + } +} diff --git a/src/test/java/it/cavallium/dbengine/MemoryTemporaryDbGenerator.java b/src/test/java/it/cavallium/dbengine/MemoryTemporaryDbGenerator.java new file mode 100644 index 0000000..3001728 --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/MemoryTemporaryDbGenerator.java @@ -0,0 +1,31 @@ +package it.cavallium.dbengine; + +import it.cavallium.dbengine.DbTestUtils.TempDb; +import it.cavallium.dbengine.DbTestUtils.TestAllocator; +import it.cavallium.dbengine.client.DatabaseOptions; +import it.cavallium.dbengine.database.Column; +import it.cavallium.dbengine.database.memory.LLMemoryDatabaseConnection; +import java.util.List; +import java.util.Map; +import reactor.core.publisher.Mono; + +public class MemoryTemporaryDbGenerator implements TemporaryDbGenerator { + + @Override + public Mono openTempDb(TestAllocator allocator) { + boolean canUseNettyDirect = DbTestUtils.computeCanUseNettyDirect(); + return Mono + .fromCallable(() -> new LLMemoryDatabaseConnection(allocator.allocator())) + .flatMap(conn -> conn + .getDatabase("testdb", + List.of(Column.dictionary("testmap"), Column.special("ints"), Column.special("longs")), + new DatabaseOptions(Map.of(), true, false, true, false, true, canUseNettyDirect, canUseNettyDirect, -1) + ) + .map(db -> new TempDb(allocator, conn, db, null))); + } + + @Override + public Mono closeTempDb(TempDb db) { + return db.db().close(); + } +} diff --git a/src/test/java/it/cavallium/dbengine/TemporaryDbGenerator.java b/src/test/java/it/cavallium/dbengine/TemporaryDbGenerator.java new file mode 100644 index 0000000..85e63d1 --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/TemporaryDbGenerator.java @@ -0,0 +1,13 @@ +package it.cavallium.dbengine; + +import io.netty5.buffer.api.BufferAllocator; +import it.cavallium.dbengine.DbTestUtils.TempDb; +import it.cavallium.dbengine.DbTestUtils.TestAllocator; +import reactor.core.publisher.Mono; + +public interface TemporaryDbGenerator { + + Mono openTempDb(TestAllocator allocator); + + Mono closeTempDb(TempDb db); +} diff --git a/src/test/java/it/cavallium/dbengine/TestDictionary.java b/src/test/java/it/cavallium/dbengine/TestDictionary.java index fcaa056..5acc271 100644 --- a/src/test/java/it/cavallium/dbengine/TestDictionary.java +++ b/src/test/java/it/cavallium/dbengine/TestDictionary.java @@ -18,10 +18,12 @@ import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import reactor.test.StepVerifier; -public class TestDictionary { +public abstract class TestDictionary { private TestAllocator allocator; + protected abstract TemporaryDbGenerator getTempDbGenerator(); + private static Stream provideArgumentsCreate() { return Arrays.stream(UpdateMode.values()).map(Arguments::of); } @@ -42,7 +44,7 @@ public class TestDictionary { @MethodSource("provideArgumentsCreate") public void testCreate(UpdateMode updateMode) { StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .flatMap(LLDictionary::clear) .then() )) diff --git a/src/test/java/it/cavallium/dbengine/TestDictionaryMap.java b/src/test/java/it/cavallium/dbengine/TestDictionaryMap.java index 7c9b738..533f0af 100644 --- a/src/test/java/it/cavallium/dbengine/TestDictionaryMap.java +++ b/src/test/java/it/cavallium/dbengine/TestDictionaryMap.java @@ -9,8 +9,6 @@ import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Objects; -import java.util.Optional; -import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -27,7 +25,7 @@ import reactor.test.StepVerifier.Step; import reactor.util.function.Tuple2; import reactor.util.function.Tuples; -public class TestDictionaryMap { +public abstract class TestDictionaryMap { private TestAllocator allocator; @@ -35,7 +33,7 @@ public class TestDictionaryMap { return System.getProperty("badkeys", "true").equalsIgnoreCase("true"); } - private static final String BIG_STRING = "012345678901234567890123456789"; + protected abstract TemporaryDbGenerator getTempDbGenerator(); private static Stream provideArgumentsPut() { var goodKeys = List.of("12345"); @@ -67,16 +65,16 @@ public class TestDictionaryMap { entryTuple.getT2(), entryTuple.getT3() ))) - .flatMap(entryTuple -> Stream.of(Tuples.of(DbType.MAP, entryTuple.getT1(), + .flatMap(entryTuple -> Stream.of(Tuples.of(MapType.MAP, entryTuple.getT1(), entryTuple.getT2(), entryTuple.getT3(), entryTuple.getT4() - ), Tuples.of(DbType.HASH_MAP, entryTuple.getT1(), + ), Tuples.of(MapType.HASH_MAP, entryTuple.getT1(), entryTuple.getT2(), entryTuple.getT3(), false ))) - .filter(tuple -> !(tuple.getT1() == DbType.HASH_MAP && tuple.getT2() != UpdateMode.ALLOW)) + .filter(tuple -> !(tuple.getT1() == MapType.HASH_MAP && tuple.getT2() != UpdateMode.ALLOW)) .map(fullTuple -> Arguments.of(fullTuple.getT1(), fullTuple.getT2(), fullTuple.getT3(), fullTuple.getT4(), fullTuple.getT5())); } @@ -94,10 +92,10 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPut") - public void testPut(DbType dbType, UpdateMode updateMode, String key, String value, boolean shouldFail) { + public void testPut(MapType mapType, UpdateMode updateMode, String key, String value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMap(map -> map .putValue(key, value) .then(map.getValue(null, key)) @@ -113,10 +111,10 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPut") - public void testAtSetAtGet(DbType dbType, UpdateMode updateMode, String key, String value, boolean shouldFail) { + public void testAtSetAtGet(MapType mapType, UpdateMode updateMode, String key, String value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMap(map -> map .at(null, key).flatMap(v -> v.set(value).doAfterTerminate(v::release)) .then(map.at(null, key).flatMap(v -> v.get(null).doAfterTerminate(v::release))) @@ -132,10 +130,10 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPut") - public void testPutAndGetPrevious(DbType dbType, UpdateMode updateMode, String key, String value, boolean shouldFail) { + public void testPutAndGetPrevious(MapType mapType, UpdateMode updateMode, String key, String value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.putValueAndGetPrevious(key, "error?"), @@ -154,10 +152,10 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPut") - public void testPutValueRemoveAndGetPrevious(DbType dbType, UpdateMode updateMode, String key, String value, boolean shouldFail) { + public void testPutValueRemoveAndGetPrevious(MapType mapType, UpdateMode updateMode, String key, String value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.removeAndGetPrevious(key), @@ -176,10 +174,10 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPut") - public void testPutValueRemoveAndGetStatus(DbType dbType, UpdateMode updateMode, String key, String value, boolean shouldFail) { + public void testPutValueRemoveAndGetStatus(MapType mapType, UpdateMode updateMode, String key, String value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.removeAndGetStatus(key), @@ -198,13 +196,13 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPut") - public void testUpdate(DbType dbType, UpdateMode updateMode, String key, String value, boolean shouldFail) { + public void testUpdate(MapType mapType, UpdateMode updateMode, String key, String value, boolean shouldFail) { if (updateMode == UpdateMode.DISALLOW && !isTestBadKeysEnabled()) { return; } var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.updateValue(key, old -> { @@ -240,13 +238,13 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPut") - public void testUpdateGet(DbType dbType, UpdateMode updateMode, String key, String value, boolean shouldFail) { + public void testUpdateGet(MapType mapType, UpdateMode updateMode, String key, String value, boolean shouldFail) { if (updateMode == UpdateMode.DISALLOW && !isTestBadKeysEnabled()) { return; } var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.updateValue(key, old -> { @@ -282,10 +280,10 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPut") - public void testPutAndGetChanged(DbType dbType, UpdateMode updateMode, String key, String value, boolean shouldFail) { + public void testPutAndGetChanged(MapType mapType, UpdateMode updateMode, String key, String value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.putValueAndGetChanged(key, "error?").single(), @@ -329,24 +327,24 @@ public class TestDictionaryMap { entryTuple.getT1(), entryTuple.getT2() ))) - .flatMap(entryTuple -> Stream.of(Tuples.of(DbType.MAP, entryTuple.getT1(), + .flatMap(entryTuple -> Stream.of(Tuples.of(MapType.MAP, entryTuple.getT1(), entryTuple.getT2(), entryTuple.getT3() - ), Tuples.of(DbType.HASH_MAP, entryTuple.getT1(), + ), Tuples.of(MapType.HASH_MAP, entryTuple.getT1(), entryTuple.getT2(), false ))) - .filter(tuple -> !(tuple.getT1() == DbType.HASH_MAP && tuple.getT2() != UpdateMode.ALLOW)) + .filter(tuple -> !(tuple.getT1() == MapType.HASH_MAP && tuple.getT2() != UpdateMode.ALLOW)) .map(fullTuple -> Arguments.of(fullTuple.getT1(), fullTuple.getT2(), fullTuple.getT3(), fullTuple.getT4())); } @ParameterizedTest @MethodSource("provideArgumentsPutMulti") - public void testPutMultiGetMulti(DbType dbType, UpdateMode updateMode, Map entries, boolean shouldFail) { + public void testPutMultiGetMulti(MapType mapType, UpdateMode updateMode, Map entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap, Boolean>().keySet(true); Step> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.putMulti(Flux.fromIterable(entries.entrySet())).then(Mono.empty()), @@ -371,11 +369,11 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPutMulti") - public void testSetAllValuesGetMulti(DbType dbType, UpdateMode updateMode, Map entries, boolean shouldFail) { + public void testSetAllValuesGetMulti(MapType mapType, UpdateMode updateMode, Map entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap, Boolean>().keySet(true); Step> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> map .setAllValues(Flux.fromIterable(entries.entrySet())) .thenMany(map.getMulti(null, Flux.fromIterable(entries.keySet()))) @@ -397,11 +395,11 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPutMulti") - public void testSetAllValuesAndGetPrevious(DbType dbType, UpdateMode updateMode, Map entries, boolean shouldFail) { + public void testSetAllValuesAndGetPrevious(MapType mapType, UpdateMode updateMode, Map entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap, Boolean>().keySet(true); Step> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.setAllValuesAndGetPrevious(Flux.fromIterable(entries.entrySet())), @@ -424,11 +422,11 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPutMulti") - public void testSetGetMulti(DbType dbType, UpdateMode updateMode, Map entries, boolean shouldFail) { + public void testSetGetMulti(MapType mapType, UpdateMode updateMode, Map entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap, Boolean>().keySet(true); Step> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.set(entries).then(Mono.empty()), @@ -452,13 +450,13 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPutMulti") - public void testSetAndGetChanged(DbType dbType, + public void testSetAndGetChanged(MapType mapType, UpdateMode updateMode, Map entries, boolean shouldFail) { Step stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> { Mono removalMono; if (entries.isEmpty()) { @@ -485,11 +483,11 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPutMulti") - public void testSetAndGetPrevious(DbType dbType, UpdateMode updateMode, Map entries, boolean shouldFail) { + public void testSetAndGetPrevious(MapType mapType, UpdateMode updateMode, Map entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap, Boolean>().keySet(true); Step> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat(map.setAndGetPrevious(entries), map.setAndGetPrevious(entries)) .map(Map::entrySet) @@ -510,11 +508,11 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPutMulti") - public void testSetClearAndGetPreviousGet(DbType dbType, UpdateMode updateMode, Map entries, boolean shouldFail) { + public void testSetClearAndGetPreviousGet(MapType mapType, UpdateMode updateMode, Map entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap, Boolean>().keySet(true); Step> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat(map.set(entries).then(Mono.empty()), map.clearAndGetPrevious(), map.get(null)) .map(Map::entrySet) @@ -535,11 +533,11 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPutMulti") - public void testPutMultiGetAllValues(DbType dbType, UpdateMode updateMode, Map entries, boolean shouldFail) { + public void testPutMultiGetAllValues(MapType mapType, UpdateMode updateMode, Map entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap, Boolean>().keySet(true); Step> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.putMulti(Flux.fromIterable(entries.entrySet())).then(Mono.empty()), @@ -562,11 +560,11 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPutMulti") - public void testPutMultiGet(DbType dbType, UpdateMode updateMode, Map entries, boolean shouldFail) { + public void testPutMultiGet(MapType mapType, UpdateMode updateMode, Map entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap, Boolean>().keySet(true); Step> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.putMulti(Flux.fromIterable(entries.entrySet())).then(Mono.empty()), @@ -591,11 +589,11 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPutMulti") - public void testPutMultiGetAllStagesGet(DbType dbType, UpdateMode updateMode, Map entries, boolean shouldFail) { + public void testPutMultiGetAllStagesGet(MapType mapType, UpdateMode updateMode, Map entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap, Boolean>().keySet(true); Step> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.putMulti(Flux.fromIterable(entries.entrySet())).then(Mono.empty()), @@ -625,11 +623,11 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPutMulti") - public void testPutMultiIsEmpty(DbType dbType, UpdateMode updateMode, Map entries, boolean shouldFail) { + public void testPutMultiIsEmpty(MapType mapType, UpdateMode updateMode, Map entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap, Boolean>().keySet(true); Step stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.isEmpty(null), @@ -650,10 +648,10 @@ public class TestDictionaryMap { @ParameterizedTest @MethodSource("provideArgumentsPutMulti") - public void testPutMultiClear(DbType dbType, UpdateMode updateMode, Map entries, boolean shouldFail) { + public void testPutMultiClear(MapType mapType, UpdateMode updateMode, Map entries, boolean shouldFail) { Step stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) - .map(dict -> tempDatabaseMapDictionaryMap(dict, dbType, 5)) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) + .map(dict -> tempDatabaseMapDictionaryMap(dict, mapType, 5)) .flatMapMany(map -> Flux .concat( map.isEmpty(null), diff --git a/src/test/java/it/cavallium/dbengine/TestDictionaryMapDeep.java b/src/test/java/it/cavallium/dbengine/TestDictionaryMapDeep.java index 9e489d5..3e35f0f 100644 --- a/src/test/java/it/cavallium/dbengine/TestDictionaryMapDeep.java +++ b/src/test/java/it/cavallium/dbengine/TestDictionaryMapDeep.java @@ -1,5 +1,6 @@ package it.cavallium.dbengine; +import static it.cavallium.dbengine.DbTestUtils.BIG_STRING; import static it.cavallium.dbengine.DbTestUtils.ensureNoLeaks; import static it.cavallium.dbengine.DbTestUtils.newAllocator; import static it.cavallium.dbengine.DbTestUtils.destroyAllocator; @@ -38,7 +39,7 @@ import reactor.util.function.Tuple4; import reactor.util.function.Tuples; @TestMethodOrder(MethodOrderer.MethodName.class) -public class TestDictionaryMapDeep { +public abstract class TestDictionaryMapDeep { private TestAllocator allocator; @@ -46,7 +47,7 @@ public class TestDictionaryMapDeep { return System.getProperty("badkeys", "true").equalsIgnoreCase("true"); } - private static final String BIG_STRING = "012345678901234567890123456789"; + protected abstract TemporaryDbGenerator getTempDbGenerator(); private static Stream provideArgumentsSet() { var goodKeys = Set.of("12345"); @@ -171,7 +172,7 @@ public class TestDictionaryMapDeep { @MethodSource("provideArgumentsSet") public void testSetValueGetValue(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMap(map -> map .putValue(key, value) @@ -193,7 +194,7 @@ public class TestDictionaryMapDeep { Map value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> map .putValue(key, value) @@ -213,7 +214,7 @@ public class TestDictionaryMapDeep { public void testAtSetGetAllStagesGetAllValues(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap, Boolean>().keySet(true); Step> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map_ -> Flux.using( () -> map_, @@ -261,7 +262,7 @@ public class TestDictionaryMapDeep { @MethodSource({"provideArgumentsPut"}) public void testAtPutValueAtGetValue(UpdateMode updateMode, String key1, String key2, String value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMap(map -> map .at(null, key1).flatMap(v -> v.putValue(key2, value).doAfterTerminate(v::release)) @@ -280,7 +281,7 @@ public class TestDictionaryMapDeep { @MethodSource("provideArgumentsSet") public void testSetAndGetPrevious(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -304,7 +305,7 @@ public class TestDictionaryMapDeep { @MethodSource("provideArgumentsPut") public void testAtPutValueAndGetPrevious(UpdateMode updateMode, String key1, String key2, String value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -341,7 +342,7 @@ public class TestDictionaryMapDeep { @MethodSource("provideArgumentsSet") public void testSetValueRemoveAndGetPrevious(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -363,7 +364,7 @@ public class TestDictionaryMapDeep { @MethodSource("provideArgumentsPut") public void testAtPutValueRemoveAndGetPrevious(UpdateMode updateMode, String key1, String key2, String value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -401,7 +402,7 @@ public class TestDictionaryMapDeep { @MethodSource("provideArgumentsSet") public void testSetValueRemoveAndGetStatus(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -423,7 +424,7 @@ public class TestDictionaryMapDeep { @MethodSource("provideArgumentsPut") public void testAtPutValueRemoveAndGetStatus(UpdateMode updateMode, String key1, String key2, String value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -464,7 +465,7 @@ public class TestDictionaryMapDeep { return; } var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -506,7 +507,7 @@ public class TestDictionaryMapDeep { return; } var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -551,7 +552,7 @@ public class TestDictionaryMapDeep { if (updateMode != UpdateMode.ALLOW_UNSAFE && !isTestBadKeysEnabled()) { return; } - var stpVer = StepVerifier.create(tempDb(allocator, db -> tempDictionary(db, updateMode) + var stpVer = StepVerifier.create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux.concat( map.updateValue(key, old -> { @@ -590,7 +591,7 @@ public class TestDictionaryMapDeep { return; } var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -641,7 +642,7 @@ public class TestDictionaryMapDeep { @MethodSource("provideArgumentsSet") public void testSetAndGetChanged(UpdateMode updateMode, String key, Map value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -697,7 +698,7 @@ public class TestDictionaryMapDeep { public void testSetMultiGetMulti(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -725,7 +726,7 @@ public class TestDictionaryMapDeep { public void testSetAllValuesGetMulti(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> map .setAllValues(Flux.fromIterable(entries.entrySet())) @@ -751,7 +752,7 @@ public class TestDictionaryMapDeep { public void testSetAllValuesAndGetPrevious(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -777,7 +778,7 @@ public class TestDictionaryMapDeep { public void testSetGetMulti(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -804,7 +805,7 @@ public class TestDictionaryMapDeep { @MethodSource("provideArgumentsSetMulti") public void testSetAndGetStatus(UpdateMode updateMode, Map> entries, boolean shouldFail) { Step stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> { Mono removalMono; @@ -836,7 +837,7 @@ public class TestDictionaryMapDeep { public void testSetAndGetPrevious(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -864,7 +865,7 @@ public class TestDictionaryMapDeep { public void testSetClearAndGetPreviousGet(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat(map.set(entries).then(Mono.empty()), map.clearAndGetPrevious(), map.get(null)) @@ -889,7 +890,7 @@ public class TestDictionaryMapDeep { public void testSetMultiGetAllValues(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -915,7 +916,7 @@ public class TestDictionaryMapDeep { public void testSetMultiGet(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -943,7 +944,7 @@ public class TestDictionaryMapDeep { public void testSetMultiGetAllStagesGet(UpdateMode updateMode, Map> entries, boolean shouldFail) { var remainingEntries = new ConcurrentHashMap>, Boolean>().keySet(true); Step>> stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -975,7 +976,7 @@ public class TestDictionaryMapDeep { @MethodSource("provideArgumentsSetMulti") public void testSetMultiIsEmpty(UpdateMode updateMode, Map> entries, boolean shouldFail) { Step stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( @@ -997,7 +998,7 @@ public class TestDictionaryMapDeep { @MethodSource("provideArgumentsSetMulti") public void testSetMultiClear(UpdateMode updateMode, Map> entries, boolean shouldFail) { Step stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMap(dict, 5, 6)) .flatMapMany(map -> Flux .concat( diff --git a/src/test/java/it/cavallium/dbengine/TestDictionaryMapDeepHashMap.java b/src/test/java/it/cavallium/dbengine/TestDictionaryMapDeepHashMap.java index 385f5da..5b894fa 100644 --- a/src/test/java/it/cavallium/dbengine/TestDictionaryMapDeepHashMap.java +++ b/src/test/java/it/cavallium/dbengine/TestDictionaryMapDeepHashMap.java @@ -1,5 +1,6 @@ package it.cavallium.dbengine; +import static it.cavallium.dbengine.DbTestUtils.BIG_STRING; import static it.cavallium.dbengine.DbTestUtils.destroyAllocator; import static it.cavallium.dbengine.DbTestUtils.ensureNoLeaks; import static it.cavallium.dbengine.DbTestUtils.newAllocator; @@ -31,7 +32,7 @@ import reactor.util.function.Tuple3; import reactor.util.function.Tuple4; import reactor.util.function.Tuples; -public class TestDictionaryMapDeepHashMap { +public abstract class TestDictionaryMapDeepHashMap { private TestAllocator allocator; @@ -39,13 +40,7 @@ public class TestDictionaryMapDeepHashMap { return System.getProperty("badkeys", "true").equalsIgnoreCase("true"); } - private static final String BIG_STRING - = "01234567890123456789012345678901234567890123456789012345678901234567890123456789" - + "01234567890123456789012345678901234567890123456789012345678901234567890123456789" - + "01234567890123456789012345678901234567890123456789012345678901234567890123456789" - + "01234567890123456789012345678901234567890123456789012345678901234567890123456789" - + "01234567890123456789012345678901234567890123456789012345678901234567890123456789" - + "01234567890123456789012345678901234567890123456789012345678901234567890123456789"; + protected abstract TemporaryDbGenerator getTempDbGenerator(); private static Stream provideArgumentsPut() { var goodKeys1 = Set.of("12345", "zebra"); @@ -118,7 +113,7 @@ public class TestDictionaryMapDeepHashMap { @MethodSource("provideArgumentsPut") public void testAtPutValueGetAllValues(UpdateMode updateMode, String key1, String key2, String value, boolean shouldFail) { var stpVer = StepVerifier - .create(tempDb(allocator, db -> tempDictionary(db, updateMode) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempDictionary(db, updateMode) .map(dict -> tempDatabaseMapDictionaryDeepMapHashMap(dict, 5)) .flatMapMany(map -> map .at(null, key1).flatMap(v -> v.putValue(key2, value).doAfterTerminate(v::release)) diff --git a/src/test/java/it/cavallium/dbengine/TestLLDictionaryLeaks.java b/src/test/java/it/cavallium/dbengine/TestLLDictionaryLeaks.java index b621f2c..1d052c7 100644 --- a/src/test/java/it/cavallium/dbengine/TestLLDictionaryLeaks.java +++ b/src/test/java/it/cavallium/dbengine/TestLLDictionaryLeaks.java @@ -30,23 +30,25 @@ import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; import reactor.core.scheduler.Schedulers; -public class TestLLDictionaryLeaks { +public abstract class TestLLDictionaryLeaks { private TestAllocator allocator; private TempDb tempDb; private LLKeyValueDatabase db; + protected abstract TemporaryDbGenerator getTempDbGenerator(); + @BeforeEach public void beforeEach() { this.allocator = newAllocator(); ensureNoLeaks(allocator.allocator(), false); - tempDb = Objects.requireNonNull(DbTestUtils.openTempDb(allocator).block(), "TempDB"); + tempDb = Objects.requireNonNull(getTempDbGenerator().openTempDb(allocator).block(), "TempDB"); db = tempDb.db(); } @AfterEach public void afterEach() { - DbTestUtils.closeTempDb(tempDb).block(); + getTempDbGenerator().closeTempDb(tempDb).block(); ensureNoLeaks(allocator.allocator(), true); destroyAllocator(allocator); } diff --git a/src/test/java/it/cavallium/dbengine/TestLocalDictionary.java b/src/test/java/it/cavallium/dbengine/TestLocalDictionary.java new file mode 100644 index 0000000..21adef2 --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/TestLocalDictionary.java @@ -0,0 +1,11 @@ +package it.cavallium.dbengine; + +public class TestLocalDictionary extends TestDictionary { + + private static final TemporaryDbGenerator GENERATOR = new LocalTemporaryDbGenerator(); + + @Override + protected TemporaryDbGenerator getTempDbGenerator() { + return GENERATOR; + } +} diff --git a/src/test/java/it/cavallium/dbengine/TestLocalDictionaryMap.java b/src/test/java/it/cavallium/dbengine/TestLocalDictionaryMap.java new file mode 100644 index 0000000..e020f7b --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/TestLocalDictionaryMap.java @@ -0,0 +1,11 @@ +package it.cavallium.dbengine; + +public class TestLocalDictionaryMap extends TestDictionaryMap { + + private static final TemporaryDbGenerator GENERATOR = new LocalTemporaryDbGenerator(); + + @Override + protected TemporaryDbGenerator getTempDbGenerator() { + return GENERATOR; + } +} diff --git a/src/test/java/it/cavallium/dbengine/TestLocalDictionaryMapDeep.java b/src/test/java/it/cavallium/dbengine/TestLocalDictionaryMapDeep.java new file mode 100644 index 0000000..1eb81a3 --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/TestLocalDictionaryMapDeep.java @@ -0,0 +1,11 @@ +package it.cavallium.dbengine; + +public class TestLocalDictionaryMapDeep extends TestDictionaryMapDeep { + + private static final TemporaryDbGenerator GENERATOR = new LocalTemporaryDbGenerator(); + + @Override + protected TemporaryDbGenerator getTempDbGenerator() { + return GENERATOR; + } +} diff --git a/src/test/java/it/cavallium/dbengine/TestLocalDictionaryMapDeepHashMap.java b/src/test/java/it/cavallium/dbengine/TestLocalDictionaryMapDeepHashMap.java new file mode 100644 index 0000000..62b1ba5 --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/TestLocalDictionaryMapDeepHashMap.java @@ -0,0 +1,11 @@ +package it.cavallium.dbengine; + +public class TestLocalDictionaryMapDeepHashMap extends TestDictionaryMapDeepHashMap { + + private static final TemporaryDbGenerator GENERATOR = new LocalTemporaryDbGenerator(); + + @Override + protected TemporaryDbGenerator getTempDbGenerator() { + return GENERATOR; + } +} diff --git a/src/test/java/it/cavallium/dbengine/TestLocalLLDictionaryLeaks.java b/src/test/java/it/cavallium/dbengine/TestLocalLLDictionaryLeaks.java new file mode 100644 index 0000000..90d7c35 --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/TestLocalLLDictionaryLeaks.java @@ -0,0 +1,11 @@ +package it.cavallium.dbengine; + +public class TestLocalLLDictionaryLeaks extends TestLLDictionaryLeaks { + + private static final TemporaryDbGenerator GENERATOR = new LocalTemporaryDbGenerator(); + + @Override + protected TemporaryDbGenerator getTempDbGenerator() { + return GENERATOR; + } +} diff --git a/src/test/java/it/cavallium/dbengine/TestLocalSingletons.java b/src/test/java/it/cavallium/dbengine/TestLocalSingletons.java new file mode 100644 index 0000000..14ab7bb --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/TestLocalSingletons.java @@ -0,0 +1,11 @@ +package it.cavallium.dbengine; + +public class TestLocalSingletons extends TestSingletons { + + private static final TemporaryDbGenerator GENERATOR = new LocalTemporaryDbGenerator(); + + @Override + protected TemporaryDbGenerator getTempDbGenerator() { + return GENERATOR; + } +} diff --git a/src/test/java/it/cavallium/dbengine/TestMemoryDictionary.java b/src/test/java/it/cavallium/dbengine/TestMemoryDictionary.java new file mode 100644 index 0000000..97d601f --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/TestMemoryDictionary.java @@ -0,0 +1,11 @@ +package it.cavallium.dbengine; + +public class TestMemoryDictionary extends TestDictionary { + + private static final TemporaryDbGenerator GENERATOR = new MemoryTemporaryDbGenerator(); + + @Override + protected TemporaryDbGenerator getTempDbGenerator() { + return GENERATOR; + } +} diff --git a/src/test/java/it/cavallium/dbengine/TestMemoryDictionaryMap.java b/src/test/java/it/cavallium/dbengine/TestMemoryDictionaryMap.java new file mode 100644 index 0000000..8f74db0 --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/TestMemoryDictionaryMap.java @@ -0,0 +1,11 @@ +package it.cavallium.dbengine; + +public class TestMemoryDictionaryMap extends TestDictionaryMap { + + private static final TemporaryDbGenerator GENERATOR = new MemoryTemporaryDbGenerator(); + + @Override + protected TemporaryDbGenerator getTempDbGenerator() { + return GENERATOR; + } +} diff --git a/src/test/java/it/cavallium/dbengine/TestMemoryLLDictionaryLeaks.java b/src/test/java/it/cavallium/dbengine/TestMemoryLLDictionaryLeaks.java new file mode 100644 index 0000000..8bce79f --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/TestMemoryLLDictionaryLeaks.java @@ -0,0 +1,11 @@ +package it.cavallium.dbengine; + +public class TestMemoryLLDictionaryLeaks extends TestLLDictionaryLeaks { + + private static final TemporaryDbGenerator GENERATOR = new MemoryTemporaryDbGenerator(); + + @Override + protected TemporaryDbGenerator getTempDbGenerator() { + return GENERATOR; + } +} diff --git a/src/test/java/it/cavallium/dbengine/TestMemorySingletons.java b/src/test/java/it/cavallium/dbengine/TestMemorySingletons.java new file mode 100644 index 0000000..5ce8116 --- /dev/null +++ b/src/test/java/it/cavallium/dbengine/TestMemorySingletons.java @@ -0,0 +1,11 @@ +package it.cavallium.dbengine; + +public class TestMemorySingletons extends TestSingletons { + + private static final TemporaryDbGenerator GENERATOR = new MemoryTemporaryDbGenerator(); + + @Override + protected TemporaryDbGenerator getTempDbGenerator() { + return GENERATOR; + } +} diff --git a/src/test/java/it/cavallium/dbengine/TestSingletons.java b/src/test/java/it/cavallium/dbengine/TestSingletons.java index cbc5653..b277ad8 100644 --- a/src/test/java/it/cavallium/dbengine/TestSingletons.java +++ b/src/test/java/it/cavallium/dbengine/TestSingletons.java @@ -20,10 +20,12 @@ import org.junit.jupiter.params.provider.ValueSource; import reactor.core.publisher.Mono; import reactor.test.StepVerifier; -public class TestSingletons { +public abstract class TestSingletons { private TestAllocator allocator; + protected abstract TemporaryDbGenerator getTempDbGenerator(); + private static Stream provideNumberWithRepeats() { return Stream.of( Arguments.of(Integer.MIN_VALUE, 2), @@ -57,7 +59,7 @@ public class TestSingletons { @Test public void testCreateInteger() { StepVerifier - .create(tempDb(allocator, db -> tempInt(db, "test", 0) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempInt(db, "test", 0) .flatMap(dbInt -> dbInt.get(null)) .then() )) @@ -67,7 +69,7 @@ public class TestSingletons { @Test public void testCreateLong() { StepVerifier - .create(tempDb(allocator, db -> tempLong(db, "test", 0) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempLong(db, "test", 0) .flatMap(dbLong -> dbLong.get(null)) .then() )) @@ -78,7 +80,7 @@ public class TestSingletons { @ValueSource(ints = {Integer.MIN_VALUE, -192, -2, -1, 0, 1, 2, 1292, Integer.MAX_VALUE}) public void testDefaultValueInteger(int i) { StepVerifier - .create(tempDb(allocator, db -> tempInt(db, "test", i) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempInt(db, "test", i) .flatMap(dbInt -> dbInt.get(null)) )) .expectNext(i) @@ -89,7 +91,7 @@ public class TestSingletons { @ValueSource(longs = {Long.MIN_VALUE, -192, -2, -1, 0, 1, 2, 1292, Long.MAX_VALUE}) public void testDefaultValueLong(long i) { StepVerifier - .create(tempDb(allocator, db -> tempLong(db, "test", i) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempLong(db, "test", i) .flatMap(dbLong -> dbLong.get(null)) )) .expectNext(i) @@ -100,7 +102,7 @@ public class TestSingletons { @MethodSource("provideNumberWithRepeats") public void testSetInteger(Integer i, Integer repeats) { StepVerifier - .create(tempDb(allocator, db -> tempInt(db, "test", 0) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempInt(db, "test", 0) .flatMap(dbInt -> Mono .defer(() -> dbInt.set((int) System.currentTimeMillis())) .repeat(repeats) @@ -115,7 +117,7 @@ public class TestSingletons { @MethodSource("provideLongNumberWithRepeats") public void testSetLong(Long i, Integer repeats) { StepVerifier - .create(tempDb(allocator, db -> tempLong(db, "test", 0) + .create(tempDb(getTempDbGenerator(), allocator, db -> tempLong(db, "test", 0) .flatMap(dbLong -> Mono .defer(() -> dbLong.set(System.currentTimeMillis())) .repeat(repeats)