From 189d1181052fc014830ac53d0090d7f3cfbc36aa Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Tue, 14 Feb 2023 00:46:26 +0100 Subject: Fuzz test environment is parametrized by VersionedMapStoreBuilder configurations --- .../store/map/tests/fuzz/CommitFuzzTest.java | 34 +++++++-------- .../map/tests/fuzz/ContentEqualsFuzzTest.java | 37 ++++++++-------- .../store/map/tests/fuzz/DiffCursorFuzzTest.java | 50 ++++++++++------------ .../store/map/tests/fuzz/MultiThreadFuzzTest.java | 42 +++++++++--------- .../map/tests/fuzz/MultiThreadTestRunnable.java | 22 +++++++--- .../store/map/tests/fuzz/MutableFuzzTest.java | 35 +++++++-------- .../fuzz/MutableImmutableCompareFuzzTest.java | 2 +- .../store/map/tests/fuzz/RestoreFuzzTest.java | 32 +++++++------- .../store/map/tests/fuzz/SharedStoreFuzzTest.java | 2 +- .../map/tests/fuzz/utils/FuzzTestCollections.java | 40 +++++++++++++++-- 10 files changed, 161 insertions(+), 135 deletions(-) (limited to 'subprojects/store') diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java index b61152f5..14a9e2e0 100644 --- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java +++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java @@ -11,10 +11,8 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -import tools.refinery.store.map.ContinousHashProvider; import tools.refinery.store.map.VersionedMapStore; -import tools.refinery.store.map.VersionedMapStoreImpl; -import tools.refinery.store.map.internal.VersionedMapImpl; +import tools.refinery.store.map.VersionedMapStoreBuilder; import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils; import tools.refinery.store.map.tests.utils.MapTestEnvironment; @@ -23,13 +21,11 @@ import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*; class CommitFuzzTest { private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, - boolean nullDefault, int commitFrequency, - boolean evilHash) { + boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder builder) { String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault); - ContinousHashProvider chp = MapTestEnvironment.prepareHashProvider(evilHash); - VersionedMapStore store = new VersionedMapStoreImpl<>(chp, values[0]); - VersionedMapImpl sut = (VersionedMapImpl) store.createMap(); + VersionedMapStore store = builder.setDefaultValue(values[0]).buildOne(); + var sut = store.createMap(); MapTestEnvironment e = new MapTestEnvironment<>(sut); Random r = new Random(seed); @@ -52,37 +48,37 @@ class CommitFuzzTest { } MapTestEnvironment.printStatus(scenario, index, steps, null); if (index % commitFrequency == 0) { - e.sut.commit(); + e.commit(); } } } - @ParameterizedTest(name = "Commit {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5} " + - "seed={6} evil-hash={7}") + public static final String title = "Commit {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5} " + + "seed={6} config={7}"; + + @ParameterizedTest(name = title) @MethodSource @Timeout(value = 10) @Tag("fuzz") void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency, - int seed, - boolean evilHash) { + int seed, VersionedMapStoreBuilder builder) { runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues, - nullDefault, commitFrequency, evilHash); + nullDefault, commitFrequency, builder); } static Stream parametrizedFastFuzz() { return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions, - commitFrequencyOptions, randomSeedOptions, evilHashOptions); + commitFrequencyOptions, randomSeedOptions, storeConfigs); } - @ParameterizedTest(name = "Commit {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5} " + - "seed={6} evil-hash={7}") + @ParameterizedTest(name = title) @MethodSource @Tag("fuzz") @Tag("slow") void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency, - int seed, boolean evilHash) { + int seed, VersionedMapStoreBuilder builder) { runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues, - nullDefault, commitFrequency, evilHash); + nullDefault, commitFrequency, builder); } static Stream parametrizedSlowFuzz() { diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java index c17b0a95..b462ed40 100644 --- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java +++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java @@ -6,7 +6,6 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import tools.refinery.store.map.*; -import tools.refinery.store.map.internal.VersionedMapImpl; import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils; import tools.refinery.store.map.tests.utils.MapTestEnvironment; @@ -22,20 +21,19 @@ import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*; class ContentEqualsFuzzTest { private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, - boolean nullDefault, int commitFrequency, - boolean evilHash) { + boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder builder) { String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault); - ContinousHashProvider chp = MapTestEnvironment.prepareHashProvider(evilHash); + Random r = new Random(seed); - iterativeRandomPutsAndCommitsThenCompare(scenario, chp, steps, maxKey, values, r, commitFrequency); + iterativeRandomPutsAndCommitsThenCompare(scenario, builder, steps, maxKey, values, r, commitFrequency); } - private void iterativeRandomPutsAndCommitsThenCompare(String scenario, ContinousHashProvider chp, + private void iterativeRandomPutsAndCommitsThenCompare(String scenario, VersionedMapStoreBuilder builder, int steps, int maxKey, String[] values, Random r, int commitFrequency) { - VersionedMapStore store1 = new VersionedMapStoreImpl<>(chp, values[0]); + VersionedMapStore store1 = builder.setDefaultValue(values[0]).buildOne(); VersionedMap sut1 = store1.createMap(); // Fill one map @@ -65,7 +63,7 @@ class ContentEqualsFuzzTest { // Randomize the order of the content Collections.shuffle(content, r); - VersionedMapStore store2 = new VersionedMapStoreImpl<>(chp, values[0]); + VersionedMapStore store2 = builder.setDefaultValue(values[0]).buildOne(); VersionedMap sut2 = store2.createMap(); int index2 = 1; for (SimpleEntry entry : content) { @@ -75,38 +73,39 @@ class ContentEqualsFuzzTest { } // Check the integrity of the maps - ((VersionedMapImpl) sut1).checkIntegrity(); - ((VersionedMapImpl) sut2).checkIntegrity(); + sut1.checkIntegrity(); + sut2.checkIntegrity(); // Compare the two maps MapTestEnvironment.compareTwoMaps(scenario, sut1, sut2); } - @ParameterizedTest(name = "Compare {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit frequency={5}" + - "seed={6} evil-hash={7}") + public static final String title = "Compare {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit frequency={5}" + + "seed={6} config={7}"; + + @ParameterizedTest(name = title) @MethodSource @Timeout(value = 10) @Tag("fuzz") void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency, - int seed, boolean evilHash) { + int seed, VersionedMapStoreBuilder builder) { runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues, - nullDefault, commitFrequency, evilHash); + nullDefault, commitFrequency, builder); } static Stream parametrizedFastFuzz() { return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions, - commitFrequencyOptions, randomSeedOptions, evilHashOptions); + commitFrequencyOptions, randomSeedOptions, storeConfigs); } - @ParameterizedTest(name = "Compare {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit frequency={5}" + - "seed={6} evil-hash={7}") + @ParameterizedTest(name = title) @MethodSource @Tag("fuzz") @Tag("slow") void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, int commitFrequency, - int seed, boolean evilHash) { + int seed, VersionedMapStoreBuilder builder) { runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues, - defaultNull, commitFrequency, evilHash); + defaultNull, commitFrequency, builder); } static Stream parametrizedSlowFuzz() { diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java index 90aa8e01..bf409a74 100644 --- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java +++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java @@ -1,33 +1,26 @@ package tools.refinery.store.map.tests.fuzz; -import static org.junit.jupiter.api.Assertions.fail; -import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*; - -import java.util.Random; -import java.util.stream.Stream; - import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Timeout; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; - -import tools.refinery.store.map.ContinousHashProvider; -import tools.refinery.store.map.DiffCursor; -import tools.refinery.store.map.VersionedMapStore; -import tools.refinery.store.map.VersionedMapStoreImpl; -import tools.refinery.store.map.internal.VersionedMapImpl; +import tools.refinery.store.map.*; import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils; import tools.refinery.store.map.tests.utils.MapTestEnvironment; +import java.util.Random; +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.fail; +import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*; + class DiffCursorFuzzTest { private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, - boolean nullDefault, int commitFrequency, - boolean evilHash) { + boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder builder) { String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault); - ContinousHashProvider chp = MapTestEnvironment.prepareHashProvider(evilHash); - VersionedMapStore store = new VersionedMapStoreImpl<>(chp, values[0]); + VersionedMapStore store = builder.setDefaultValue(values[0]).buildOne(); iterativeRandomPutsAndCommitsThenDiffCursor(scenario, store, steps, maxKey, values, seed, commitFrequency); } @@ -35,7 +28,7 @@ class DiffCursorFuzzTest { int steps, int maxKey, String[] values, int seed, int commitFrequency) { // 1. build a map with versions Random r = new Random(seed); - VersionedMapImpl versioned = (VersionedMapImpl) store.createMap(); + VersionedMap versioned = store.createMap(); int largestCommit = -1; for (int i = 0; i < steps; i++) { @@ -56,7 +49,7 @@ class DiffCursorFuzzTest { System.out.println(scenario + ":" + index + "/" + steps + " building finished"); } // 2. create a non-versioned map, - VersionedMapImpl moving = (VersionedMapImpl) store.createMap(); + VersionedMap moving = store.createMap(); Random r2 = new Random(seed + 1); final int diffTravelFrequency = commitFrequency * 2; @@ -88,31 +81,32 @@ class DiffCursorFuzzTest { } - @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " + - "commit frequency={5} seed={6} evil-hash={7}") + public static final String title = "DiffCursor {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " + + "commit frequency={5} seed={6} config={7}"; + + @ParameterizedTest(name = title) @MethodSource @Timeout(value = 10) @Tag("fuzz") void parametrizedFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency, - int seed, boolean evilHash) { + int seed, VersionedMapStoreBuilder builder) { runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, - noKeys, noValues, nullDefault, commitFrequency, evilHash); + noKeys, noValues, nullDefault, commitFrequency, builder); } static Stream parametrizedFuzz() { - return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions, - commitFrequencyOptions, randomSeedOptions, evilHashOptions); + return FuzzTestUtils.permutationWithSize(new Object[]{100}, keyCounts, valueCounts, nullDefaultOptions, + commitFrequencyOptions, randomSeedOptions, storeConfigs); } - @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " + - "commit frequency={5} seed={6} evil-hash={7}") + @ParameterizedTest(name = title) @MethodSource @Tag("fuzz") @Tag("slow") void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency, - int seed, boolean evilHash) { + int seed, VersionedMapStoreBuilder builder) { runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues, - nullDefault, commitFrequency, evilHash); + nullDefault, commitFrequency, builder); } static Stream parametrizedSlowFuzz() { diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java index 9325a938..ec2224b4 100644 --- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java +++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java @@ -15,27 +15,24 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -import tools.refinery.store.map.ContinousHashProvider; import tools.refinery.store.map.VersionedMapStore; -import tools.refinery.store.map.VersionedMapStoreImpl; +import tools.refinery.store.map.VersionedMapStoreBuilder; import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils; import tools.refinery.store.map.tests.utils.MapTestEnvironment; class MultiThreadFuzzTest { - public static final int noThreads = 32; + public static final int noThreads = 10; - private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, - boolean nullDefault, int commitFrequency, - boolean evilHash) { + private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder builder) { String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault); - ContinousHashProvider chp = MapTestEnvironment.prepareHashProvider(evilHash); - VersionedMapStore store = new VersionedMapStoreImpl<>(chp, values[0]); + VersionedMapStore store = builder.setDefaultValue(values[0]).buildOne(); // initialize runnables MultiThreadTestRunnable[] runnables = new MultiThreadTestRunnable[noThreads]; for (int i = 0; i < noThreads; i++) { - runnables[i] = new MultiThreadTestRunnable(scenario + "-T" + (i + 1), store, steps, maxKey, values, seed, commitFrequency); + runnables[i] = new MultiThreadTestRunnable(scenario + "-T" + (i + 1), store, steps, maxKey, values, seed + , commitFrequency); } // initialize threads @@ -46,7 +43,8 @@ class MultiThreadFuzzTest { // start threads; for (int i = 0; i < noThreads; i++) { - threads[i].start(); + runnables[i].run(); + //threads[i].start(); } // wait all the threads; @@ -67,32 +65,32 @@ class MultiThreadFuzzTest { assertEquals(Collections.EMPTY_LIST, errors); } - @ParameterizedTest(name = "MultiThread {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit " + - "frequency={5} seed={6} evil-hash={7}") + static final String title = "MultiThread {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit " + + "frequency={5} seed={6} config={7}"; + + @ParameterizedTest(name = title) @MethodSource @Timeout(value = 10) @Tag("fuzz") - void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, int commitFrequency, - int seed, boolean evilHash) { + void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, + int commitFrequency, int seed, VersionedMapStoreBuilder builder) { runFuzzTest("MultiThreadS" + steps + "K" + noKeys + "V" + noValues + defaultNull + "CF" + commitFrequency + - "s" + seed, seed, steps, noKeys, noValues, defaultNull, commitFrequency, evilHash); + "s" + seed, seed, steps, noKeys, noValues, defaultNull, commitFrequency, builder); } static Stream parametrizedFastFuzz() { return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions, - new Object[]{10, 100}, randomSeedOptions, - evilHashOptions); + new Object[]{10, 100}, randomSeedOptions, storeConfigs); } - @ParameterizedTest(name = "MultiThread {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit " + - "frequency={5} seed={6} evil-hash={7}") + @ParameterizedTest(name = title) @MethodSource @Tag("fuzz") @Tag("slow") - void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency, int seed, - boolean evilHash) { + void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, + int commitFrequency, int seed, VersionedMapStoreBuilder builder) { runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues, - nullDefault, commitFrequency, evilHash); + nullDefault, commitFrequency, builder); } static Stream parametrizedSlowFuzz() { diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadTestRunnable.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadTestRunnable.java index 4415e4e5..f449ca97 100644 --- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadTestRunnable.java +++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadTestRunnable.java @@ -8,8 +8,8 @@ import java.util.List; import java.util.Map; import java.util.Random; +import tools.refinery.store.map.VersionedMap; import tools.refinery.store.map.VersionedMapStore; -import tools.refinery.store.map.internal.VersionedMapImpl; import tools.refinery.store.map.tests.utils.MapTestEnvironment; public class MultiThreadTestRunnable implements Runnable { @@ -45,9 +45,17 @@ public class MultiThreadTestRunnable implements Runnable { @Override public void run() { + try{ + task(); + } catch(Exception e) { + e.printStackTrace(); + } + } + + private void task() { // 1. build a map with versions Random r = new Random(seed); - VersionedMapImpl versioned = (VersionedMapImpl) store.createMap(); + VersionedMap versioned = store.createMap(); Map index2Version = new HashMap<>(); for (int i = 0; i < steps; i++) { @@ -67,7 +75,7 @@ public class MultiThreadTestRunnable implements Runnable { MapTestEnvironment.printStatus(scenario, index, steps, "building"); } // 2. create a non-versioned - VersionedMapImpl reference = (VersionedMapImpl) store.createMap(); + VersionedMap reference = store.createMap(); r = new Random(seed); Random r2 = new Random(seed + 1); @@ -84,13 +92,17 @@ public class MultiThreadTestRunnable implements Runnable { // go back to an existing state and compare to the reference if (index % (commitFrequency) == 0) { versioned.restore(index2Version.get(i)); - MapTestEnvironment.compareTwoMaps(scenario + ":" + index, reference, versioned, errors); + MapTestEnvironment.compareTwoMaps(scenario + ":" + index, reference, versioned, null); // go back to a random state (probably created by another thread) List states = new ArrayList<>(store.getStates()); + states.sort(Long::compare); Collections.shuffle(states, r2); for (Long state : states.subList(0, Math.min(states.size(), 100))) { - versioned.restore(state); + long x = state; + versioned.restore(x); + var clean = store.createMap(x); + MapTestEnvironment.compareTwoMaps(scenario + ":" + index, clean, versioned, null); } versioned.restore(index2Version.get(i)); } diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java index ab37ef83..bdf72ce4 100644 --- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java +++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java @@ -12,21 +12,17 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -import tools.refinery.store.map.ContinousHashProvider; -import tools.refinery.store.map.VersionedMapStore; -import tools.refinery.store.map.VersionedMapStoreImpl; -import tools.refinery.store.map.internal.VersionedMapImpl; +import tools.refinery.store.map.*; import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils; import tools.refinery.store.map.tests.utils.MapTestEnvironment; class MutableFuzzTest { private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, - boolean nullDefault, boolean evilHash) { + boolean nullDefault, VersionedMapStoreBuilder builder) { String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault); - ContinousHashProvider chp = MapTestEnvironment.prepareHashProvider(evilHash); - VersionedMapStore store = new VersionedMapStoreImpl<>(chp, values[0]); - VersionedMapImpl sut = (VersionedMapImpl) store.createMap(); + VersionedMapStore store = builder.setDefaultValue(values[0]).buildOne(); + VersionedMap sut = store.createMap(); MapTestEnvironment e = new MapTestEnvironment<>(sut); Random r = new Random(seed); @@ -52,33 +48,34 @@ class MutableFuzzTest { } } - @ParameterizedTest(name = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} seed={5} " + - "evil-hash={6}") + final String title = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} seed={5} " + + "config={6}"; + + @ParameterizedTest(name = title) @MethodSource @Timeout(value = 10) @Tag("fuzz") void parametrizedFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, int seed, - boolean evilHash) { + VersionedMapStoreBuilder builder) { runFuzzTest( - "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed + "H" + (evilHash ? "Evil" : "Normal"), - seed, steps, noKeys, noValues, defaultNull, evilHash); + "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, + seed, steps, noKeys, noValues, defaultNull, builder); } static Stream parametrizedFuzz() { return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions, - randomSeedOptions, evilHashOptions); + randomSeedOptions, storeConfigs); } - @ParameterizedTest(name = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} seed={5} " + - "evil-hash={6}") + @ParameterizedTest(name = title) @MethodSource @Tag("fuzz") @Tag("slow") void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int seed, - boolean evilHash) { + VersionedMapStoreBuilder builder) { runFuzzTest( - "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed + "H" + (evilHash ? "Evil" : "Normal"), - seed, steps, noKeys, noValues, nullDefault, evilHash); + "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, + seed, steps, noKeys, noValues, nullDefault, builder); } static Stream parametrizedSlowFuzz() { diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableImmutableCompareFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableImmutableCompareFuzzTest.java index b58b06f9..cee15fe1 100644 --- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableImmutableCompareFuzzTest.java +++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableImmutableCompareFuzzTest.java @@ -71,7 +71,7 @@ class MutableImmutableCompareFuzzTest { static Stream parametrizedFastFuzz() { return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions, - commitFrequencyOptions, randomSeedOptions, evilHashOptions); + commitFrequencyOptions, randomSeedOptions, new Object[]{false, true}); } @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " + diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java index 77b26c41..568aaac9 100644 --- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java +++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java @@ -14,9 +14,7 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -import tools.refinery.store.map.ContinousHashProvider; -import tools.refinery.store.map.VersionedMapStore; -import tools.refinery.store.map.VersionedMapStoreImpl; +import tools.refinery.store.map.*; import tools.refinery.store.map.internal.VersionedMapImpl; import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils; import tools.refinery.store.map.tests.utils.MapTestEnvironment; @@ -24,11 +22,10 @@ import tools.refinery.store.map.tests.utils.MapTestEnvironment; class RestoreFuzzTest { private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, - boolean evilHash) { + VersionedMapStoreBuilder builder) { String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault); - ContinousHashProvider chp = MapTestEnvironment.prepareHashProvider(evilHash); - VersionedMapStore store = new VersionedMapStoreImpl<>(chp, values[0]); + VersionedMapStore store = builder.setDefaultValue(values[0]).buildOne(); iterativeRandomPutsAndCommitsThenRestore(scenario, store, steps, maxKey, values, seed, commitFrequency); } @@ -37,7 +34,7 @@ class RestoreFuzzTest { int steps, int maxKey, String[] values, int seed, int commitFrequency) { // 1. build a map with versions Random r = new Random(seed); - VersionedMapImpl versioned = (VersionedMapImpl) store.createMap(); + VersionedMap versioned = store.createMap(); Map index2Version = new HashMap<>(); for (int i = 0; i < steps; i++) { @@ -57,7 +54,7 @@ class RestoreFuzzTest { MapTestEnvironment.printStatus(scenario, index, steps, "building"); } // 2. create a non-versioned and - VersionedMapImpl reference = (VersionedMapImpl) store.createMap(); + VersionedMap reference = store.createMap(); r = new Random(seed); for (int i = 0; i < steps; i++) { @@ -79,31 +76,32 @@ class RestoreFuzzTest { } - @ParameterizedTest(name = "Restore {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5}" + - " seed={6} evil-hash={7}") + public static final String title = "Commit {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5} " + + "seed={6} config={7}"; + + @ParameterizedTest(name = title) @MethodSource @Timeout(value = 10) @Tag("smoke") void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency, - int seed, boolean evilHash) { + int seed, VersionedMapStoreBuilder builder) { runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues, - nullDefault, commitFrequency, evilHash); + nullDefault, commitFrequency, builder); } static Stream parametrizedFastFuzz() { return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions, - commitFrequencyOptions, randomSeedOptions, evilHashOptions); + commitFrequencyOptions, randomSeedOptions, storeConfigs); } - @ParameterizedTest(name = "Restore {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5}" + - " seed={6} evil-hash={7}") + @ParameterizedTest(name = title) @MethodSource @Tag("smoke") @Tag("slow") void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency, - int seed, boolean evilHash) { + int seed, VersionedMapStoreBuilder builder) { runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues, - nullDefault, commitFrequency, evilHash); + nullDefault, commitFrequency, builder); } static Stream parametrizedSlowFuzz() { diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SharedStoreFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SharedStoreFuzzTest.java index 4462c55b..0544687a 100644 --- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SharedStoreFuzzTest.java +++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SharedStoreFuzzTest.java @@ -96,7 +96,7 @@ class SharedStoreFuzzTest { static Stream parametrizedFastFuzz() { return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions, - commitFrequencyOptions, randomSeedOptions, evilHashOptions); + commitFrequencyOptions, randomSeedOptions, new Object[]{false, true}); } @ParameterizedTest(name = "Shared Store {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit " + diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java index add4ca5d..fb6b28d8 100644 --- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java +++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java @@ -1,11 +1,43 @@ package tools.refinery.store.map.tests.fuzz.utils; +import tools.refinery.store.map.VersionedMapStoreBuilder; +import tools.refinery.store.map.tests.utils.MapTestEnvironment; + public final class FuzzTestCollections { public static final Object[] stepCounts = {FuzzTestUtils.FAST_STEP_COUNT}; - public static final Object[] keyCounts = {3, 32, 32 * 32}; + public static final Object[] keyCounts = {1, 32, 32 * 32}; public static final Object[] valueCounts = {2, 3}; public static final Object[] nullDefaultOptions = {false, true}; - public static final Object[] commitFrequencyOptions = {1, 10, 100}; - public static final Object[] randomSeedOptions = {1, 2, 3}; - public static final Object[] evilHashOptions = {false, true}; + public static final Object[] commitFrequencyOptions = {10, 10, 100}; + public static final Object[] randomSeedOptions = {1/*, 2, 3*/}; + public static final Object[] storeConfigs = { + // State based + VersionedMapStoreBuilder.builder() + .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE) + .setStateBasedImmutableWhenCommitting(true) + .setHashProvider(MapTestEnvironment.prepareHashProvider(false)) + .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy.SHARED_NODE_CACHE), + VersionedMapStoreBuilder.builder() + .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE) + .setStateBasedImmutableWhenCommitting(true) + .setHashProvider(MapTestEnvironment.prepareHashProvider(true)) + .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy.SHARED_NODE_CACHE), + VersionedMapStoreBuilder.builder() + .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE) + .setStateBasedImmutableWhenCommitting(false) + .setHashProvider(MapTestEnvironment.prepareHashProvider(false)) + .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy.SHARED_NODE_CACHE), + VersionedMapStoreBuilder.builder() + .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE) + .setStateBasedImmutableWhenCommitting(false) + .setHashProvider(MapTestEnvironment.prepareHashProvider(false)) + .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy.NO_NODE_CACHE), + // Delta based + VersionedMapStoreBuilder.builder() + .setStrategy(VersionedMapStoreBuilder.StoreStrategy.DELTA) + .setDeltaStorageStrategy(VersionedMapStoreBuilder.DeltaStorageStrategy.SET), + VersionedMapStoreBuilder.builder() + .setStrategy(VersionedMapStoreBuilder.StoreStrategy.DELTA) + .setDeltaStorageStrategy(VersionedMapStoreBuilder.DeltaStorageStrategy.LIST) + }; } -- cgit v1.2.3-54-g00ecf