From 5e4a41f8c02c5c245950fd329714f97513c8bde5 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Fri, 9 Aug 2019 16:51:47 +0300 Subject: [PATCH 01/44] InMemoryDatabase: property tests --- db/core/build.gradle | 3 +++ .../beacon/db/InMemoryDatabaseTest.java | 19 +++++++++++++++++++ 2 files changed, 22 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java diff --git a/db/core/build.gradle b/db/core/build.gradle index 41a9485f3..24e62c9fe 100644 --- a/db/core/build.gradle +++ b/db/core/build.gradle @@ -1,3 +1,6 @@ dependencies { api project(':types') + + testImplementation 'com.pholser:junit-quickcheck-core:0.7' + testImplementation 'ru.vyarus:generics-resolver:3.0.0' } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java new file mode 100644 index 000000000..3c4a15e56 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java @@ -0,0 +1,19 @@ +package org.ethereum.beacon.db; + +import com.pholser.junit.quickcheck.Property; +import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.runner.RunWith; + +import static org.assertj.core.api.Assertions.assertThat; + +@RunWith(JUnitQuickcheck.class) +public class InMemoryDatabaseTest { + + @Property + public void getBackingDataSource() { + final InMemoryDatabase database = new InMemoryDatabase(); + assertThat(database.getBackingDataSource()).isNotNull(); + assertThat(database.getBackingDataSource()).isInstanceOf(HashMapDataSource.class); + } +} From a8cc578fe0096dcbd1a829b6c9cc3fb0e9e76756 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Fri, 9 Aug 2019 18:11:27 +0300 Subject: [PATCH 02/44] XorKeyDatabase: property tests --- .../beacon/db/XorKeyDatabaseTest.java | 75 +++++++++++++++++++ .../EmptyBytesValueGenerator.java | 16 ++++ .../configuration/EmptyFunctionGenerator.java | 17 +++++ .../HashMapDatasourceGenerator.java | 17 +++++ 4 files changed, 125 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyBytesValueGenerator.java create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyFunctionGenerator.java create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/configuration/HashMapDatasourceGenerator.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java new file mode 100644 index 000000000..2c8ce6e09 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java @@ -0,0 +1,75 @@ +package org.ethereum.beacon.db; + +import com.pholser.junit.quickcheck.*; +import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; +import org.ethereum.beacon.db.configuration.*; +import org.ethereum.beacon.db.source.DataSource; +import org.ethereum.beacon.db.source.impl.XorDataSource; +import org.junit.runner.RunWith; +import tech.pegasys.artemis.util.bytes.*; + +import java.util.function.Function; + +import static org.assertj.core.api.Assertions.assertThat; + +@RunWith(JUnitQuickcheck.class) +public class XorKeyDatabaseTest { + + private final String TEST_STORAGE_NAME = "TEST_STORAGE_NAME"; + private final String TEST_ENTITY_KEY = "TEST_ENTITY_KEY"; + + @Property + public void createStorage(@From(HashMapDatasourceGenerator.class) DataSource<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> backingDataSource, + @From(EmptyFunctionGenerator.class) Function<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> sourceNameHasher) { + + final XorKeyDatabase database = new XorKeyDatabase(backingDataSource, sourceNameHasher) { + @Override + public void commit() { + } + + @Override + public void close() { + } + }; + + final DataSource actual = database.createStorage(TEST_STORAGE_NAME); + assertThat(actual).isNotNull(); + assertThat(actual).isInstanceOf(XorDataSource.class); + + final BytesValue key = BytesValue.wrap(TEST_ENTITY_KEY.getBytes()); + final BytesValue value = BytesValue.EMPTY; + actual.put(key, value); + assertThat(actual.get(key)).isPresent().hasValue(value); + } + + private BytesValue xorLongest(BytesValue v1, BytesValue v2) { + BytesValue longVal = v1.size() >= v2.size() ? v1 : v2; + BytesValue shortVal = v1.size() < v2.size() ? v1 : v2; + MutableBytesValue ret = longVal.mutableCopy(); + int longLen = longVal.size(); + int shortLen = shortVal.size(); + for (int i = 0; i < shortLen; i++) { + ret.set(longLen - i - 1, (byte) (ret.get(longLen - i - 1) ^ shortVal.get(shortLen - i - 1))); + } + return ret; + } + + @Property + public void getBackingDataSource(@From(HashMapDatasourceGenerator.class) DataSource<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> backingDataSource, + @From(EmptyFunctionGenerator.class) Function<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> sourceNameHasher) { + + final XorKeyDatabase actual = new XorKeyDatabase(backingDataSource, sourceNameHasher) { + @Override + public void commit() { + } + + @Override + public void close() { + } + }; + + assertThat(actual).isNotNull(); + assertThat(actual.getBackingDataSource()).isNotNull(); + assertThat(actual.getBackingDataSource()).isEqualTo(backingDataSource); + } +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyBytesValueGenerator.java b/db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyBytesValueGenerator.java new file mode 100644 index 000000000..c8f1fd75d --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyBytesValueGenerator.java @@ -0,0 +1,16 @@ +package org.ethereum.beacon.db.configuration; + +import com.pholser.junit.quickcheck.generator.*; +import com.pholser.junit.quickcheck.random.SourceOfRandomness; +import tech.pegasys.artemis.util.bytes.BytesValue; + +public class EmptyBytesValueGenerator extends Generator { + public EmptyBytesValueGenerator() { + super(BytesValue.class); + } + + @Override + public BytesValue generate(SourceOfRandomness random, GenerationStatus status) { + return BytesValue.EMPTY; + } +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyFunctionGenerator.java b/db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyFunctionGenerator.java new file mode 100644 index 000000000..1c1e59ac3 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyFunctionGenerator.java @@ -0,0 +1,17 @@ +package org.ethereum.beacon.db.configuration; + +import com.pholser.junit.quickcheck.generator.*; +import com.pholser.junit.quickcheck.random.SourceOfRandomness; + +import java.util.function.Function; + +public class EmptyFunctionGenerator extends Generator { + public EmptyFunctionGenerator() { + super(Function.class); + } + + @Override + public Function generate(SourceOfRandomness random, GenerationStatus status) { + return Function.identity(); + } +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/configuration/HashMapDatasourceGenerator.java b/db/core/src/test/java/org/ethereum/beacon/db/configuration/HashMapDatasourceGenerator.java new file mode 100644 index 000000000..eb0f891f6 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/configuration/HashMapDatasourceGenerator.java @@ -0,0 +1,17 @@ +package org.ethereum.beacon.db.configuration; + +import com.pholser.junit.quickcheck.generator.*; +import com.pholser.junit.quickcheck.random.SourceOfRandomness; +import org.ethereum.beacon.db.source.DataSource; +import org.ethereum.beacon.db.source.impl.HashMapDataSource; + +public class HashMapDatasourceGenerator extends Generator { + public HashMapDatasourceGenerator() { + super(DataSource.class); + } + + @Override + public HashMapDataSource generate(SourceOfRandomness random, GenerationStatus status) { + return new HashMapDataSource(); + } +} From a23e3b175024b47f80ac44e7eedb491b0a44d0e2 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Fri, 9 Aug 2019 18:28:51 +0300 Subject: [PATCH 03/44] WritableCacheImpl: property tests --- .../beacon/db/XorKeyDatabaseTest.java | 14 +--------- .../beacon/db/source/WriteCacheImplTest.java | 26 +++++++++++++++++++ 2 files changed, 27 insertions(+), 13 deletions(-) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java index 2c8ce6e09..2e7af192b 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java @@ -6,7 +6,7 @@ import org.ethereum.beacon.db.source.DataSource; import org.ethereum.beacon.db.source.impl.XorDataSource; import org.junit.runner.RunWith; -import tech.pegasys.artemis.util.bytes.*; +import tech.pegasys.artemis.util.bytes.BytesValue; import java.util.function.Function; @@ -42,18 +42,6 @@ public void close() { assertThat(actual.get(key)).isPresent().hasValue(value); } - private BytesValue xorLongest(BytesValue v1, BytesValue v2) { - BytesValue longVal = v1.size() >= v2.size() ? v1 : v2; - BytesValue shortVal = v1.size() < v2.size() ? v1 : v2; - MutableBytesValue ret = longVal.mutableCopy(); - int longLen = longVal.size(); - int shortLen = shortVal.size(); - for (int i = 0; i < shortLen; i++) { - ret.set(longLen - i - 1, (byte) (ret.get(longLen - i - 1) ^ shortVal.get(shortLen - i - 1))); - } - return ret; - } - @Property public void getBackingDataSource(@From(HashMapDatasourceGenerator.class) DataSource<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> backingDataSource, @From(EmptyFunctionGenerator.class) Function<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> sourceNameHasher) { diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java new file mode 100644 index 000000000..3c89e3858 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java @@ -0,0 +1,26 @@ +package org.ethereum.beacon.db.source; + +import com.pholser.junit.quickcheck.*; +import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; +import org.ethereum.beacon.db.configuration.HashMapDatasourceGenerator; +import org.junit.runner.RunWith; + +import static org.assertj.core.api.Assertions.assertThat; + +@RunWith(JUnitQuickcheck.class) +public class WriteCacheImplTest { + + private final String TEST_ENTITY_KEY = "TEST_ENTITY_KEY"; + + @Property + public void get(@From(HashMapDatasourceGenerator.class) DataSource dataSource) { + final CacheDataSource cacheDataSource = new WriteCacheImpl(dataSource); + assertThat(cacheDataSource.get(TEST_ENTITY_KEY)).isNotPresent(); + } + + @Property + public void getCacheEntry(@From(HashMapDatasourceGenerator.class) DataSource dataSource) { + final CacheDataSource cacheDataSource = new WriteCacheImpl(dataSource); + assertThat(cacheDataSource.get(TEST_ENTITY_KEY)).isNotPresent(); + } +} From d0d232ef4e200b5cad84ae30602ab5267cebe6df Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Tue, 13 Aug 2019 18:15:08 +0300 Subject: [PATCH 04/44] WritableCacheImpl/DelegateDataSourceTest --- .../beacon/db/InMemoryDatabaseTest.java | 15 ++- .../beacon/db/XorKeyDatabaseTest.java | 10 +- .../beacon/db/source/CodecSourceTest.java | 91 +++++++++++++++++++ .../beacon/db/source/WriteCacheImplTest.java | 27 +++--- .../source/impl/DelegateDataSourceTest.java | 39 ++++++++ 5 files changed, 159 insertions(+), 23 deletions(-) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java index 3c4a15e56..ce077e199 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java @@ -2,18 +2,27 @@ import com.pholser.junit.quickcheck.Property; import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; -import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.ethereum.beacon.db.source.DataSource; import org.junit.runner.RunWith; +import tech.pegasys.artemis.util.bytes.BytesValue; import static org.assertj.core.api.Assertions.assertThat; @RunWith(JUnitQuickcheck.class) public class InMemoryDatabaseTest { + private final String TEST_ENTITY_KEY = "TEST_ENTITY_KEY"; + @Property public void getBackingDataSource() { final InMemoryDatabase database = new InMemoryDatabase(); - assertThat(database.getBackingDataSource()).isNotNull(); - assertThat(database.getBackingDataSource()).isInstanceOf(HashMapDataSource.class); + final DataSource dataSource = database.getBackingDataSource(); + assertThat(dataSource).isNotNull(); + + final BytesValue key = BytesValue.wrap(TEST_ENTITY_KEY.getBytes()); + final BytesValue value = BytesValue.EMPTY; + dataSource.put(key, value); + + assertThat(dataSource.get(key)).isPresent(); } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java index 2e7af192b..4e16888e5 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java @@ -4,7 +4,6 @@ import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; import org.ethereum.beacon.db.configuration.*; import org.ethereum.beacon.db.source.DataSource; -import org.ethereum.beacon.db.source.impl.XorDataSource; import org.junit.runner.RunWith; import tech.pegasys.artemis.util.bytes.BytesValue; @@ -32,14 +31,13 @@ public void close() { } }; - final DataSource actual = database.createStorage(TEST_STORAGE_NAME); - assertThat(actual).isNotNull(); - assertThat(actual).isInstanceOf(XorDataSource.class); + final DataSource storage = database.createStorage(TEST_STORAGE_NAME); + assertThat(storage).isNotNull(); final BytesValue key = BytesValue.wrap(TEST_ENTITY_KEY.getBytes()); final BytesValue value = BytesValue.EMPTY; - actual.put(key, value); - assertThat(actual.get(key)).isPresent().hasValue(value); + storage.put(key, value); + assertThat(storage.get(key)).isPresent().hasValue(value); } @Property diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java new file mode 100644 index 000000000..d6a410871 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java @@ -0,0 +1,91 @@ +package org.ethereum.beacon.db.source; + +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.Test; + +import java.util.function.Function; + +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; + +public class CodecSourceTest { + + private final String TEST_KEY = "test_key"; + private final String TEST_VALUE = "test_value"; + + @Test + public void testValidSourceCreation() { + assertThatThrownBy(() -> new CodecSource(null, Function.identity(), Function.identity(), Function.identity())) + .isInstanceOf(NullPointerException.class); + + assertThatThrownBy(() -> new CodecSource(new HashMapDataSource(), null, Function.identity(), Function.identity())) + .isInstanceOf(NullPointerException.class); + + assertThatThrownBy(() -> new CodecSource(new HashMapDataSource(), Function.identity(), null, Function.identity())) + .isInstanceOf(NullPointerException.class); + + assertThatThrownBy(() -> new CodecSource(new HashMapDataSource(), Function.identity(), Function.identity(), null)) + .isInstanceOf(NullPointerException.class); + + assertThatThrownBy(() -> new CodecSource.KeyOnly<>(null, Function.identity())) + .isInstanceOf(NullPointerException.class); + + assertThatThrownBy(() -> new CodecSource.KeyOnly<>(new HashMapDataSource<>(), null)) + .isInstanceOf(NullPointerException.class); + + assertThatThrownBy(() -> new CodecSource.ValueOnly<>(null, Function.identity(), Function.identity())) + .isInstanceOf(NullPointerException.class); + + assertThatThrownBy(() -> new CodecSource.ValueOnly<>(new HashMapDataSource<>(), null, Function.identity())) + .isInstanceOf(NullPointerException.class); + + assertThatThrownBy(() -> new CodecSource.ValueOnly<>(new HashMapDataSource<>(), Function.identity(), null)) + .isInstanceOf(NullPointerException.class); + } + + @Test + public void testPutGetRemove() { + final CodecSource source = new CodecSource<>(new HashMapDataSource<>(), Function.identity(), Function.identity(), Function.identity()); + assertThat(source).isNotNull(); + assertThat(source.get(TEST_KEY)).isNotPresent(); + + source.put(TEST_KEY, TEST_VALUE); + assertThat(source.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); + + source.remove(TEST_KEY); + assertThat(source.get(TEST_KEY)).isNotPresent(); + } + + @Test + public void testKeyConversion() { + final CodecSource source = new CodecSource<>(new HashMapDataSource<>(), key -> encode(key, TEST_KEY), Function.identity(), Function.identity()); + + source.put(TEST_KEY, TEST_VALUE); + assertThat(source.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); + } + + private String encode(String value, String valueModifier) { + return value.concat(valueModifier); + } + + @Test + public void testValueTargetValueToUpValueConversion() { + final CodecSource source = new CodecSource<>(new HashMapDataSource<>(), key -> encode(key, TEST_KEY), key -> encode(key, TEST_VALUE), Function.identity()); + + source.put(TEST_KEY, TEST_VALUE); + assertThat(source.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE.concat(TEST_VALUE)); + } + + @Test + public void testValueUpValueToTargetValueConversion() { + final CodecSource source = new CodecSource<>(new HashMapDataSource<>(), key -> encode(key, TEST_KEY), key -> encode(key, TEST_VALUE), key -> decode()); + + source.put(TEST_KEY, TEST_VALUE); + assertThat(source.get(TEST_KEY)).isPresent().hasValue(""); + } + + private String decode() { + return ""; + } + +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java index 3c89e3858..7f0f9bae4 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java @@ -1,26 +1,25 @@ package org.ethereum.beacon.db.source; -import com.pholser.junit.quickcheck.*; -import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; -import org.ethereum.beacon.db.configuration.HashMapDatasourceGenerator; -import org.junit.runner.RunWith; +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.Test; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(JUnitQuickcheck.class) public class WriteCacheImplTest { - private final String TEST_ENTITY_KEY = "TEST_ENTITY_KEY"; + private final String TEST_KEY = "test_key"; - @Property - public void get(@From(HashMapDatasourceGenerator.class) DataSource dataSource) { - final CacheDataSource cacheDataSource = new WriteCacheImpl(dataSource); - assertThat(cacheDataSource.get(TEST_ENTITY_KEY)).isNotPresent(); + @Test + public void get() { + final WriteCacheImpl dataSource = new WriteCacheImpl<>(new HashMapDataSource<>()); + assertThat(dataSource).isNotNull(); + assertThat(dataSource.get(TEST_KEY)).isEmpty(); } - @Property - public void getCacheEntry(@From(HashMapDatasourceGenerator.class) DataSource dataSource) { - final CacheDataSource cacheDataSource = new WriteCacheImpl(dataSource); - assertThat(cacheDataSource.get(TEST_ENTITY_KEY)).isNotPresent(); + @Test + public void getCacheEntry() { + final WriteCacheImpl dataSource = new WriteCacheImpl<>(new HashMapDataSource<>()); + assertThat(dataSource).isNotNull(); + assertThat(dataSource.getCacheEntry(TEST_KEY)).isEmpty(); } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java new file mode 100644 index 000000000..be63f4789 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java @@ -0,0 +1,39 @@ +package org.ethereum.beacon.db.source.impl; + +import org.junit.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class DelegateDataSourceTest { + + private final String TEST_KEY = "test_key"; + private final String TEST_VALUE = "test_value"; + + @Test + public void testPutGetRemove() { + final DelegateDataSource delegateDataSource = new DelegateDataSource<>(new HashMapDataSource<>()); + assertThat(delegateDataSource).isNotNull(); + + delegateDataSource.put(TEST_KEY, TEST_VALUE); + assertThat(delegateDataSource.get(TEST_KEY)).isPresent(); + + delegateDataSource.remove(TEST_KEY); + assertThat(delegateDataSource.get(TEST_KEY)).isNotPresent(); + } + + @Test(expected = NullPointerException.class) + public void testNullKey() { + final DelegateDataSource delegateDataSource = new DelegateDataSource<>(new HashMapDataSource<>()); + assertThat(delegateDataSource).isNotNull(); + + delegateDataSource.put(null, TEST_VALUE); + } + + @Test(expected = NullPointerException.class) + public void testNullValue() { + final DelegateDataSource delegateDataSource = new DelegateDataSource<>(new HashMapDataSource<>()); + assertThat(delegateDataSource).isNotNull(); + + delegateDataSource.put(TEST_KEY, null); + } +} From 854535960ec9e543da47e86c889b9d435c9b85d3 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Tue, 13 Aug 2019 21:46:20 +0300 Subject: [PATCH 05/44] HashMapHoleyListTest --- .../db/source/impl/HashMapHoleyListTest.java | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java new file mode 100644 index 000000000..4021e3c39 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java @@ -0,0 +1,55 @@ +package org.ethereum.beacon.db.source.impl; + +import org.ethereum.beacon.db.source.HoleyList; +import org.junit.Test; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; + +public class HashMapHoleyListTest { + + private final Long TEST_KEY = 0L; + private final String TEST_VALUE = "test_value"; + + @Test + public void size() { + final HoleyList map = new HashMapHoleyList<>(); + assertThat(map).isNotNull(); + assertThat(map.size()).isEqualTo(0L); + + map.put(TEST_KEY, TEST_VALUE); + assertThat(map.size()).isEqualTo(1L); + } + + @Test + public void putNullValue() { + final HoleyList map = new HashMapHoleyList<>(); + map.put(TEST_KEY, null); + assertThat(map.size()).isEqualTo(0L); + } + + @Test + public void put() { + final HoleyList map = new HashMapHoleyList<>(); + map.put(TEST_KEY, TEST_VALUE); + assertThat(map.size()).isEqualTo(1L); + } + + @Test + public void putSameKey() { + final HoleyList map = new HashMapHoleyList<>(); + map.put(TEST_KEY, TEST_VALUE); + map.put(1, TEST_VALUE); + assertThat(map.size()).isEqualTo(2L); + + map.put(TEST_KEY, "NewTestValue"); + assertThat(map.size()).isEqualTo(2L); + } + + @Test + public void get() { + final HoleyList map = new HashMapHoleyList<>(); + map.put(TEST_KEY, TEST_VALUE); + assertThat(map.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); + assertThat(map.get(1)).isNotPresent(); + } +} From 19133081c93c901edc7b90fd2cd7956d0e53ff93 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 14 Aug 2019 10:38:00 +0300 Subject: [PATCH 06/44] LinkedDataSourceTest --- .../db/source/LinkedDataSourceTest.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java new file mode 100644 index 000000000..af30e7f62 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java @@ -0,0 +1,21 @@ +package org.ethereum.beacon.db.source; + +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.Test; + +import static org.assertj.core.api.Java6Assertions.assertThatThrownBy; + +public class LinkedDataSourceTest { + + @Test + public void setUpstream() { + final LinkedDataSource dataSource = new WriteCacheImpl<>(new HashMapDataSource<>()); + assertThatThrownBy(() -> dataSource.setUpstream(new HashMapDataSource<>())).isInstanceOf(UnsupportedOperationException.class); + } + + @Test + public void testValidSourceCreation() { + assertThatThrownBy(() -> new WriteCacheImpl(null)).isInstanceOf(NullPointerException.class); + } + +} From 00fd3124b96ba8a958aae8137f36ac468ac0989b Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 14 Aug 2019 11:22:23 +0300 Subject: [PATCH 07/44] DataSourceListTest --- .../db/source/impl/DataSourceListTest.java | 78 +++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java new file mode 100644 index 000000000..19a8078c6 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java @@ -0,0 +1,78 @@ +package org.ethereum.beacon.db.source.impl; + +import org.junit.Test; +import tech.pegasys.artemis.util.bytes.BytesValue; + +import java.util.function.Function; + +import static org.assertj.core.api.Assertions.*; + +public class DataSourceListTest { + + private final String TEST_VALUE = "test_value"; + + @Test + public void testValidSourceCreation() { + assertThatThrownBy(() -> new DataSourceList(new HashMapDataSource<>(), null, deserialize())) + .isInstanceOf(NullPointerException.class); + + assertThatThrownBy(() -> new DataSourceList(new HashMapDataSource<>(), serialize(), null)) + .isInstanceOf(NullPointerException.class); + } + + private Function serialize() { + return key -> BytesValue.EMPTY; + } + + private Function deserialize() { + return key -> ""; + } + + @Test + public void testPutGetSizeSerialization() { + final DataSourceList dataSource = new DataSourceList<>(new HashMapDataSource<>(), serialize(), deserialize()); + assertThat(dataSource).isNotNull(); + assertThat(dataSource.size()).isEqualTo(0); + assertThat(dataSource.get(0)).isNotPresent(); + + dataSource.put(0, TEST_VALUE); + assertThat(dataSource.size()).isEqualTo(1); + assertThat(dataSource.get(0)).isPresent().hasValue(""); + + dataSource.put(1, TEST_VALUE); + assertThat(dataSource.size()).isEqualTo(2); + } + + @Test + public void testPutNull() { + final DataSourceList dataSource = new DataSourceList<>(new HashMapDataSource<>(), serialize(), deserialize()); + assertThat(dataSource).isNotNull(); + assertThat(dataSource.size()).isEqualTo(0); + assertThat(dataSource.get(0)).isNotPresent(); + + dataSource.put(0, null); + assertThat(dataSource.size()).isEqualTo(0); + assertThat(dataSource.get(0)).isNotPresent(); + } + + @Test + public void testPutOverSize() { + final DataSourceList dataSource = new DataSourceList<>(new HashMapDataSource<>(), serialize(), deserialize()); + assertThat(dataSource).isNotNull(); + assertThat(dataSource.size()).isEqualTo(0); + + dataSource.put(1, TEST_VALUE); + assertThat(dataSource.size()).isEqualTo(2); + } + + @Test + public void testGetOverIndex() { + final DataSourceList dataSource = new DataSourceList<>(new HashMapDataSource<>(), serialize(), deserialize()); + assertThat(dataSource).isNotNull(); + assertThat(dataSource.size()).isEqualTo(0); + + dataSource.put(0, TEST_VALUE); + assertThat(dataSource.get(-1)).isEmpty(); + assertThat(dataSource.get(1)).isEmpty(); + } +} From a9283d2b77e1ca2d9892d61980b03d9e7c21810d Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 14 Aug 2019 14:05:18 +0300 Subject: [PATCH 08/44] Fix after code review --- .../beacon/db/InMemoryDatabaseTest.java | 6 +- .../beacon/db/XorKeyDatabaseTest.java | 8 +-- .../beacon/db/source/CodecSourceTest.java | 27 ++++--- .../db/source/LinkedDataSourceTest.java | 2 +- .../beacon/db/source/WriteCacheImplTest.java | 4 +- .../db/source/impl/DataSourceListTest.java | 71 ++++++++++--------- .../source/impl/DelegateDataSourceTest.java | 42 +++++++---- .../db/source/impl/HashMapHoleyListTest.java | 38 ++++++---- .../db/source/impl/XorDataSourceTest.java | 5 ++ 9 files changed, 124 insertions(+), 79 deletions(-) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java index ce077e199..08b48c9d4 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java @@ -11,15 +11,15 @@ @RunWith(JUnitQuickcheck.class) public class InMemoryDatabaseTest { - private final String TEST_ENTITY_KEY = "TEST_ENTITY_KEY"; + private final String TEST_KEY = "TEST_KEY"; @Property - public void getBackingDataSource() { + public void testGetBackingDataSource() { final InMemoryDatabase database = new InMemoryDatabase(); final DataSource dataSource = database.getBackingDataSource(); assertThat(dataSource).isNotNull(); - final BytesValue key = BytesValue.wrap(TEST_ENTITY_KEY.getBytes()); + final BytesValue key = BytesValue.wrap(TEST_KEY.getBytes()); final BytesValue value = BytesValue.EMPTY; dataSource.put(key, value); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java index 4e16888e5..1a0fbf754 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java @@ -18,8 +18,8 @@ public class XorKeyDatabaseTest { private final String TEST_ENTITY_KEY = "TEST_ENTITY_KEY"; @Property - public void createStorage(@From(HashMapDatasourceGenerator.class) DataSource<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> backingDataSource, - @From(EmptyFunctionGenerator.class) Function<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> sourceNameHasher) { + public void testCreateStorage(@From(HashMapDatasourceGenerator.class) DataSource<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> backingDataSource, + @From(EmptyFunctionGenerator.class) Function<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> sourceNameHasher) { final XorKeyDatabase database = new XorKeyDatabase(backingDataSource, sourceNameHasher) { @Override @@ -41,8 +41,8 @@ public void close() { } @Property - public void getBackingDataSource(@From(HashMapDatasourceGenerator.class) DataSource<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> backingDataSource, - @From(EmptyFunctionGenerator.class) Function<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> sourceNameHasher) { + public void testGetBackingDataSource(@From(HashMapDatasourceGenerator.class) DataSource<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> backingDataSource, + @From(EmptyFunctionGenerator.class) Function<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> sourceNameHasher) { final XorKeyDatabase actual = new XorKeyDatabase(backingDataSource, sourceNameHasher) { @Override diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java index d6a410871..581119da3 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java @@ -1,7 +1,7 @@ package org.ethereum.beacon.db.source; import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.Test; +import org.junit.*; import java.util.function.Function; @@ -13,6 +13,15 @@ public class CodecSourceTest { private final String TEST_KEY = "test_key"; private final String TEST_VALUE = "test_value"; + private CodecSource source; + + @Before + public void setUp() { + source = new CodecSource<>(new HashMapDataSource<>(), Function.identity(), Function.identity(), Function.identity()); + assertThat(source).isNotNull(); + assertThat(source.get(TEST_KEY)).isNotPresent(); + } + @Test public void testValidSourceCreation() { assertThatThrownBy(() -> new CodecSource(null, Function.identity(), Function.identity(), Function.identity())) @@ -45,10 +54,6 @@ public void testValidSourceCreation() { @Test public void testPutGetRemove() { - final CodecSource source = new CodecSource<>(new HashMapDataSource<>(), Function.identity(), Function.identity(), Function.identity()); - assertThat(source).isNotNull(); - assertThat(source.get(TEST_KEY)).isNotPresent(); - source.put(TEST_KEY, TEST_VALUE); assertThat(source.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); @@ -58,7 +63,9 @@ public void testPutGetRemove() { @Test public void testKeyConversion() { - final CodecSource source = new CodecSource<>(new HashMapDataSource<>(), key -> encode(key, TEST_KEY), Function.identity(), Function.identity()); + source = new CodecSource<>(new HashMapDataSource<>(), key -> encode(key, TEST_KEY), Function.identity(), Function.identity()); + assertThat(source).isNotNull(); + assertThat(source.get(TEST_KEY)).isNotPresent(); source.put(TEST_KEY, TEST_VALUE); assertThat(source.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); @@ -70,7 +77,9 @@ private String encode(String value, String valueModifier) { @Test public void testValueTargetValueToUpValueConversion() { - final CodecSource source = new CodecSource<>(new HashMapDataSource<>(), key -> encode(key, TEST_KEY), key -> encode(key, TEST_VALUE), Function.identity()); + source = new CodecSource<>(new HashMapDataSource<>(), key -> encode(key, TEST_KEY), key -> encode(key, TEST_VALUE), Function.identity()); + assertThat(source).isNotNull(); + assertThat(source.get(TEST_KEY)).isNotPresent(); source.put(TEST_KEY, TEST_VALUE); assertThat(source.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE.concat(TEST_VALUE)); @@ -78,7 +87,9 @@ public void testValueTargetValueToUpValueConversion() { @Test public void testValueUpValueToTargetValueConversion() { - final CodecSource source = new CodecSource<>(new HashMapDataSource<>(), key -> encode(key, TEST_KEY), key -> encode(key, TEST_VALUE), key -> decode()); + source = new CodecSource<>(new HashMapDataSource<>(), key -> encode(key, TEST_KEY), key -> encode(key, TEST_VALUE), key -> decode()); + assertThat(source).isNotNull(); + assertThat(source.get(TEST_KEY)).isNotPresent(); source.put(TEST_KEY, TEST_VALUE); assertThat(source.get(TEST_KEY)).isPresent().hasValue(""); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java index af30e7f62..4795b7631 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java @@ -8,7 +8,7 @@ public class LinkedDataSourceTest { @Test - public void setUpstream() { + public void testSetUpstream() { final LinkedDataSource dataSource = new WriteCacheImpl<>(new HashMapDataSource<>()); assertThatThrownBy(() -> dataSource.setUpstream(new HashMapDataSource<>())).isInstanceOf(UnsupportedOperationException.class); } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java index 7f0f9bae4..c5057f54d 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java @@ -10,14 +10,14 @@ public class WriteCacheImplTest { private final String TEST_KEY = "test_key"; @Test - public void get() { + public void testGet() { final WriteCacheImpl dataSource = new WriteCacheImpl<>(new HashMapDataSource<>()); assertThat(dataSource).isNotNull(); assertThat(dataSource.get(TEST_KEY)).isEmpty(); } @Test - public void getCacheEntry() { + public void testGetCacheEntry() { final WriteCacheImpl dataSource = new WriteCacheImpl<>(new HashMapDataSource<>()); assertThat(dataSource).isNotNull(); assertThat(dataSource.getCacheEntry(TEST_KEY)).isEmpty(); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java index 19a8078c6..16b3917e0 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java @@ -1,6 +1,7 @@ package org.ethereum.beacon.db.source.impl; -import org.junit.Test; +import org.ethereum.beacon.db.source.DataSource; +import org.junit.*; import tech.pegasys.artemis.util.bytes.BytesValue; import java.util.function.Function; @@ -9,14 +10,28 @@ public class DataSourceListTest { + private final BytesValue SIZE_KEY = BytesValue.fromHexString("FFFFFFFFFFFFFFFF"); + private final Long TEST_KEY_0 = 0L; + private final Long TEST_KEY_1 = 1L; + private final Long TEST_KEY_LESS_ZERO = -1L; private final String TEST_VALUE = "test_value"; + private DataSourceList dataSourceList; + + @Before + public void setUp() { + dataSourceList = new DataSourceList<>(new HashMapDataSource<>(), serialize(), deserialize()); + assertThat(dataSourceList).isNotNull(); + assertThat(dataSourceList.size()).isEqualTo(0); + assertThat(dataSourceList.get(TEST_KEY_0)).isNotPresent(); + } + @Test public void testValidSourceCreation() { - assertThatThrownBy(() -> new DataSourceList(new HashMapDataSource<>(), null, deserialize())) + assertThatThrownBy(() -> new DataSourceList<>(new HashMapDataSource<>(), null, deserialize())) .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> new DataSourceList(new HashMapDataSource<>(), serialize(), null)) + assertThatThrownBy(() -> new DataSourceList<>(new HashMapDataSource<>(), serialize(), null)) .isInstanceOf(NullPointerException.class); } @@ -30,49 +45,39 @@ private Function deserialize() { @Test public void testPutGetSizeSerialization() { - final DataSourceList dataSource = new DataSourceList<>(new HashMapDataSource<>(), serialize(), deserialize()); - assertThat(dataSource).isNotNull(); - assertThat(dataSource.size()).isEqualTo(0); - assertThat(dataSource.get(0)).isNotPresent(); - - dataSource.put(0, TEST_VALUE); - assertThat(dataSource.size()).isEqualTo(1); - assertThat(dataSource.get(0)).isPresent().hasValue(""); + dataSourceList.put(TEST_KEY_0, TEST_VALUE); + assertThat(dataSourceList.size()).isEqualTo(1); + assertThat(dataSourceList.get(TEST_KEY_0)).isPresent().hasValue(""); - dataSource.put(1, TEST_VALUE); - assertThat(dataSource.size()).isEqualTo(2); + dataSourceList.put(TEST_KEY_1, TEST_VALUE); + assertThat(dataSourceList.size()).isEqualTo(2); } @Test public void testPutNull() { - final DataSourceList dataSource = new DataSourceList<>(new HashMapDataSource<>(), serialize(), deserialize()); - assertThat(dataSource).isNotNull(); - assertThat(dataSource.size()).isEqualTo(0); - assertThat(dataSource.get(0)).isNotPresent(); - - dataSource.put(0, null); - assertThat(dataSource.size()).isEqualTo(0); - assertThat(dataSource.get(0)).isNotPresent(); + dataSourceList.put(TEST_KEY_0, null); + assertThat(dataSourceList.size()).isEqualTo(0); + assertThat(dataSourceList.get(TEST_KEY_0)).isNotPresent(); } @Test public void testPutOverSize() { - final DataSourceList dataSource = new DataSourceList<>(new HashMapDataSource<>(), serialize(), deserialize()); - assertThat(dataSource).isNotNull(); - assertThat(dataSource.size()).isEqualTo(0); - - dataSource.put(1, TEST_VALUE); - assertThat(dataSource.size()).isEqualTo(2); + dataSourceList.put(TEST_KEY_1, TEST_VALUE); + assertThat(dataSourceList.size()).isEqualTo(2); } @Test public void testGetOverIndex() { - final DataSourceList dataSource = new DataSourceList<>(new HashMapDataSource<>(), serialize(), deserialize()); - assertThat(dataSource).isNotNull(); - assertThat(dataSource.size()).isEqualTo(0); + dataSourceList.put(TEST_KEY_0, TEST_VALUE); + assertThat(dataSourceList.get(TEST_KEY_LESS_ZERO)).isEmpty(); + assertThat(dataSourceList.get(TEST_KEY_1)).isEmpty(); + } - dataSource.put(0, TEST_VALUE); - assertThat(dataSource.get(-1)).isEmpty(); - assertThat(dataSource.get(1)).isEmpty(); + @Test + public void testSizeBySIZE_KEY() { + final DataSource dataSource = new HashMapDataSource<>(); + dataSource.put(SIZE_KEY, BytesValue.wrap("-1000".getBytes())); + dataSourceList = new DataSourceList<>(dataSource, serialize(), deserialize()); + assertThat(dataSourceList.size()).isEqualTo(0L); } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java index be63f4789..8c141b02c 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java @@ -1,39 +1,55 @@ package org.ethereum.beacon.db.source.impl; -import org.junit.Test; +import org.junit.*; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Java6Assertions.assertThatThrownBy; public class DelegateDataSourceTest { private final String TEST_KEY = "test_key"; private final String TEST_VALUE = "test_value"; - @Test - public void testPutGetRemove() { - final DelegateDataSource delegateDataSource = new DelegateDataSource<>(new HashMapDataSource<>()); + private DelegateDataSource delegateDataSource; + + @Before + public void setUp() { + delegateDataSource = new DelegateDataSource<>(new HashMapDataSource<>()); assertThat(delegateDataSource).isNotNull(); + } + @Test + public void testPutGetRemove() { delegateDataSource.put(TEST_KEY, TEST_VALUE); - assertThat(delegateDataSource.get(TEST_KEY)).isPresent(); + assertThat(delegateDataSource.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); delegateDataSource.remove(TEST_KEY); assertThat(delegateDataSource.get(TEST_KEY)).isNotPresent(); } - @Test(expected = NullPointerException.class) + @Test public void testNullKey() { - final DelegateDataSource delegateDataSource = new DelegateDataSource<>(new HashMapDataSource<>()); - assertThat(delegateDataSource).isNotNull(); - - delegateDataSource.put(null, TEST_VALUE); + assertThatThrownBy(() -> delegateDataSource.put(null, TEST_VALUE)).isInstanceOf(NullPointerException.class); } - @Test(expected = NullPointerException.class) + @Test public void testNullValue() { - final DelegateDataSource delegateDataSource = new DelegateDataSource<>(new HashMapDataSource<>()); + assertThatThrownBy(() -> delegateDataSource.put(TEST_KEY, null)).isInstanceOf(NullPointerException.class); + } + + @Test + public void testFlush() { + delegateDataSource = new DelegateDataSource<>(new HashMapDataSource() { + public void flush() { + store.clear(); + } + }); assertThat(delegateDataSource).isNotNull(); - delegateDataSource.put(TEST_KEY, null); + delegateDataSource.put(TEST_KEY, TEST_VALUE); + assertThat(delegateDataSource.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); + + delegateDataSource.flush(); + assertThat(delegateDataSource.get(TEST_KEY)).isNotPresent(); } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java index 4021e3c39..94294767a 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java @@ -1,55 +1,63 @@ package org.ethereum.beacon.db.source.impl; import org.ethereum.beacon.db.source.HoleyList; -import org.junit.Test; +import org.junit.*; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; public class HashMapHoleyListTest { private final Long TEST_KEY = 0L; + private final Long TEST_KEY_1 = 1L; + private final Long TEST_KEY_LESS_ZERO = -1L; private final String TEST_VALUE = "test_value"; + private final String TEST_VALUE_NEW = "NewTestValue"; - @Test - public void size() { - final HoleyList map = new HashMapHoleyList<>(); + private HoleyList map; + + @Before + public void setUp() { + map = new HashMapHoleyList<>(); assertThat(map).isNotNull(); assertThat(map.size()).isEqualTo(0L); + } + @Test + public void testSize() { map.put(TEST_KEY, TEST_VALUE); assertThat(map.size()).isEqualTo(1L); } @Test - public void putNullValue() { - final HoleyList map = new HashMapHoleyList<>(); + public void testPutNullValue() { map.put(TEST_KEY, null); assertThat(map.size()).isEqualTo(0L); + assertThat(map.get(TEST_KEY)).isNotPresent(); } @Test - public void put() { - final HoleyList map = new HashMapHoleyList<>(); + public void testPutGet() { map.put(TEST_KEY, TEST_VALUE); assertThat(map.size()).isEqualTo(1L); + assertThat(map.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); } @Test - public void putSameKey() { - final HoleyList map = new HashMapHoleyList<>(); + public void testPutSameKey() { map.put(TEST_KEY, TEST_VALUE); - map.put(1, TEST_VALUE); + map.put(TEST_KEY_1, TEST_VALUE); assertThat(map.size()).isEqualTo(2L); - map.put(TEST_KEY, "NewTestValue"); + map.put(TEST_KEY, TEST_VALUE_NEW); assertThat(map.size()).isEqualTo(2L); + assertThat(map.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE_NEW); } @Test - public void get() { - final HoleyList map = new HashMapHoleyList<>(); + public void testGetOverIndex() { map.put(TEST_KEY, TEST_VALUE); assertThat(map.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); - assertThat(map.get(1)).isNotPresent(); + assertThat(map.get(TEST_KEY_1)).isNotPresent(); + assertThat(map.get(TEST_KEY_LESS_ZERO)).isNotPresent(); } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java new file mode 100644 index 000000000..b6295cd4b --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java @@ -0,0 +1,5 @@ +package org.ethereum.beacon.db.source.impl; + +public class XorDataSourceTest { + +} From 4c0cb48c42bf7df7741e1e6028fbc51fd2384e66 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 14 Aug 2019 14:56:01 +0300 Subject: [PATCH 09/44] XorDataSourceTest --- .../beacon/db/source/impl/DelegateDataSourceTest.java | 5 +++-- .../beacon/db/source/impl/XorDataSourceTest.java | 11 +++++++++++ 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java index 8c141b02c..673a094bc 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java @@ -9,6 +9,7 @@ public class DelegateDataSourceTest { private final String TEST_KEY = "test_key"; private final String TEST_VALUE = "test_value"; + private final String TEST_FLUSH = "flush"; private DelegateDataSource delegateDataSource; @@ -41,7 +42,7 @@ public void testNullValue() { public void testFlush() { delegateDataSource = new DelegateDataSource<>(new HashMapDataSource() { public void flush() { - store.clear(); + store.put(TEST_FLUSH, TEST_FLUSH); } }); assertThat(delegateDataSource).isNotNull(); @@ -50,6 +51,6 @@ public void flush() { assertThat(delegateDataSource.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); delegateDataSource.flush(); - assertThat(delegateDataSource.get(TEST_KEY)).isNotPresent(); + assertThat(delegateDataSource.get(TEST_FLUSH)).isPresent().hasValue(TEST_FLUSH); } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java index b6295cd4b..45d421953 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java @@ -1,5 +1,16 @@ package org.ethereum.beacon.db.source.impl; +import org.junit.Test; +import tech.pegasys.artemis.util.bytes.BytesValue; + +import static org.assertj.core.api.Assertions.assertThatThrownBy; + public class XorDataSourceTest { + @Test + public void testValidSourceCreation() { + assertThatThrownBy(() -> new XorDataSource<>(null, BytesValue.EMPTY)) + .isInstanceOf(NullPointerException.class); + } + } From 045421e81551c62ec28078add6f6a155822680cc Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 14 Aug 2019 15:36:47 +0300 Subject: [PATCH 10/44] AbstractLinkedDataSourceTest --- .../source/AbstractLinkedDataSourceTest.java | 126 ++++++++++++++++++ 1 file changed, 126 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java new file mode 100644 index 000000000..cc7fd769e --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java @@ -0,0 +1,126 @@ +package org.ethereum.beacon.db.source; + +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.*; + +import javax.annotation.Nonnull; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.*; + +public class AbstractLinkedDataSourceTest { + + private final String TEST_KEY = "test_key"; + private final String TEST_VALUE = "test_value"; + private final String TEST_FLUSH = "flush"; + private final String TEST_DO_FLUSH = "do_flush"; + + + private AbstractLinkedDataSource dataSource; + + @Before + public void setUp() { + dataSource = new AbstractLinkedDataSource(new HashMapDataSource<>()) { + public Optional get(@Nonnull String key) { + return getUpstream().get(key); + } + + public void put(@Nonnull String key, @Nonnull String value) { + getUpstream().put(key, value); + } + + public void remove(@Nonnull String key) { + getUpstream().remove(key); + } + }; + + assertThat(dataSource).isNotNull(); + } + + @Test + public void testValidSourceCreation() { + assertThatThrownBy(() -> new AbstractLinkedDataSource(null) { + public Optional get(@Nonnull Object key) { + return Optional.empty(); + } + + public void put(@Nonnull Object key, @Nonnull Object value) { + + } + + public void remove(@Nonnull Object key) { + + } + }).isInstanceOf(NullPointerException.class); + } + + @Test + public void testGetPutRemoveUpstreamFlush() { + dataSource = new AbstractLinkedDataSource(new HashMapDataSource() { + public void flush() { + getStore().put(TEST_FLUSH, TEST_FLUSH); + } + }, true) { + public Optional get(@Nonnull String key) { + return getUpstream().get(key); + } + + public void put(@Nonnull String key, @Nonnull String value) { + getUpstream().put(key, value); + } + + public void remove(@Nonnull String key) { + getUpstream().remove(key); + } + + protected void doFlush() { + getUpstream().put(TEST_DO_FLUSH, TEST_DO_FLUSH); + } + }; + + assertThat(dataSource).isNotNull(); + assertThat(dataSource.getUpstream()).isNotNull(); + + dataSource.put(TEST_KEY, TEST_VALUE); + assertThat(dataSource.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); + + dataSource.remove(TEST_KEY); + assertThat(dataSource.get(TEST_KEY)).isNotPresent(); + + dataSource.flush(); + assertThat(dataSource.get(TEST_FLUSH)).isPresent().hasValue(TEST_FLUSH); + assertThat(dataSource.get(TEST_DO_FLUSH)).isPresent().hasValue(TEST_DO_FLUSH); + } + + @Test + public void testFlushIsFalse() { + dataSource = new AbstractLinkedDataSource(new HashMapDataSource() { + public void flush() { + getStore().put(TEST_FLUSH, TEST_FLUSH); + } + }) { + public Optional get(@Nonnull String key) { + return getUpstream().get(key); + } + + public void put(@Nonnull String key, @Nonnull String value) { + } + + public void remove(@Nonnull String key) { + } + + protected void doFlush() { + getUpstream().put(TEST_DO_FLUSH, TEST_DO_FLUSH); + } + }; + + dataSource.flush(); + assertThat(dataSource.get(TEST_FLUSH)).isNotPresent(); + assertThat(dataSource.get(TEST_DO_FLUSH)).isPresent().hasValue(TEST_DO_FLUSH); + } + + @Test + public void testGetUpstream() { + assertThat(dataSource.getUpstream()).isNotNull(); + } +} From 9384595647a3a66b71bbf1a84f661116fa8ebb0a Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 14 Aug 2019 16:40:13 +0300 Subject: [PATCH 11/44] HoleyListTest --- .../beacon/db/source/HoleyListTest.java | 79 +++++++++++++++++++ .../db/source/LinkedDataSourceTest.java | 70 ++++++++++++++-- 2 files changed, 144 insertions(+), 5 deletions(-) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java new file mode 100644 index 000000000..fe8f2f03d --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java @@ -0,0 +1,79 @@ +package org.ethereum.beacon.db.source; + +import org.junit.*; + +import java.util.*; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; + +public class HoleyListTest { + + private final Long TEST_KEY_0 = 0L; + private final Long TEST_KEY_1 = 1L; + private final Long TEST_KEY_LESS_ZERO = -1L; + private final String TEST_VALUE = "test_value"; + private final String TEST_DEFAULT_VALUE = "test_default_value"; + + private HoleyList list; + + @Before + public void setUp() { + list = new HoleyList() { + private final Map store = new HashMap<>(); + + public long size() { + return store.size(); + } + + public void put(long idx, String value) { + store.put(idx, value); + } + + public Optional get(long idx) { + return Optional.of(store.get(idx)); + } + }; + + assertThat(list).isNotNull(); + } + + @Test + public void testAdd() { + list.put(TEST_KEY_0, TEST_VALUE); + final long indexToAdd = list.size(); + list.add(TEST_VALUE); + + assertThat(list.size()).isEqualTo(2); + assertThat(list.get(indexToAdd)).isPresent().hasValue(TEST_VALUE); + } + + @Test + public void testAddNull() { + list.put(TEST_KEY_0, TEST_VALUE); + final long indexToAdd = list.size(); + list.add(null); + + assertThat(list.size()).isEqualTo(1); + } + + @Test + public void testUpdateExistingValue() { + list.put(TEST_KEY_0, TEST_VALUE); + assertThat(list.update(TEST_KEY_0, key -> "")).isPresent().hasValue(""); + } + + @Test + public void testUpdateExistingValueOverIndex() { + list.put(TEST_KEY_0, TEST_VALUE); + assertThat(list.update(TEST_KEY_1, key -> "")).isNotPresent(); + assertThat(list.update(TEST_KEY_LESS_ZERO, key -> "")).isNotPresent(); + } + + @Test + public void testUpdateExistingValueOrPutDefault() { + list.put(TEST_KEY_0, TEST_VALUE); + assertThat(list.update(TEST_KEY_0, key -> "", () -> TEST_DEFAULT_VALUE)).isEqualTo(""); + assertThat(list.update(TEST_KEY_1, key -> "", () -> TEST_DEFAULT_VALUE)).isEqualTo(TEST_DEFAULT_VALUE); + } + +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java index 4795b7631..cede73548 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java @@ -1,21 +1,81 @@ package org.ethereum.beacon.db.source; import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.Test; +import org.junit.*; -import static org.assertj.core.api.Java6Assertions.assertThatThrownBy; +import javax.annotation.Nonnull; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; public class LinkedDataSourceTest { + private LinkedDataSource dataSource; + + @Before + public void setUp() { + dataSource = new LinkedDataSource() { + public Optional get(@Nonnull String key) { + return Optional.empty(); + } + + public void put(@Nonnull String key, @Nonnull String value) { + + } + + public void remove(@Nonnull String key) { + + } + + public void flush() { + + } + + @Nonnull + public DataSource getUpstream() { + return null; + } + }; + + assertThat(dataSource).isNotNull(); + } + @Test public void testSetUpstream() { - final LinkedDataSource dataSource = new WriteCacheImpl<>(new HashMapDataSource<>()); assertThatThrownBy(() -> dataSource.setUpstream(new HashMapDataSource<>())).isInstanceOf(UnsupportedOperationException.class); } @Test - public void testValidSourceCreation() { - assertThatThrownBy(() -> new WriteCacheImpl(null)).isInstanceOf(NullPointerException.class); + public void testGetNullUpstream() { + assertThat(dataSource.getUpstream()).isNull(); } + @Test + public void testGetUpstream() { + dataSource = new LinkedDataSource() { + public Optional get(@Nonnull String key) { + return Optional.empty(); + } + + public void put(@Nonnull String key, @Nonnull String value) { + + } + + public void remove(@Nonnull String key) { + + } + + public void flush() { + + } + + @Nonnull + public DataSource getUpstream() { + return new HashMapDataSource<>(); + } + }; + assertThat(dataSource).isNotNull(); + assertThat(dataSource.getUpstream()).isNotNull(); + } } From fcd09971731e0af7009531d4b70c7e77056eb8f2 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Thu, 15 Aug 2019 12:37:08 +0300 Subject: [PATCH 12/44] Remove WriteCacheImplTest --- .../beacon/db/source/WriteCacheImplTest.java | 25 ------------------- 1 file changed, 25 deletions(-) delete mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java deleted file mode 100644 index c5057f54d..000000000 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/WriteCacheImplTest.java +++ /dev/null @@ -1,25 +0,0 @@ -package org.ethereum.beacon.db.source; - -import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.Test; - -import static org.assertj.core.api.Assertions.assertThat; - -public class WriteCacheImplTest { - - private final String TEST_KEY = "test_key"; - - @Test - public void testGet() { - final WriteCacheImpl dataSource = new WriteCacheImpl<>(new HashMapDataSource<>()); - assertThat(dataSource).isNotNull(); - assertThat(dataSource.get(TEST_KEY)).isEmpty(); - } - - @Test - public void testGetCacheEntry() { - final WriteCacheImpl dataSource = new WriteCacheImpl<>(new HashMapDataSource<>()); - assertThat(dataSource).isNotNull(); - assertThat(dataSource.getCacheEntry(TEST_KEY)).isEmpty(); - } -} From d519feee705e7e234b10f9be2654b1cdae7d5020 Mon Sep 17 00:00:00 2001 From: Mikhail Kalinin Date: Fri, 16 Aug 2019 13:29:56 +0600 Subject: [PATCH 13/44] Avoid unnecessary merklisation of initial deposits (#171) * Avoid unnecessary merklisation of initial deposits * Put a comment on why initial deposits are not verified --- .../consensus/spec/GenesisFunction.java | 25 ++++++++++--------- .../InitialStateTransitionTest.java | 2 +- .../beacon/pow/AbstractDepositContract.java | 14 +++++++---- 3 files changed, 23 insertions(+), 18 deletions(-) diff --git a/consensus/src/main/java/org/ethereum/beacon/consensus/spec/GenesisFunction.java b/consensus/src/main/java/org/ethereum/beacon/consensus/spec/GenesisFunction.java index 540c2720c..286d7a603 100644 --- a/consensus/src/main/java/org/ethereum/beacon/consensus/spec/GenesisFunction.java +++ b/consensus/src/main/java/org/ethereum/beacon/consensus/spec/GenesisFunction.java @@ -55,18 +55,19 @@ default BeaconState initialize_beacon_state_from_eth1( state.setLatestBlockHeader(get_block_header(get_empty_block())); // Process deposits - for (int index = 0; index < deposits.size(); index++) { - Deposit deposit = deposits.get(index); - ReadList deposit_data_list = - ReadList.wrap( - deposits.stream().map(Deposit::getData).limit(index + 1).collect(Collectors.toList()), - Integer::new, - 1L << getConstants().getDepositContractTreeDepth().getIntValue()); - state.setEth1Data(new Eth1Data( - hash_tree_root(deposit_data_list), UInt64.valueOf(deposits.size()), eth1_block_hash)); - verify_deposit(state, deposit); - process_deposit(state, deposit); - } + ReadList deposit_data_list = + ReadList.wrap( + deposits.stream().map(Deposit::getData).collect(Collectors.toList()), + Integer::new, + 1L << getConstants().getDepositContractTreeDepth().getIntValue()); + state.setEth1Data(new Eth1Data( + hash_tree_root(deposit_data_list), UInt64.valueOf(deposits.size()), eth1_block_hash)); + + // according to the spec deposits are verified before processing + // but this is redundant for genesis initialisation + // since passed deposits are created by our own code + // hence, we are able to avoid verification which saves us some computational resources + deposits.forEach(deposit -> process_deposit(state, deposit)); // Process activations for (ValidatorIndex index : state.getValidators().size().iterateFromZero()) { diff --git a/consensus/src/test/java/org/ethereum/beacon/consensus/transition/InitialStateTransitionTest.java b/consensus/src/test/java/org/ethereum/beacon/consensus/transition/InitialStateTransitionTest.java index 4aff42278..dd0f5410d 100644 --- a/consensus/src/test/java/org/ethereum/beacon/consensus/transition/InitialStateTransitionTest.java +++ b/consensus/src/test/java/org/ethereum/beacon/consensus/transition/InitialStateTransitionTest.java @@ -48,6 +48,6 @@ public void handleChainStartCorrectly() { .plus(spec.getConstants().getSecondsPerDay().times(2)); assertThat(initialState.getGenesisTime()).isEqualTo(expectedTime); - assertThat(initialState.getEth1Data()).isEqualTo(Eth1Data.EMPTY); + assertThat(initialState.getEth1Data()).isEqualTo(eth1Data); } } diff --git a/pow/core/src/main/java/org/ethereum/beacon/pow/AbstractDepositContract.java b/pow/core/src/main/java/org/ethereum/beacon/pow/AbstractDepositContract.java index f898b771a..824b4fdad 100644 --- a/pow/core/src/main/java/org/ethereum/beacon/pow/AbstractDepositContract.java +++ b/pow/core/src/main/java/org/ethereum/beacon/pow/AbstractDepositContract.java @@ -100,12 +100,16 @@ protected synchronized void newDeposits(List eventDataList, by } private void tryChainStart(byte[] blockHash, long blockTimestamp) { + // use fake proof for initial deposits to avoid of unnecessary merklizing + List fakeProof = + Collections.nCopies( + spec.getConstants().getDepositContractTreeDepthPlusOne().getIntValue(), Hash32.ZERO); // instantiate initial deposits - List genesisDeposits = new ArrayList<>(); - for (int i = 0; i < initialDeposits.size(); i++) { - genesisDeposits.add( - Deposit.create(tree.getProof(i, initialDeposits.size()), initialDeposits.get(i))); - } + List genesisDeposits = + initialDeposits.stream() + .map(data -> Deposit.create(fakeProof, data)) + .collect(Collectors.toList()); + try { // check if genesis conditions met Eth1Data genesisEth1Data = From 9a4aac2a33a4d0f37ec47dfb3749635bbdd5dd4f Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Mon, 26 Aug 2019 21:38:12 +0300 Subject: [PATCH 14/44] JUnit5 and db tests --- db/core/build.gradle | 13 +- .../org/ethereum/beacon/db/DatabaseTest.java | 98 ++++++++++++++ .../beacon/db/EngineDrivenDatabaseTest.java | 121 ++++++++--------- .../beacon/db/InMemoryDatabaseTest.java | 15 +-- .../beacon/db/RocksDbDrivenDatabaseTest.java | 60 +++++---- .../beacon/db/XorKeyDatabaseTest.java | 95 +++++++------- .../EmptyBytesValueGenerator.java | 16 --- .../configuration/EmptyFunctionGenerator.java | 17 --- .../HashMapDatasourceGenerator.java | 17 --- .../beacon/db/rocksdb/RocksDbSourceTest.java | 43 +++--- .../source/AbstractLinkedDataSourceTest.java | 7 +- .../beacon/db/source/CodecSourceTest.java | 122 +++++++++++------- .../beacon/db/source/HoleyListTest.java | 5 +- .../db/source/LinkedDataSourceTest.java | 4 +- .../db/source/impl/DataSourceListTest.java | 75 +++++------ .../source/impl/DelegateDataSourceTest.java | 23 ++-- .../db/source/impl/HashMapHoleyListTest.java | 76 ++++++----- .../db/source/impl/MemSizeEvaluatorTest.java | 7 +- .../db/source/impl/XorDataSourceTest.java | 13 +- .../beacon/db/util/AutoCloseableLockTest.java | 51 ++++++++ 20 files changed, 504 insertions(+), 374 deletions(-) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java delete mode 100644 db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyBytesValueGenerator.java delete mode 100644 db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyFunctionGenerator.java delete mode 100644 db/core/src/test/java/org/ethereum/beacon/db/configuration/HashMapDatasourceGenerator.java create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/util/AutoCloseableLockTest.java diff --git a/db/core/build.gradle b/db/core/build.gradle index d888d3e63..5b5ab3f82 100644 --- a/db/core/build.gradle +++ b/db/core/build.gradle @@ -1,10 +1,17 @@ dependencies { - api project(':types') + api(project(':types')) { + exclude group: 'junit' + } api project(':crypto') api "org.rocksdb:rocksdbjni" api "com.googlecode.concurrent-locks:concurrent-locks" - testImplementation 'com.pholser:junit-quickcheck-core:0.7' - testImplementation 'ru.vyarus:generics-resolver:3.0.0' + testImplementation 'org.junit.jupiter:junit-jupiter:5.5.1' + + test { + useJUnitPlatform { + excludeTags 'FIX' + } + } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java new file mode 100644 index 000000000..1a9f7a8ca --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -0,0 +1,98 @@ +package org.ethereum.beacon.db; + +import org.ethereum.beacon.db.source.DataSource; +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.jupiter.api.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.*; +import tech.pegasys.artemis.util.bytes.BytesValue; + +import java.util.stream.Stream; + +import static org.assertj.core.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.*; + +class DatabaseTest { + + @Test + void inMemoryDB() { + final Database database = Database.inMemoryDB(); + assertThat(database).isNotNull(); + } + + @Tag("FIX") + @ParameterizedTest + @MethodSource("invalidArgumentsProvider") + void testInvalidCreation(String path, long bufferLimitsInBytes) { + assertThatThrownBy(() -> Database.rocksDB(path, bufferLimitsInBytes)).isInstanceOf(NullPointerException.class); + } + + private static Stream invalidArgumentsProvider() { + return Stream.of( + Arguments.of(null, 0), + Arguments.of("", 0) + ); + } + + @ParameterizedTest + @MethodSource("validArgumentsProvider") + void testValidCreation(String path, long bufferLimitsInBytes) { + final Database database = Database.rocksDB(path, bufferLimitsInBytes); + assertThat(database).isNotNull(); + } + + private static Stream validArgumentsProvider() { + return Stream.of( + Arguments.of("/tmp", 0), + Arguments.of("/tmp", Long.MAX_VALUE), + Arguments.of("/tmp", Long.MIN_VALUE) + ); + } + + + private static final String TEST_STORAGE_NAME = "TEST_STORAGE_NAME"; + + private boolean committed; + private boolean closed; + private String storageName; + + @Test + void testDatabaseCommitCloseCreateStorage() { + final DataSource dataSource = new HashMapDataSource<>(); + committed = false; + closed = false; + storageName = null; + + final Database db = new Database() { + @Override + public DataSource createStorage(String name) { + storageName = name; + return dataSource; + } + + @Override + public void commit() { + committed = true; + } + + @Override + public void close() { + closed = true; + } + }; + + assertThat(db).isNotNull(); + final DataSource storage = db.createStorage(TEST_STORAGE_NAME); + assertThat(storage).isNotNull(); + assertThat(storage).isEqualTo(dataSource); + assertThat(storageName).isEqualTo(TEST_STORAGE_NAME); + + assertFalse(committed); + db.commit(); + assertTrue(committed); + + assertFalse(closed); + db.close(); + assertTrue(closed); + } +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java index 28f27f043..b8c01fd97 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java @@ -1,28 +1,17 @@ package org.ethereum.beacon.db; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Random; -import java.util.Set; -import javax.annotation.Nonnull; -import org.ethereum.beacon.db.source.DataSource; -import org.ethereum.beacon.db.source.StorageEngineSource; +import org.ethereum.beacon.db.source.*; import org.ethereum.beacon.db.source.impl.MemSizeEvaluators; -import org.junit.Ignore; -import org.junit.Test; -import tech.pegasys.artemis.util.bytes.Bytes32; -import tech.pegasys.artemis.util.bytes.BytesValue; +import org.junit.jupiter.api.*; +import tech.pegasys.artemis.util.bytes.*; import tech.pegasys.artemis.util.uint.UInt64; +import javax.annotation.Nonnull; +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + public class EngineDrivenDatabaseTest { @Test @@ -36,21 +25,21 @@ public void generalCasesAreCorrect() { storage.put(wrap("TWO"), wrap("SECOND")); assertTrue(engineSource.source.isEmpty()); - assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get()); - assertEquals(wrap("SECOND"), storage.get(wrap("TWO")).get()); - assertFalse(storage.get(wrap("THREE")).isPresent()); + assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get()); + assertThat(wrap("SECOND")).isEqualTo(storage.get(wrap("TWO")).get()); + assertThat(storage.get(wrap("THREE"))).isNotPresent(); db.commit(); - assertFalse(db.getWriteBuffer().getCacheEntry(wrap("ONE")).isPresent()); - assertFalse(db.getWriteBuffer().getCacheEntry(wrap("TWO")).isPresent()); - assertEquals(0L, db.getWriteBuffer().evaluateSize()); + assertThat(db.getWriteBuffer().getCacheEntry(wrap("ONE"))).isNotPresent(); + assertThat(db.getWriteBuffer().getCacheEntry(wrap("TWO"))).isNotPresent(); + assertThat(0L).isEqualTo(db.getWriteBuffer().evaluateSize()); assertTrue(engineSource.source.containsValue(wrap("FIRST"))); assertTrue(engineSource.source.containsValue(wrap("SECOND"))); - assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get()); - assertEquals(wrap("SECOND"), storage.get(wrap("TWO")).get()); - assertFalse(storage.get(wrap("THREE")).isPresent()); + assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get()); + assertThat(wrap("SECOND")).isEqualTo(storage.get(wrap("TWO")).get()); + assertThat(storage.get(wrap("THREE"))).isNotPresent(); storage.remove(wrap("SECOND")); storage.put(wrap("THREE"), wrap("THIRD")); @@ -60,9 +49,9 @@ public void generalCasesAreCorrect() { assertTrue(engineSource.source.containsValue(wrap("SECOND"))); assertFalse(engineSource.source.containsValue(wrap("THIRD"))); - assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get()); - assertFalse(storage.get(wrap("TWO")).isPresent()); - assertEquals(wrap("THIRD"), storage.get(wrap("THREE")).get()); + assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get()); + assertThat(storage.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("THIRD")).isEqualTo(storage.get(wrap("THREE")).get()); db.commit(); @@ -70,9 +59,9 @@ public void generalCasesAreCorrect() { assertFalse(engineSource.source.containsValue(wrap("SECOND"))); assertTrue(engineSource.source.containsValue(wrap("THIRD"))); - assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get()); - assertFalse(storage.get(wrap("TWO")).isPresent()); - assertEquals(wrap("THIRD"), storage.get(wrap("THREE")).get()); + assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get()); + assertThat(storage.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("THIRD")).isEqualTo(storage.get(wrap("THREE")).get()); } @Test @@ -90,35 +79,35 @@ public void multipleStorageCase() { dos.put(wrap("FOUR"), wrap("DOS_FOURTH")); db.commit(); - assertEquals(wrap("FIRST"), uno.get(wrap("ONE")).get()); - assertEquals(wrap("SECOND"), uno.get(wrap("TWO")).get()); - assertEquals(wrap("SECOND"), dos.get(wrap("TWO")).get()); - assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get()); - assertEquals(wrap("DOS_FOURTH"), dos.get(wrap("FOUR")).get()); - assertFalse(uno.get(wrap("FOUR")).isPresent()); - assertFalse(dos.get(wrap("ONE")).isPresent()); - assertFalse(dos.get(wrap("THREE")).isPresent()); + assertThat(wrap("FIRST")).isEqualTo(uno.get(wrap("ONE")).get()); + assertThat(wrap("SECOND")).isEqualTo(uno.get(wrap("TWO")).get()); + assertThat(wrap("SECOND")).isEqualTo(dos.get(wrap("TWO")).get()); + assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get()); + assertThat(wrap("DOS_FOURTH")).isEqualTo(dos.get(wrap("FOUR")).get()); + assertThat(uno.get(wrap("FOUR"))).isNotPresent(); + assertThat(dos.get(wrap("ONE"))).isNotPresent(); + assertThat(dos.get(wrap("THREE"))).isNotPresent(); uno.remove(wrap("TWO")); dos.put(wrap("THREE"), wrap("DOS_THIRD")); - assertFalse(uno.get(wrap("TWO")).isPresent()); - assertEquals(wrap("DOS_THIRD"), dos.get(wrap("THREE")).get()); - assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get()); + assertThat(uno.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("DOS_THIRD")).isEqualTo(dos.get(wrap("THREE")).get()); + assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get()); db.commit(); - assertFalse(uno.get(wrap("TWO")).isPresent()); - assertEquals(wrap("DOS_THIRD"), dos.get(wrap("THREE")).get()); - assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get()); + assertThat(uno.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("DOS_THIRD")).isEqualTo(dos.get(wrap("THREE")).get()); + assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get()); dos.remove(wrap("FOUR")); uno.put(wrap("FOUR"), wrap("UNO_FOURTH")); - assertEquals(wrap("UNO_FOURTH"), uno.get(wrap("FOUR")).get()); - assertFalse(dos.get(wrap("FOUR")).isPresent()); + assertThat(wrap("UNO_FOURTH")).isEqualTo(uno.get(wrap("FOUR")).get()); + assertThat(dos.get(wrap("FOUR"))).isNotPresent(); db.commit(); - assertEquals(wrap("UNO_FOURTH"), uno.get(wrap("FOUR")).get()); - assertFalse(dos.get(wrap("FOUR")).isPresent()); + assertThat(wrap("UNO_FOURTH")).isEqualTo(uno.get(wrap("FOUR")).get()); + assertThat(dos.get(wrap("FOUR"))).isNotPresent(); } @Test @@ -142,28 +131,28 @@ public void checkBufferSizeFlusher() { // should be flushed now db.commit(); - assertEquals(4, engineSource.source.size()); - assertEquals(0L, db.getWriteBuffer().evaluateSize()); - assertFalse(db.getWriteBuffer().getCacheEntry(wrap("ONE")).isPresent()); - assertFalse(db.getWriteBuffer().getCacheEntry(wrap("TWO")).isPresent()); - assertFalse(db.getWriteBuffer().getCacheEntry(wrap("THREE")).isPresent()); - assertFalse(db.getWriteBuffer().getCacheEntry(wrap("FOUR")).isPresent()); + assertThat(4).isEqualTo(engineSource.source.size()); + assertThat(0L).isEqualTo(db.getWriteBuffer().evaluateSize()); + assertThat(db.getWriteBuffer().getCacheEntry(wrap("ONE"))).isNotPresent(); + assertThat(db.getWriteBuffer().getCacheEntry(wrap("TWO"))).isNotPresent(); + assertThat(db.getWriteBuffer().getCacheEntry(wrap("THREE"))).isNotPresent(); + assertThat(db.getWriteBuffer().getCacheEntry(wrap("FOUR"))).isNotPresent(); storage.put(wrap("FIVE"), Bytes32.random(rnd)); storage.put(wrap("SIX"), Bytes32.random(rnd)); - assertEquals( - 4 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd)), + assertThat( + 4 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))).isEqualTo( db.getWriteBuffer().evaluateSize()); storage.remove(wrap("FIVE")); - assertEquals( - 2 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd)), + assertThat( + 2 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))).isEqualTo( db.getWriteBuffer().evaluateSize()); } @Test - @Ignore + @Disabled public void checkWithConcurrentAccessTake1() throws InterruptedException { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource); @@ -204,11 +193,11 @@ public void checkWithConcurrentAccessTake1() throws InterruptedException { Set expectedValues = new HashSet<>(writtenToOne.values()); expectedValues.addAll(writtenToTwo.values()); - assertEquals(expectedValues, sourceValues); + assertThat(expectedValues).isEqualTo(sourceValues); } @Test - @Ignore + @Disabled public void checkWithConcurrentAccessTake2() throws InterruptedException { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java index 08b48c9d4..789cccc4a 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java @@ -1,25 +1,22 @@ package org.ethereum.beacon.db; -import com.pholser.junit.quickcheck.Property; -import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; import org.ethereum.beacon.db.source.DataSource; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; import tech.pegasys.artemis.util.bytes.BytesValue; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(JUnitQuickcheck.class) public class InMemoryDatabaseTest { - private final String TEST_KEY = "TEST_KEY"; - - @Property - public void testGetBackingDataSource() { + @ParameterizedTest + @ValueSource(strings = {"TEST_KEY"}) + public void testGetBackingDataSource(String param) { final InMemoryDatabase database = new InMemoryDatabase(); final DataSource dataSource = database.getBackingDataSource(); assertThat(dataSource).isNotNull(); - final BytesValue key = BytesValue.wrap(TEST_KEY.getBytes()); + final BytesValue key = BytesValue.wrap(param.getBytes()); final BytesValue value = BytesValue.EMPTY; dataSource.put(key, value); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java index 6cdccc574..50452b878 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java @@ -1,20 +1,18 @@ package org.ethereum.beacon.db; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; - -import java.io.IOException; import org.ethereum.beacon.db.source.DataSource; import org.ethereum.beacon.db.util.FileUtil; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.*; import tech.pegasys.artemis.util.bytes.BytesValue; +import java.io.IOException; + +import static org.assertj.core.api.Assertions.assertThat; + public class RocksDbDrivenDatabaseTest { - @After - @Before + @AfterEach + @BeforeEach public void cleanUp() throws IOException { FileUtil.removeRecursively("test-db"); } @@ -33,36 +31,36 @@ public void basicOperations() { dos.put(wrap("FOUR"), wrap("DOS_FOURTH")); db.commit(); - assertEquals(wrap("FIRST"), uno.get(wrap("ONE")).get()); - assertEquals(wrap("SECOND"), uno.get(wrap("TWO")).get()); - assertEquals(wrap("SECOND"), dos.get(wrap("TWO")).get()); - assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get()); - assertEquals(wrap("DOS_FOURTH"), dos.get(wrap("FOUR")).get()); - assertFalse(uno.get(wrap("FOUR")).isPresent()); - assertFalse(dos.get(wrap("ONE")).isPresent()); - assertFalse(dos.get(wrap("THREE")).isPresent()); - assertFalse(uno.get(wrap("FOUR")).isPresent()); + assertThat(wrap("FIRST")).isEqualTo(uno.get(wrap("ONE")).get()); + assertThat(wrap("SECOND")).isEqualTo(uno.get(wrap("TWO")).get()); + assertThat(wrap("SECOND")).isEqualTo(dos.get(wrap("TWO")).get()); + assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get()); + assertThat(wrap("DOS_FOURTH")).isEqualTo(dos.get(wrap("FOUR")).get()); + assertThat(uno.get(wrap("FOUR"))).isNotPresent(); + assertThat(dos.get(wrap("ONE"))).isNotPresent(); + assertThat(dos.get(wrap("THREE"))).isNotPresent(); + assertThat(uno.get(wrap("FOUR"))).isNotPresent(); uno.remove(wrap("TWO")); dos.put(wrap("THREE"), wrap("DOS_THIRD")); - assertFalse(uno.get(wrap("TWO")).isPresent()); - assertEquals(wrap("DOS_THIRD"), dos.get(wrap("THREE")).get()); - assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get()); + assertThat(uno.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("DOS_THIRD")).isEqualTo(dos.get(wrap("THREE")).get()); + assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get()); db.commit(); - assertFalse(uno.get(wrap("TWO")).isPresent()); - assertEquals(wrap("DOS_THIRD"), dos.get(wrap("THREE")).get()); - assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get()); + assertThat(uno.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("DOS_THIRD")).isEqualTo(dos.get(wrap("THREE")).get()); + assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get()); dos.remove(wrap("FOUR")); uno.put(wrap("FOUR"), wrap("UNO_FOURTH")); - assertEquals(wrap("UNO_FOURTH"), uno.get(wrap("FOUR")).get()); - assertFalse(dos.get(wrap("FOUR")).isPresent()); + assertThat(wrap("UNO_FOURTH")).isEqualTo(uno.get(wrap("FOUR")).get()); + assertThat(dos.get(wrap("FOUR"))).isNotPresent(); db.commit(); - assertEquals(wrap("UNO_FOURTH"), uno.get(wrap("FOUR")).get()); - assertFalse(dos.get(wrap("FOUR")).isPresent()); + assertThat(wrap("UNO_FOURTH")).isEqualTo(uno.get(wrap("FOUR")).get()); + assertThat(dos.get(wrap("FOUR"))).isNotPresent(); db.close(); } @@ -81,9 +79,9 @@ public void reopenWithoutFlush() { storage = db.createStorage("uno"); - assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get()); - assertEquals(wrap("SECOND"), storage.get(wrap("TWO")).get()); - assertEquals(wrap("THIRD"), storage.get(wrap("THREE")).get()); + assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get()); + assertThat(wrap("SECOND")).isEqualTo(storage.get(wrap("TWO")).get()); + assertThat(wrap("THIRD")).isEqualTo(storage.get(wrap("THREE")).get()); db.close(); } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java index 1a0fbf754..7d1902c23 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java @@ -1,61 +1,58 @@ package org.ethereum.beacon.db; -import com.pholser.junit.quickcheck.*; -import com.pholser.junit.quickcheck.runner.JUnitQuickcheck; -import org.ethereum.beacon.db.configuration.*; import org.ethereum.beacon.db.source.DataSource; -import org.junit.runner.RunWith; +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.jupiter.api.*; import tech.pegasys.artemis.util.bytes.BytesValue; import java.util.function.Function; import static org.assertj.core.api.Assertions.assertThat; -@RunWith(JUnitQuickcheck.class) public class XorKeyDatabaseTest { - private final String TEST_STORAGE_NAME = "TEST_STORAGE_NAME"; - private final String TEST_ENTITY_KEY = "TEST_ENTITY_KEY"; - - @Property - public void testCreateStorage(@From(HashMapDatasourceGenerator.class) DataSource<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> backingDataSource, - @From(EmptyFunctionGenerator.class) Function<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> sourceNameHasher) { - - final XorKeyDatabase database = new XorKeyDatabase(backingDataSource, sourceNameHasher) { - @Override - public void commit() { - } - - @Override - public void close() { - } - }; - - final DataSource storage = database.createStorage(TEST_STORAGE_NAME); - assertThat(storage).isNotNull(); - - final BytesValue key = BytesValue.wrap(TEST_ENTITY_KEY.getBytes()); - final BytesValue value = BytesValue.EMPTY; - storage.put(key, value); - assertThat(storage.get(key)).isPresent().hasValue(value); - } - - @Property - public void testGetBackingDataSource(@From(HashMapDatasourceGenerator.class) DataSource<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> backingDataSource, - @From(EmptyFunctionGenerator.class) Function<@From(EmptyBytesValueGenerator.class) BytesValue, @From(EmptyBytesValueGenerator.class) BytesValue> sourceNameHasher) { - - final XorKeyDatabase actual = new XorKeyDatabase(backingDataSource, sourceNameHasher) { - @Override - public void commit() { - } - - @Override - public void close() { - } - }; - - assertThat(actual).isNotNull(); - assertThat(actual.getBackingDataSource()).isNotNull(); - assertThat(actual.getBackingDataSource()).isEqualTo(backingDataSource); - } + private XorKeyDatabase db; + + @BeforeEach + public void setUp() { + final HashMapDataSource mapds = new HashMapDataSource<>(); + db = new XorKeyDatabase(mapds, Function.identity()) { + @Override + public void commit() { + } + + @Override + public void close() { + } + }; + } + + @Test + public void testCreateStorage_EmptyStorage() { + final DataSource storage1 = db.createStorage("Storage1"); + storage1.put(BytesValue.of(1, 2, 3), BytesValue.of(1, 4)); + assertThat(storage1.get(BytesValue.of(1, 2, 3))).isPresent(); + } + + @Test + public void testCreateStorage() { + final DataSource storage0 = db.createStorage("Storage1"); + storage0.put(BytesValue.of(1, 2, 3), BytesValue.of(1, 4)); + final DataSource storage1 = db.createStorage("Storage1"); + assertThat(storage1.get(BytesValue.of(1, 2, 3))).isPresent(); + } + + @Test + public void testCreateStorage_1() { + final DataSource storage0 = db.createStorage("Storage1"); + storage0.put(BytesValue.of(1, 2, 3), BytesValue.of(1, 4)); + final DataSource storage1 = db.createStorage("Storage2"); + assertThat(storage1.get(BytesValue.of(1, 2, 3))).isNotPresent(); + storage1.put(BytesValue.of(1, 2, 3), BytesValue.of(1, 4, 5)); + assertThat(storage1.get(BytesValue.of(1, 2, 3))).isPresent(); + assertThat(storage1.get(BytesValue.of(1, 2, 3)).get()).isEqualTo(BytesValue.of(1, 4, 5)); + + assertThat(storage0.get(BytesValue.of(1, 2, 3))).isPresent(); + assertThat(storage0.get(BytesValue.of(1, 2, 3)).get()).isEqualTo(BytesValue.of(1, 4)); + } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyBytesValueGenerator.java b/db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyBytesValueGenerator.java deleted file mode 100644 index c8f1fd75d..000000000 --- a/db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyBytesValueGenerator.java +++ /dev/null @@ -1,16 +0,0 @@ -package org.ethereum.beacon.db.configuration; - -import com.pholser.junit.quickcheck.generator.*; -import com.pholser.junit.quickcheck.random.SourceOfRandomness; -import tech.pegasys.artemis.util.bytes.BytesValue; - -public class EmptyBytesValueGenerator extends Generator { - public EmptyBytesValueGenerator() { - super(BytesValue.class); - } - - @Override - public BytesValue generate(SourceOfRandomness random, GenerationStatus status) { - return BytesValue.EMPTY; - } -} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyFunctionGenerator.java b/db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyFunctionGenerator.java deleted file mode 100644 index 1c1e59ac3..000000000 --- a/db/core/src/test/java/org/ethereum/beacon/db/configuration/EmptyFunctionGenerator.java +++ /dev/null @@ -1,17 +0,0 @@ -package org.ethereum.beacon.db.configuration; - -import com.pholser.junit.quickcheck.generator.*; -import com.pholser.junit.quickcheck.random.SourceOfRandomness; - -import java.util.function.Function; - -public class EmptyFunctionGenerator extends Generator { - public EmptyFunctionGenerator() { - super(Function.class); - } - - @Override - public Function generate(SourceOfRandomness random, GenerationStatus status) { - return Function.identity(); - } -} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/configuration/HashMapDatasourceGenerator.java b/db/core/src/test/java/org/ethereum/beacon/db/configuration/HashMapDatasourceGenerator.java deleted file mode 100644 index eb0f891f6..000000000 --- a/db/core/src/test/java/org/ethereum/beacon/db/configuration/HashMapDatasourceGenerator.java +++ /dev/null @@ -1,17 +0,0 @@ -package org.ethereum.beacon.db.configuration; - -import com.pholser.junit.quickcheck.generator.*; -import com.pholser.junit.quickcheck.random.SourceOfRandomness; -import org.ethereum.beacon.db.source.DataSource; -import org.ethereum.beacon.db.source.impl.HashMapDataSource; - -public class HashMapDatasourceGenerator extends Generator { - public HashMapDatasourceGenerator() { - super(DataSource.class); - } - - @Override - public HashMapDataSource generate(SourceOfRandomness random, GenerationStatus status) { - return new HashMapDataSource(); - } -} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java index ce9a837f5..a9fd15c65 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java @@ -1,22 +1,19 @@ package org.ethereum.beacon.db.rocksdb; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; +import org.ethereum.beacon.db.util.FileUtil; +import org.junit.jupiter.api.*; +import tech.pegasys.artemis.util.bytes.BytesValue; import java.io.IOException; import java.nio.file.Paths; -import java.util.HashMap; -import java.util.Map; -import org.ethereum.beacon.db.util.FileUtil; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import tech.pegasys.artemis.util.bytes.BytesValue; +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; public class RocksDbSourceTest { - @After - @Before + @AfterEach + @BeforeEach public void cleanUp() throws IOException { FileUtil.removeRecursively("test-db"); } @@ -28,8 +25,8 @@ public void basicOperations() { rocksDb.open(); rocksDb.put(wrap("ONE"), wrap("FIRST")); - assertFalse(rocksDb.get(wrap("TWO")).isPresent()); - assertEquals(wrap("FIRST"), rocksDb.get(wrap("ONE")).get()); + assertThat(rocksDb.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("FIRST")).isEqualTo(rocksDb.get(wrap("ONE")).get()); Map batch = new HashMap<>(); batch.put(wrap("ONE"), null); @@ -39,22 +36,22 @@ public void basicOperations() { rocksDb.batchUpdate(batch); - assertFalse(rocksDb.get(wrap("ONE")).isPresent()); - assertEquals(wrap("SECOND"), rocksDb.get(wrap("TWO")).get()); - assertEquals(wrap("THIRD"), rocksDb.get(wrap("THREE")).get()); - assertEquals(wrap("FOURTH"), rocksDb.get(wrap("FOUR")).get()); + assertThat(rocksDb.get(wrap("ONE"))).isNotPresent(); + assertThat(wrap("SECOND")).isEqualTo(rocksDb.get(wrap("TWO")).get()); + assertThat(wrap("THIRD")).isEqualTo(rocksDb.get(wrap("THREE")).get()); + assertThat(wrap("FOURTH")).isEqualTo(rocksDb.get(wrap("FOUR")).get()); rocksDb.remove(wrap("THREE")); - assertFalse(rocksDb.get(wrap("THREE")).isPresent()); + assertThat(rocksDb.get(wrap("THREE"))).isNotPresent(); rocksDb.close(); rocksDb.open(); - assertFalse(rocksDb.get(wrap("ONE")).isPresent()); - assertEquals(wrap("SECOND"), rocksDb.get(wrap("TWO")).get()); - assertFalse(rocksDb.get(wrap("THREE")).isPresent()); - assertEquals(wrap("FOURTH"), rocksDb.get(wrap("FOUR")).get()); - assertFalse(rocksDb.get(wrap("FIVE")).isPresent()); + assertThat(rocksDb.get(wrap("ONE"))).isNotPresent(); + assertThat(wrap("SECOND")).isEqualTo(rocksDb.get(wrap("TWO")).get()); + assertThat(rocksDb.get(wrap("THREE"))).isNotPresent(); + assertThat(wrap("FOURTH")).isEqualTo(rocksDb.get(wrap("FOUR")).get()); + assertThat(rocksDb.get(wrap("FIVE"))).isNotPresent(); rocksDb.close(); } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java index cc7fd769e..c7781f2ec 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java @@ -1,7 +1,7 @@ package org.ethereum.beacon.db.source; import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.*; +import org.junit.jupiter.api.*; import javax.annotation.Nonnull; import java.util.Optional; @@ -15,10 +15,9 @@ public class AbstractLinkedDataSourceTest { private final String TEST_FLUSH = "flush"; private final String TEST_DO_FLUSH = "do_flush"; - private AbstractLinkedDataSource dataSource; - @Before + @BeforeEach public void setUp() { dataSource = new AbstractLinkedDataSource(new HashMapDataSource<>()) { public Optional get(@Nonnull String key) { @@ -38,7 +37,7 @@ public void remove(@Nonnull String key) { } @Test - public void testValidSourceCreation() { + public void testInvalidSourceCreation() { assertThatThrownBy(() -> new AbstractLinkedDataSource(null) { public Optional get(@Nonnull Object key) { return Optional.empty(); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java index 581119da3..eaeaab107 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java @@ -1,98 +1,124 @@ package org.ethereum.beacon.db.source; import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.*; import java.util.function.Function; +import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; public class CodecSourceTest { - private final String TEST_KEY = "test_key"; - private final String TEST_VALUE = "test_value"; - private CodecSource source; - @Before + @BeforeEach public void setUp() { source = new CodecSource<>(new HashMapDataSource<>(), Function.identity(), Function.identity(), Function.identity()); assertThat(source).isNotNull(); - assertThat(source.get(TEST_KEY)).isNotPresent(); } - @Test - public void testValidSourceCreation() { - assertThatThrownBy(() -> new CodecSource(null, Function.identity(), Function.identity(), Function.identity())) + @ParameterizedTest + @MethodSource("nullArgumentsProvider") + public void testInvalidSourceCreation(DataSource ds, Function f1, Function f2, Function f3) { + assertThatThrownBy(() -> new CodecSource(ds, f1, f2, f3)) .isInstanceOf(NullPointerException.class); + } - assertThatThrownBy(() -> new CodecSource(new HashMapDataSource(), null, Function.identity(), Function.identity())) - .isInstanceOf(NullPointerException.class); + private static Stream nullArgumentsProvider() { + return Stream.of( + Arguments.of(null, Function.identity(), Function.identity(), Function.identity()), + Arguments.of(new HashMapDataSource(), null, Function.identity(), Function.identity()), + Arguments.of(new HashMapDataSource(), Function.identity(), null, Function.identity()), + Arguments.of(new HashMapDataSource(), Function.identity(), Function.identity(), null) + ); + } - assertThatThrownBy(() -> new CodecSource(new HashMapDataSource(), Function.identity(), null, Function.identity())) + @ParameterizedTest + @MethodSource("keyOnlyCodecSourceArgumentsProvider") + public void testInvalidKeyOnlyCreation(DataSource ds, Function f1) { + assertThatThrownBy(() -> new CodecSource.KeyOnly<>(ds, f1)) .isInstanceOf(NullPointerException.class); + } - assertThatThrownBy(() -> new CodecSource(new HashMapDataSource(), Function.identity(), Function.identity(), null)) - .isInstanceOf(NullPointerException.class); + private static Stream keyOnlyCodecSourceArgumentsProvider() { + return Stream.of( + Arguments.of(null, Function.identity()), + Arguments.of(new HashMapDataSource(), null) + ); + } - assertThatThrownBy(() -> new CodecSource.KeyOnly<>(null, Function.identity())) + @ParameterizedTest + @MethodSource("valueOnlyCodecSourceArgumentsProvider") + public void testInvalidValueOnlyCreation(DataSource ds, Function f1, Function f2) { + assertThatThrownBy(() -> new CodecSource.ValueOnly<>(ds, f1, f2)) .isInstanceOf(NullPointerException.class); + } - assertThatThrownBy(() -> new CodecSource.KeyOnly<>(new HashMapDataSource<>(), null)) - .isInstanceOf(NullPointerException.class); + private static Stream valueOnlyCodecSourceArgumentsProvider() { + return Stream.of( + Arguments.of(null, Function.identity(), Function.identity()), + Arguments.of(new HashMapDataSource(), null, Function.identity()), + Arguments.of(new HashMapDataSource(), Function.identity(), null) + ); + } - assertThatThrownBy(() -> new CodecSource.ValueOnly<>(null, Function.identity(), Function.identity())) - .isInstanceOf(NullPointerException.class); + @ParameterizedTest + @MethodSource("keyValueArgumentsProvider") + public void testPutGetRemove(String key, String value) { + assertThat(source.get(key)).isNotPresent(); - assertThatThrownBy(() -> new CodecSource.ValueOnly<>(new HashMapDataSource<>(), null, Function.identity())) - .isInstanceOf(NullPointerException.class); + source.put(key, value); + assertThat(source.get(key)).isPresent().hasValue(value); - assertThatThrownBy(() -> new CodecSource.ValueOnly<>(new HashMapDataSource<>(), Function.identity(), null)) - .isInstanceOf(NullPointerException.class); + source.remove(key); + assertThat(source.get(key)).isNotPresent(); } - @Test - public void testPutGetRemove() { - source.put(TEST_KEY, TEST_VALUE); - assertThat(source.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); - - source.remove(TEST_KEY); - assertThat(source.get(TEST_KEY)).isNotPresent(); + private static Stream keyValueArgumentsProvider() { + return Stream.of( + Arguments.of("test_key", "test_value") + ); } - @Test - public void testKeyConversion() { - source = new CodecSource<>(new HashMapDataSource<>(), key -> encode(key, TEST_KEY), Function.identity(), Function.identity()); + @ParameterizedTest + @MethodSource("keyValueArgumentsProvider") + public void testKeyConversion(String key, String value) { + source = new CodecSource<>(new HashMapDataSource<>(), k -> encode(k, key), Function.identity(), Function.identity()); assertThat(source).isNotNull(); - assertThat(source.get(TEST_KEY)).isNotPresent(); + assertThat(source.get(key)).isNotPresent(); - source.put(TEST_KEY, TEST_VALUE); - assertThat(source.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); + source.put(key, value); + assertThat(source.get(key)).isPresent().hasValue(value); } private String encode(String value, String valueModifier) { return value.concat(valueModifier); } - @Test - public void testValueTargetValueToUpValueConversion() { - source = new CodecSource<>(new HashMapDataSource<>(), key -> encode(key, TEST_KEY), key -> encode(key, TEST_VALUE), Function.identity()); + @ParameterizedTest + @MethodSource("keyValueArgumentsProvider") + public void testValueTargetValueToUpValueConversion(String key, String value) { + source = new CodecSource<>(new HashMapDataSource<>(), k -> encode(k, key), k -> encode(k, value), Function.identity()); assertThat(source).isNotNull(); - assertThat(source.get(TEST_KEY)).isNotPresent(); + assertThat(source.get(key)).isNotPresent(); - source.put(TEST_KEY, TEST_VALUE); - assertThat(source.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE.concat(TEST_VALUE)); + source.put(key, value); + assertThat(source.get(key)).isPresent().hasValue(value.concat(value)); } - @Test - public void testValueUpValueToTargetValueConversion() { - source = new CodecSource<>(new HashMapDataSource<>(), key -> encode(key, TEST_KEY), key -> encode(key, TEST_VALUE), key -> decode()); + @ParameterizedTest + @MethodSource("keyValueArgumentsProvider") + public void testValueUpValueToTargetValueConversion(String key, String value) { + source = new CodecSource<>(new HashMapDataSource<>(), k -> encode(k, key), k -> encode(k, value), k -> decode()); assertThat(source).isNotNull(); - assertThat(source.get(TEST_KEY)).isNotPresent(); + assertThat(source.get(key)).isNotPresent(); - source.put(TEST_KEY, TEST_VALUE); - assertThat(source.get(TEST_KEY)).isPresent().hasValue(""); + source.put(key, value); + assertThat(source.get(key)).isPresent().hasValue(""); } private String decode() { diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java index fe8f2f03d..1a0dfa391 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java @@ -1,6 +1,6 @@ package org.ethereum.beacon.db.source; -import org.junit.*; +import org.junit.jupiter.api.*; import java.util.*; @@ -16,7 +16,7 @@ public class HoleyListTest { private HoleyList list; - @Before + @BeforeEach public void setUp() { list = new HoleyList() { private final Map store = new HashMap<>(); @@ -50,7 +50,6 @@ public void testAdd() { @Test public void testAddNull() { list.put(TEST_KEY_0, TEST_VALUE); - final long indexToAdd = list.size(); list.add(null); assertThat(list.size()).isEqualTo(1); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java index cede73548..b5d0e0e00 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java @@ -1,7 +1,7 @@ package org.ethereum.beacon.db.source; import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.*; +import org.junit.jupiter.api.*; import javax.annotation.Nonnull; import java.util.Optional; @@ -13,7 +13,7 @@ public class LinkedDataSourceTest { private LinkedDataSource dataSource; - @Before + @BeforeEach public void setUp() { dataSource = new LinkedDataSource() { public Optional get(@Nonnull String key) { diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java index 16b3917e0..e68508aa4 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java @@ -1,38 +1,25 @@ package org.ethereum.beacon.db.source.impl; import org.ethereum.beacon.db.source.DataSource; -import org.junit.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.*; import tech.pegasys.artemis.util.bytes.BytesValue; import java.util.function.Function; +import java.util.stream.Stream; import static org.assertj.core.api.Assertions.*; public class DataSourceListTest { - private final BytesValue SIZE_KEY = BytesValue.fromHexString("FFFFFFFFFFFFFFFF"); - private final Long TEST_KEY_0 = 0L; - private final Long TEST_KEY_1 = 1L; - private final Long TEST_KEY_LESS_ZERO = -1L; - private final String TEST_VALUE = "test_value"; - private DataSourceList dataSourceList; - @Before + @BeforeEach public void setUp() { dataSourceList = new DataSourceList<>(new HashMapDataSource<>(), serialize(), deserialize()); assertThat(dataSourceList).isNotNull(); assertThat(dataSourceList.size()).isEqualTo(0); - assertThat(dataSourceList.get(TEST_KEY_0)).isNotPresent(); - } - - @Test - public void testValidSourceCreation() { - assertThatThrownBy(() -> new DataSourceList<>(new HashMapDataSource<>(), null, deserialize())) - .isInstanceOf(NullPointerException.class); - - assertThatThrownBy(() -> new DataSourceList<>(new HashMapDataSource<>(), serialize(), null)) - .isInstanceOf(NullPointerException.class); } private Function serialize() { @@ -43,41 +30,45 @@ private Function deserialize() { return key -> ""; } - @Test - public void testPutGetSizeSerialization() { - dataSourceList.put(TEST_KEY_0, TEST_VALUE); - assertThat(dataSourceList.size()).isEqualTo(1); - assertThat(dataSourceList.get(TEST_KEY_0)).isPresent().hasValue(""); + @ParameterizedTest + @MethodSource("nullArgumentsProvider") + public void testInvalidSourceCreation(DataSource ds, Function f1, Function f2) { + assertThatThrownBy(() -> new DataSourceList<>(ds, f1, f2)) + .isInstanceOf(NullPointerException.class); + } - dataSourceList.put(TEST_KEY_1, TEST_VALUE); - assertThat(dataSourceList.size()).isEqualTo(2); + private static Stream nullArgumentsProvider() { + return Stream.of( + Arguments.of(new HashMapDataSource<>(), null, Function.identity()), + Arguments.of(new HashMapDataSource<>(), Function.identity(), null) + ); } - @Test - public void testPutNull() { - dataSourceList.put(TEST_KEY_0, null); - assertThat(dataSourceList.size()).isEqualTo(0); - assertThat(dataSourceList.get(TEST_KEY_0)).isNotPresent(); + @ParameterizedTest + @MethodSource("putGetSizeArgumentsProvider") + public void testPutGetSizeSerialization(Long key, String value, int expectedSize) { + assertThat(dataSourceList.get(key)).isNotPresent(); + dataSourceList.put(key, value); + assertThat(dataSourceList.size()).isEqualTo(expectedSize); } - @Test - public void testPutOverSize() { - dataSourceList.put(TEST_KEY_1, TEST_VALUE); - assertThat(dataSourceList.size()).isEqualTo(2); + private static Stream putGetSizeArgumentsProvider() { + return Stream.of( + Arguments.of(0L, "test_value", 1), + Arguments.of(0L, null, 0), + Arguments.of(1L, "test_value", 2) + ); } @Test public void testGetOverIndex() { + final Long TEST_KEY_0 = 0L; + final Long TEST_KEY_1 = 1L; + final Long TEST_KEY_LESS_ZERO = -1L; + final String TEST_VALUE = "test_value"; + dataSourceList.put(TEST_KEY_0, TEST_VALUE); assertThat(dataSourceList.get(TEST_KEY_LESS_ZERO)).isEmpty(); assertThat(dataSourceList.get(TEST_KEY_1)).isEmpty(); } - - @Test - public void testSizeBySIZE_KEY() { - final DataSource dataSource = new HashMapDataSource<>(); - dataSource.put(SIZE_KEY, BytesValue.wrap("-1000".getBytes())); - dataSourceList = new DataSourceList<>(dataSource, serialize(), deserialize()); - assertThat(dataSourceList.size()).isEqualTo(0L); - } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java index 673a094bc..00e4aa0ba 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java @@ -1,6 +1,10 @@ package org.ethereum.beacon.db.source.impl; -import org.junit.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.*; + +import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Java6Assertions.assertThatThrownBy; @@ -13,7 +17,7 @@ public class DelegateDataSourceTest { private DelegateDataSource delegateDataSource; - @Before + @BeforeEach public void setUp() { delegateDataSource = new DelegateDataSource<>(new HashMapDataSource<>()); assertThat(delegateDataSource).isNotNull(); @@ -28,14 +32,17 @@ public void testPutGetRemove() { assertThat(delegateDataSource.get(TEST_KEY)).isNotPresent(); } - @Test - public void testNullKey() { - assertThatThrownBy(() -> delegateDataSource.put(null, TEST_VALUE)).isInstanceOf(NullPointerException.class); + @ParameterizedTest + @MethodSource("nullArgumentsProvider") + public void testInvalidSourceCreation(String key, String value) { + assertThatThrownBy(() -> delegateDataSource.put(key, value)).isInstanceOf(NullPointerException.class); } - @Test - public void testNullValue() { - assertThatThrownBy(() -> delegateDataSource.put(TEST_KEY, null)).isInstanceOf(NullPointerException.class); + private static Stream nullArgumentsProvider() { + return Stream.of( + Arguments.of(null, "test_value"), + Arguments.of("test_key", null) + ); } @Test diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java index 94294767a..74908cf32 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java @@ -1,49 +1,73 @@ package org.ethereum.beacon.db.source.impl; import org.ethereum.beacon.db.source.HoleyList; -import org.junit.*; +import org.junit.jupiter.api.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.*; + +import java.util.stream.Stream; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; public class HashMapHoleyListTest { - private final Long TEST_KEY = 0L; - private final Long TEST_KEY_1 = 1L; - private final Long TEST_KEY_LESS_ZERO = -1L; - private final String TEST_VALUE = "test_value"; - private final String TEST_VALUE_NEW = "NewTestValue"; - private HoleyList map; - @Before + @BeforeEach public void setUp() { map = new HashMapHoleyList<>(); assertThat(map).isNotNull(); assertThat(map.size()).isEqualTo(0L); } - @Test - public void testSize() { - map.put(TEST_KEY, TEST_VALUE); - assertThat(map.size()).isEqualTo(1L); + @ParameterizedTest + @MethodSource("keyValueArgumentsProvider") + public void testPutSize(Long key, String value, Long size) { + map.put(key, value); + assertThat(map.size()).isEqualTo(size); } - @Test - public void testPutNullValue() { - map.put(TEST_KEY, null); - assertThat(map.size()).isEqualTo(0L); - assertThat(map.get(TEST_KEY)).isNotPresent(); + private static Stream keyValueArgumentsProvider() { + return Stream.of( + Arguments.of(0L, "test_value", 1L), + Arguments.of(0L, null, 0L) + ); } - @Test - public void testPutGet() { - map.put(TEST_KEY, TEST_VALUE); - assertThat(map.size()).isEqualTo(1L); - assertThat(map.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); + @ParameterizedTest + @MethodSource("keyValueGetArgumentsProvider") + public void testValidGet(Long key, String value) { + map.put(key, value); + assertThat(map.get(key)).isPresent().hasValue(value); + } + + private static Stream keyValueGetArgumentsProvider() { + return Stream.of( + Arguments.of(0L, "test_value") + ); + } + + @ParameterizedTest + @MethodSource("invalidKeyArgumentsProvider") + public void testGetOverIndex(Long key, String value, Long wrongKey) { + map.put(key, value); + assertThat(map.get(wrongKey)).isNotPresent(); + } + + private static Stream invalidKeyArgumentsProvider() { + return Stream.of( + Arguments.of(0L, "test_value", 1L), + Arguments.of(0L, "test_value", -1L) + ); } @Test public void testPutSameKey() { + final Long TEST_KEY = 0L; + final Long TEST_KEY_1 = 1L; + final String TEST_VALUE = "test_value"; + final String TEST_VALUE_NEW = "NewTestValue"; + map.put(TEST_KEY, TEST_VALUE); map.put(TEST_KEY_1, TEST_VALUE); assertThat(map.size()).isEqualTo(2L); @@ -52,12 +76,4 @@ public void testPutSameKey() { assertThat(map.size()).isEqualTo(2L); assertThat(map.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE_NEW); } - - @Test - public void testGetOverIndex() { - map.put(TEST_KEY, TEST_VALUE); - assertThat(map.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); - assertThat(map.get(TEST_KEY_1)).isNotPresent(); - assertThat(map.get(TEST_KEY_LESS_ZERO)).isNotPresent(); - } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java index 3a203e477..dc5fd67fa 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java @@ -1,9 +1,10 @@ package org.ethereum.beacon.db.source.impl; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; import tech.pegasys.artemis.util.bytes.BytesValue; +import static org.assertj.core.api.Assertions.assertThat; + public class MemSizeEvaluatorTest { @Test @@ -11,6 +12,6 @@ public void bytesValueEvaluator() { long evaluatedSize = MemSizeEvaluators.BytesValueEvaluator.apply(BytesValue.wrap(new byte[1000])); System.out.println("Evaluated size: " + evaluatedSize); - Assert.assertTrue(evaluatedSize > 1000); + assertThat(evaluatedSize).isGreaterThan(1000); } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java index 45d421953..bc228302d 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java @@ -1,16 +1,23 @@ package org.ethereum.beacon.db.source.impl; + import org.junit.Test; import tech.pegasys.artemis.util.bytes.BytesValue; - import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.Assertions.assertThat; + public class XorDataSourceTest { @Test - public void testValidSourceCreation() { + public void testInvalidSourceCreation() { assertThatThrownBy(() -> new XorDataSource<>(null, BytesValue.EMPTY)) .isInstanceOf(NullPointerException.class); - } + assertThatThrownBy(() -> new XorDataSource<>(null, null)) + .isInstanceOf(NullPointerException.class); + + assertThat(new XorDataSource<>(new HashMapDataSource<>(), null)).isNotNull(); + assertThat(new XorDataSource<>(new HashMapDataSource<>(), BytesValue.of(1,2,3))).isNotNull(); + } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/util/AutoCloseableLockTest.java b/db/core/src/test/java/org/ethereum/beacon/db/util/AutoCloseableLockTest.java new file mode 100644 index 000000000..ec3b65896 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/util/AutoCloseableLockTest.java @@ -0,0 +1,51 @@ +package org.ethereum.beacon.db.util; + +import org.junit.jupiter.api.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.*; + +import java.util.concurrent.locks.*; +import java.util.stream.Stream; + +import static org.assertj.core.api.Assertions.*; + +class AutoCloseableLockTest { + + @Tag("FIX") + @Test + void testInvalidCreation() { + assertThatThrownBy(() -> new AutoCloseableLock(null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> AutoCloseableLock.wrap(null)).isInstanceOf(NullPointerException.class); + } + + @ParameterizedTest + @MethodSource("creationArgumentsProvider") + void testValidCreation(Lock lock) { + final AutoCloseable result = new AutoCloseableLock(lock); + assertThat(result).isNotNull(); + } + + private static Stream creationArgumentsProvider() { + return Stream.of( + Arguments.of(new ReentrantLock()), + Arguments.of(new ReentrantReadWriteLock().writeLock()), + Arguments.of(new ReentrantReadWriteLock().readLock()) + ); + } + + @ParameterizedTest + @MethodSource("creationArgumentsProvider") + void wrap(Lock lock) { + final AutoCloseable result = AutoCloseableLock.wrap(lock); + assertThat(result).isNotNull(); + } + + @ParameterizedTest + @MethodSource("creationArgumentsProvider") + void testLockCloseCreation(Lock lock) { + //TODO: how to test? + final AutoCloseableLock result = new AutoCloseableLock(lock); + result.lock(); + result.close(); + } +} From b1b898e4758cb4059296c2ae485dc0974823ad57 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 28 Aug 2019 15:41:33 +0300 Subject: [PATCH 15/44] SingleValueSourceTest/AutoclosableLockTest --- .../db/source/SingleValueSourceTest.java | 138 ++++++++++++++++++ .../beacon/db/util/AutoCloseableLockTest.java | 57 +++++++- 2 files changed, 191 insertions(+), 4 deletions(-) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/SingleValueSourceTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/SingleValueSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/SingleValueSourceTest.java new file mode 100644 index 000000000..f8f6da4a4 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/SingleValueSourceTest.java @@ -0,0 +1,138 @@ +package org.ethereum.beacon.db.source; + +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.jupiter.api.*; + +import java.util.Optional; +import java.util.function.Function; + +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; + +public class SingleValueSourceTest { + + private final String TEST_KEY = "test_key"; + private final String TEST_VALUE = "test_value"; + private SingleValueSource source; + + + @BeforeEach + public void setUp() { + source = new SingleValueSource() { + String value; + + @Override + public Optional get() { + return Optional.ofNullable(value); + } + + @Override + public void set(String value) { + this.value = value; + } + + @Override + public void remove() { + this.value = null; + } + }; + + assertThat(source).isNotNull(); + assertThat(source.get()).isEmpty(); + } + + @Test + public void testInvalidFromDefaultDataSource() { + assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, null)) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, TEST_KEY)) + .isInstanceOf(NullPointerException.class); + + assertThat(SingleValueSource.fromDataSource(new HashMapDataSource<>(), null)).isNotNull(); + assertThat(SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY)).isNotNull(); + } + + @Test + public void testInvalidFromDataSource() { + assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, null, null, null)) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, null, null, Function.identity())) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, null, Function.identity(), null)) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, null, Function.identity(), Function.identity())) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(new HashMapDataSource<>(), null, null, null)) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, null, null)) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, Function.identity(), null)) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(new HashMapDataSource<>(), null, Function.identity(), null)) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(new HashMapDataSource<>(), null, null, Function.identity())) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, null, Function.identity())) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, TEST_KEY, Function.identity(), Function.identity())) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, TEST_KEY, Function.identity(), null)) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, TEST_KEY, null, Function.identity())) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, TEST_KEY, null, null)) + .isInstanceOf(NullPointerException.class); + + + assertThat(SingleValueSource.fromDataSource(new HashMapDataSource<>(), null, Function.identity(), Function.identity())).isNotNull(); + assertThat(SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, Function.identity(), Function.identity())).isNotNull(); + } + + @Test + public void testGetSetRemoveSourceValue() { + source = SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, Function.identity(), Function.identity()); + assertThat(source).isNotNull(); + assertThat(source.get()).isNotPresent(); + source.set(TEST_VALUE); + assertThat(source.get()).isPresent().hasValue(TEST_VALUE); + source.remove(); + assertThat(source.get()).isEmpty(); + } + + @Test + public void testGetSetRemoveWithEncode() { + source = SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, key -> encode(key, TEST_VALUE), Function.identity()); + source.set(TEST_VALUE); + assertThat(source.get()).isPresent().hasValue(TEST_VALUE.concat(TEST_VALUE)); + source.remove(); + assertThat(source.get()).isEmpty(); + } + + @Test + public void testGetSetRemoveWithEncodeDecode() { + source = SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, key -> encode(key, TEST_VALUE), key -> decode()); + source.set(TEST_VALUE); + assertThat(source.get()).isPresent().hasValue(""); + source.remove(); + assertThat(source.get()).isEmpty(); + } + + @Test + public void memSourceGetSetRemoveTest() { + source = SingleValueSource.memSource(); + assertThat(source).isNotNull(); + assertThat(source.get()).isNotPresent(); + source.set(TEST_VALUE); + assertThat(source.get()).isPresent().hasValue(TEST_VALUE); + source.remove(); + assertThat(source.get()).isEmpty(); + } + + private String encode(String value, String valueModifier) { + return value.concat(valueModifier); + } + + private String decode() { + return ""; + } +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/util/AutoCloseableLockTest.java b/db/core/src/test/java/org/ethereum/beacon/db/util/AutoCloseableLockTest.java index ec3b65896..5bf9b25e2 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/util/AutoCloseableLockTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/util/AutoCloseableLockTest.java @@ -1,9 +1,11 @@ package org.ethereum.beacon.db.util; +import org.jetbrains.annotations.NotNull; import org.junit.jupiter.api.*; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.*; +import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.*; import java.util.stream.Stream; @@ -40,12 +42,59 @@ void wrap(Lock lock) { assertThat(result).isNotNull(); } - @ParameterizedTest - @MethodSource("creationArgumentsProvider") - void testLockCloseCreation(Lock lock) { - //TODO: how to test? + private boolean locked; + private boolean unlocked; + + @Test + void testLockUnlockCloseCreation() { + locked = false; + unlocked = false; + + final Lock lock = new Lock() { + @Override + public void lock() { + locked = true; + } + + @Override + public void lockInterruptibly() { + + } + + @Override + public boolean tryLock() { + return false; + } + + @Override + public boolean tryLock(long time, @NotNull TimeUnit unit) { + return false; + } + + @Override + public void unlock() { + unlocked = true; + } + + @NotNull + @Override + public Condition newCondition() { + return null; + } + }; + final AutoCloseableLock result = new AutoCloseableLock(lock); + assertThat(locked).isFalse(); result.lock(); + assertThat(locked).isTrue(); + + assertThat(unlocked).isFalse(); result.close(); + assertThat(unlocked).isTrue(); + + unlocked = false; + assertThat(unlocked).isFalse(); + result.unlock(); + assertThat(unlocked).isTrue(); } } From 07391148b013d9707d14c6282268e7d4df16e5eb Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 28 Aug 2019 16:23:50 +0300 Subject: [PATCH 16/44] CacheSizeEvaluatorImplTest --- .../impl/CacheSizeEvaluatorImplTest.java | 58 +++++++++++++++++++ .../db/source/impl/XorDataSourceTest.java | 5 +- test/src/test/resources/eth2.0-spec-tests | 2 +- 3 files changed, 61 insertions(+), 4 deletions(-) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/impl/CacheSizeEvaluatorImplTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/CacheSizeEvaluatorImplTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/CacheSizeEvaluatorImplTest.java new file mode 100644 index 000000000..e2ad37552 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/CacheSizeEvaluatorImplTest.java @@ -0,0 +1,58 @@ +package org.ethereum.beacon.db.source.impl; + +import org.ethereum.beacon.db.source.CacheSizeEvaluator; +import org.junit.jupiter.api.*; + +import java.util.function.Function; + +import static org.assertj.core.api.Assertions.*; + +class CacheSizeEvaluatorImplTest { + + private static final long EMPTY_SIZE = 0L; + private static final String KEY = "key"; + private static final String VALUE = "value"; + + private CacheSizeEvaluator cacheSizeEvaluator; + private long createdStorageSize; + + @BeforeEach + void setUp() { + cacheSizeEvaluator = new CacheSizeEvaluatorImpl<>(key -> (long) key.length(), key -> (long) key.length()); + assertThat(cacheSizeEvaluator).isNotNull(); + createdStorageSize = cacheSizeEvaluator.getEvaluatedSize(); + assertThat(createdStorageSize).isEqualTo(EMPTY_SIZE); + } + + @Test + @Tag("FIX") + void testInvalidInstanceCreation() { + assertThatThrownBy(() -> new CacheSizeEvaluatorImpl<>(null, null)) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> new CacheSizeEvaluatorImpl<>(null, Function.identity())) + .isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> new CacheSizeEvaluatorImpl<>(Function.identity(), null)) + .isInstanceOf(NullPointerException.class); + } + + @Test + void added() { + cacheSizeEvaluator.added(KEY, VALUE); + final long newSize = createdStorageSize + KEY.length() + VALUE.length(); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(newSize); + } + + @Test + void removed() { + cacheSizeEvaluator.added(KEY, VALUE); + cacheSizeEvaluator.removed(KEY, VALUE); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(createdStorageSize); + } + + @Test + void reset() { + cacheSizeEvaluator.added(KEY, VALUE); + cacheSizeEvaluator.reset(); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(EMPTY_SIZE); + } +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java index bc228302d..d75b66c1c 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java @@ -3,14 +3,13 @@ import org.junit.Test; import tech.pegasys.artemis.util.bytes.BytesValue; -import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.*; public class XorDataSourceTest { @Test - public void testInvalidSourceCreation() { + public void testDataSourceCreation() { assertThatThrownBy(() -> new XorDataSource<>(null, BytesValue.EMPTY)) .isInstanceOf(NullPointerException.class); diff --git a/test/src/test/resources/eth2.0-spec-tests b/test/src/test/resources/eth2.0-spec-tests index ae6dd9011..aaa1673f5 160000 --- a/test/src/test/resources/eth2.0-spec-tests +++ b/test/src/test/resources/eth2.0-spec-tests @@ -1 +1 @@ -Subproject commit ae6dd9011df05fab8c7e651c09cf9c940973bf81 +Subproject commit aaa1673f508103e11304833e0456e4149f880065 From 9ba3288146920b2c8731823c244b0c1be9c1e43f Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 28 Aug 2019 16:54:22 +0300 Subject: [PATCH 17/44] DatabaseFlusherTest --- .../beacon/db/flush/DatabaseFlusherTest.java | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/flush/DatabaseFlusherTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/flush/DatabaseFlusherTest.java b/db/core/src/test/java/org/ethereum/beacon/db/flush/DatabaseFlusherTest.java new file mode 100644 index 000000000..7fd7690b0 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/flush/DatabaseFlusherTest.java @@ -0,0 +1,45 @@ +package org.ethereum.beacon.db.flush; + +import org.junit.jupiter.api.*; + +import static org.assertj.core.api.Assertions.assertThat; + +class DatabaseFlusherTest { + + private DatabaseFlusher databaseFlusher; + + private boolean flushed; + private boolean committed; + + @BeforeEach + void setUp() { + flushed = false; + committed = false; + + databaseFlusher = new DatabaseFlusher() { + @Override + public void flush() { + flushed = true; + } + + @Override + public void commit() { + committed = true; + } + }; + } + + @Test + void flush() { + assertThat(flushed).isFalse(); + databaseFlusher.flush(); + assertThat(flushed).isTrue(); + } + + @Test + void commit() { + assertThat(committed).isFalse(); + databaseFlusher.commit(); + assertThat(committed).isTrue(); + } +} From 352f9cb0366fc2be129360cb08506ce886ef906a Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 28 Aug 2019 18:28:44 +0300 Subject: [PATCH 18/44] InstantFlusherTest --- .../beacon/db/flush/InstantFlusherTest.java | 92 +++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/flush/InstantFlusherTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/flush/InstantFlusherTest.java b/db/core/src/test/java/org/ethereum/beacon/db/flush/InstantFlusherTest.java new file mode 100644 index 000000000..6b73a76f8 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/flush/InstantFlusherTest.java @@ -0,0 +1,92 @@ +package org.ethereum.beacon.db.flush; + +import org.ethereum.beacon.db.source.WriteBuffer; +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.jupiter.api.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.assertj.core.api.Assertions.*; + +class InstantFlusherTest { + + private boolean doFlush; + private boolean datasourceFlush; + private boolean instantFlushed; + + @BeforeEach + void setUp() { + doFlush = false; + datasourceFlush = false; + instantFlushed = false; + } + + @Test + @Tag("FIX") + void testInvalidInstanceCreation() { + assertThatThrownBy(() -> new InstantFlusher(null)).isInstanceOf(NullPointerException.class); + } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void flush(boolean upstreamFlush) { + final InstantFlusher instantFlusher = new InstantFlusher(new WriteBuffer(new HashMapDataSource() { + @Override + public void flush() { + datasourceFlush = true; + } + }, upstreamFlush) { + @Override + public void doFlush() { + doFlush = true; + } + }) { + @Override + public void flush() { + instantFlushed = true; + } + }; + + assertThat(instantFlusher).isNotNull(); + + assertThat(doFlush).isFalse(); + assertThat(datasourceFlush).isFalse(); + assertThat(instantFlushed).isFalse(); + instantFlusher.flush(); + assertThat(doFlush).isFalse(); + assertThat(datasourceFlush).isFalse(); + assertThat(instantFlushed).isTrue(); + } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void commit(boolean upstreamFlush) { + final InstantFlusher instantFlusher = new InstantFlusher(new WriteBuffer(new HashMapDataSource() { + @Override + public void flush() { + datasourceFlush = true; + } + }, upstreamFlush) { + @Override + public void doFlush() { + doFlush = true; + } + }) { + @Override + public void flush() { + instantFlushed = true; + } + }; + + assertThat(instantFlusher).isNotNull(); + + assertThat(doFlush).isFalse(); + assertThat(datasourceFlush).isFalse(); + assertThat(instantFlushed).isFalse(); + + instantFlusher.commit(); + assertThat(doFlush).isTrue(); + assertThat(datasourceFlush).isEqualTo(upstreamFlush); + assertThat(instantFlushed).isFalse(); + } +} From 7ef7ee2670ad6c171685ed644a2045a151efac19 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 28 Aug 2019 18:59:16 +0300 Subject: [PATCH 19/44] Refactor tests --- .../beacon/db/flush/InstantFlusherTest.java | 1 - .../db/source/SingleValueSourceTest.java | 105 ++++++++++-------- 2 files changed, 57 insertions(+), 49 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/flush/InstantFlusherTest.java b/db/core/src/test/java/org/ethereum/beacon/db/flush/InstantFlusherTest.java index 6b73a76f8..e4c56d245 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/flush/InstantFlusherTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/flush/InstantFlusherTest.java @@ -83,7 +83,6 @@ public void flush() { assertThat(doFlush).isFalse(); assertThat(datasourceFlush).isFalse(); assertThat(instantFlushed).isFalse(); - instantFlusher.commit(); assertThat(doFlush).isTrue(); assertThat(datasourceFlush).isEqualTo(upstreamFlush); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/SingleValueSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/SingleValueSourceTest.java index f8f6da4a4..19260a5b5 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/SingleValueSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/SingleValueSourceTest.java @@ -2,22 +2,24 @@ import org.ethereum.beacon.db.source.impl.HashMapDataSource; import org.junit.jupiter.api.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.*; import java.util.Optional; import java.util.function.Function; +import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -public class SingleValueSourceTest { +class SingleValueSourceTest { - private final String TEST_KEY = "test_key"; - private final String TEST_VALUE = "test_value"; + private static final String TEST_KEY = "test_key"; + private static final String TEST_VALUE = "test_value"; private SingleValueSource source; - @BeforeEach - public void setUp() { + void setUp() { source = new SingleValueSource() { String value; @@ -41,55 +43,62 @@ public void remove() { assertThat(source.get()).isEmpty(); } - @Test - public void testInvalidFromDefaultDataSource() { - assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, null)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, TEST_KEY)) - .isInstanceOf(NullPointerException.class); + @Tag("FIX") + @ParameterizedTest + @MethodSource("invalidFromDefaultDataSourceArgumentsProvider") + void testInvalidFromDefaultDataSource(DataSource ds, Object key) { + assertThatThrownBy(() -> SingleValueSource.fromDataSource(ds, key)).isInstanceOf(NullPointerException.class); + } - assertThat(SingleValueSource.fromDataSource(new HashMapDataSource<>(), null)).isNotNull(); + private static Stream invalidFromDefaultDataSourceArgumentsProvider() { + return Stream.of( + Arguments.of(null, null), + Arguments.of(null, TEST_KEY), + Arguments.of(new HashMapDataSource(), null) + ); + } + + @Test + void testValidFromDefaultDataSource() { assertThat(SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY)).isNotNull(); } + + @Tag("FIX") + @ParameterizedTest + @MethodSource("invalidFromDataSourceArgumentsProvider") + void testInvalidFromDataSource(DataSource ds, Object key, Function coder, Function decoder) { + assertThatThrownBy(() -> SingleValueSource.fromDataSource(ds, key, coder, decoder)).isInstanceOf(NullPointerException.class); + } + + private static Stream invalidFromDataSourceArgumentsProvider() { + return Stream.of( + Arguments.of(null, null, null, null), + Arguments.of(null, null, null, Function.identity()), + Arguments.of(null, null, Function.identity(), null), + Arguments.of(null, null, Function.identity(), Function.identity()), + Arguments.of(new HashMapDataSource<>(), null, null, null), + Arguments.of(new HashMapDataSource<>(), TEST_KEY, null, null), + Arguments.of(new HashMapDataSource<>(), TEST_KEY, Function.identity(), null), + Arguments.of(new HashMapDataSource<>(), null, Function.identity(), null), + Arguments.of(new HashMapDataSource<>(), null, null, Function.identity()), + Arguments.of(new HashMapDataSource<>(), TEST_KEY, null, Function.identity()), + Arguments.of(null, TEST_KEY, Function.identity(), Function.identity()), + Arguments.of(null, TEST_KEY, Function.identity(), null), + Arguments.of(null, TEST_KEY, null, Function.identity()), + Arguments.of(null, TEST_KEY, null, null), + Arguments.of(new HashMapDataSource<>(), null, Function.identity(), Function.identity()) + ); + } + + @Test - public void testInvalidFromDataSource() { - assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, null, null, null)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, null, null, Function.identity())) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, null, Function.identity(), null)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, null, Function.identity(), Function.identity())) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(new HashMapDataSource<>(), null, null, null)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, null, null)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, Function.identity(), null)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(new HashMapDataSource<>(), null, Function.identity(), null)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(new HashMapDataSource<>(), null, null, Function.identity())) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, null, Function.identity())) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, TEST_KEY, Function.identity(), Function.identity())) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, TEST_KEY, Function.identity(), null)) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, TEST_KEY, null, Function.identity())) - .isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> SingleValueSource.fromDataSource(null, TEST_KEY, null, null)) - .isInstanceOf(NullPointerException.class); - - - assertThat(SingleValueSource.fromDataSource(new HashMapDataSource<>(), null, Function.identity(), Function.identity())).isNotNull(); + void testValidFromDataSource() { assertThat(SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, Function.identity(), Function.identity())).isNotNull(); } @Test - public void testGetSetRemoveSourceValue() { + void testGetSetRemoveSourceValue() { source = SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, Function.identity(), Function.identity()); assertThat(source).isNotNull(); assertThat(source.get()).isNotPresent(); @@ -100,7 +109,7 @@ public void testGetSetRemoveSourceValue() { } @Test - public void testGetSetRemoveWithEncode() { + void testGetSetRemoveWithEncode() { source = SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, key -> encode(key, TEST_VALUE), Function.identity()); source.set(TEST_VALUE); assertThat(source.get()).isPresent().hasValue(TEST_VALUE.concat(TEST_VALUE)); @@ -109,7 +118,7 @@ public void testGetSetRemoveWithEncode() { } @Test - public void testGetSetRemoveWithEncodeDecode() { + void testGetSetRemoveWithEncodeDecode() { source = SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, key -> encode(key, TEST_VALUE), key -> decode()); source.set(TEST_VALUE); assertThat(source.get()).isPresent().hasValue(""); @@ -118,7 +127,7 @@ public void testGetSetRemoveWithEncodeDecode() { } @Test - public void memSourceGetSetRemoveTest() { + void memSourceGetSetRemoveTest() { source = SingleValueSource.memSource(); assertThat(source).isNotNull(); assertThat(source.get()).isNotPresent(); From 702371706961e709113603c9eccdc0cf46f52a0b Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 4 Sep 2019 13:36:10 +0300 Subject: [PATCH 20/44] test: add BufferSizeObserverTest. Exclude junit4 from db project dependencies. --- db/core/build.gradle | 5 + .../beacon/db/EngineDrivenDatabaseTest.java | 12 +- .../beacon/db/InMemoryDatabaseTest.java | 4 +- .../beacon/db/RocksDbDrivenDatabaseTest.java | 8 +- .../beacon/db/XorKeyDatabaseTest.java | 10 +- .../db/flush/BufferSizeObserverTest.java | 121 ++++++++++++++++++ .../beacon/db/rocksdb/RocksDbSourceTest.java | 6 +- .../source/AbstractLinkedDataSourceTest.java | 12 +- .../beacon/db/source/CodecSourceTest.java | 18 +-- .../beacon/db/source/HoleyListTest.java | 14 +- .../db/source/LinkedDataSourceTest.java | 10 +- .../db/source/impl/DataSourceListTest.java | 10 +- .../source/impl/DelegateDataSourceTest.java | 10 +- .../db/source/impl/HashMapHoleyListTest.java | 12 +- .../db/source/impl/MemSizeEvaluatorTest.java | 4 +- .../db/source/impl/XorDataSourceTest.java | 6 +- 16 files changed, 194 insertions(+), 68 deletions(-) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java diff --git a/db/core/build.gradle b/db/core/build.gradle index 5b5ab3f82..4e763afb7 100644 --- a/db/core/build.gradle +++ b/db/core/build.gradle @@ -2,6 +2,7 @@ dependencies { api(project(':types')) { exclude group: 'junit' } + api project(':crypto') api "org.rocksdb:rocksdbjni" @@ -15,3 +16,7 @@ dependencies { } } } + +configurations { + testImplementation.exclude group: 'junit', module: 'junit' +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java index b8c01fd97..fc708f596 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java @@ -12,10 +12,10 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.*; -public class EngineDrivenDatabaseTest { +class EngineDrivenDatabaseTest { @Test - public void generalCasesAreCorrect() { + void generalCasesAreCorrect() { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource); @@ -65,7 +65,7 @@ public void generalCasesAreCorrect() { } @Test - public void multipleStorageCase() { + void multipleStorageCase() { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource); @@ -111,7 +111,7 @@ public void multipleStorageCase() { } @Test - public void checkBufferSizeFlusher() { + void checkBufferSizeFlusher() { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.create(engineSource, 512); @@ -153,7 +153,7 @@ public void checkBufferSizeFlusher() { @Test @Disabled - public void checkWithConcurrentAccessTake1() throws InterruptedException { + void checkWithConcurrentAccessTake1() throws InterruptedException { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource); @@ -198,7 +198,7 @@ public void checkWithConcurrentAccessTake1() throws InterruptedException { @Test @Disabled - public void checkWithConcurrentAccessTake2() throws InterruptedException { + void checkWithConcurrentAccessTake2() throws InterruptedException { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java index 789cccc4a..2c83eeac2 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java @@ -7,11 +7,11 @@ import static org.assertj.core.api.Assertions.assertThat; -public class InMemoryDatabaseTest { +class InMemoryDatabaseTest { @ParameterizedTest @ValueSource(strings = {"TEST_KEY"}) - public void testGetBackingDataSource(String param) { + void testGetBackingDataSource(String param) { final InMemoryDatabase database = new InMemoryDatabase(); final DataSource dataSource = database.getBackingDataSource(); assertThat(dataSource).isNotNull(); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java index 50452b878..bf6577f56 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java @@ -9,16 +9,16 @@ import static org.assertj.core.api.Assertions.assertThat; -public class RocksDbDrivenDatabaseTest { +class RocksDbDrivenDatabaseTest { @AfterEach @BeforeEach - public void cleanUp() throws IOException { + void cleanUp() throws IOException { FileUtil.removeRecursively("test-db"); } @Test - public void basicOperations() { + void basicOperations() { Database db = Database.rocksDB("test-db", -1); DataSource uno = db.createStorage("uno"); @@ -66,7 +66,7 @@ public void basicOperations() { } @Test - public void reopenWithoutFlush() { + void reopenWithoutFlush() { Database db = Database.rocksDB("test-db", -1); DataSource storage = db.createStorage("uno"); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java index 7d1902c23..98e398bd8 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java @@ -9,12 +9,12 @@ import static org.assertj.core.api.Assertions.assertThat; -public class XorKeyDatabaseTest { +class XorKeyDatabaseTest { private XorKeyDatabase db; @BeforeEach - public void setUp() { + void setUp() { final HashMapDataSource mapds = new HashMapDataSource<>(); db = new XorKeyDatabase(mapds, Function.identity()) { @Override @@ -28,14 +28,14 @@ public void close() { } @Test - public void testCreateStorage_EmptyStorage() { + void testCreateStorage_EmptyStorage() { final DataSource storage1 = db.createStorage("Storage1"); storage1.put(BytesValue.of(1, 2, 3), BytesValue.of(1, 4)); assertThat(storage1.get(BytesValue.of(1, 2, 3))).isPresent(); } @Test - public void testCreateStorage() { + void testCreateStorage() { final DataSource storage0 = db.createStorage("Storage1"); storage0.put(BytesValue.of(1, 2, 3), BytesValue.of(1, 4)); final DataSource storage1 = db.createStorage("Storage1"); @@ -43,7 +43,7 @@ public void testCreateStorage() { } @Test - public void testCreateStorage_1() { + void testCreateStorage_1() { final DataSource storage0 = db.createStorage("Storage1"); storage0.put(BytesValue.of(1, 2, 3), BytesValue.of(1, 4)); final DataSource storage1 = db.createStorage("Storage2"); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java b/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java new file mode 100644 index 000000000..5d4c6713e --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java @@ -0,0 +1,121 @@ +package org.ethereum.beacon.db.flush; + +import org.ethereum.beacon.db.source.WriteBuffer; +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.jupiter.api.*; + +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; +import static org.junit.jupiter.api.Assertions.assertTrue; + + +class BufferSizeObserverTest { + + private final String TEST_KEY = "TEST_KEY"; + private final String TEST_VALUE = "TEST_VALUE"; + private WriteBuffer buffer; + private WriteBuffer commitTrack; + private BufferSizeObserver observer; + + + @BeforeEach + void setUp() { + buffer = new WriteBuffer<>(new HashMapDataSource<>(), true); + commitTrack = new WriteBuffer<>(new HashMapDataSource<>(), true); + observer = new BufferSizeObserver(buffer, commitTrack, Long.MIN_VALUE); + assertThat(observer).isNotNull(); + observer = new BufferSizeObserver(buffer, commitTrack, Long.MAX_VALUE); + assertThat(observer).isNotNull(); + } + + @Test + void testBufferSizeObserverCreation() { + assertThat(new BufferSizeObserver(null, null, Long.MIN_VALUE)).isNotNull(); + assertThat(new BufferSizeObserver(null, new WriteBuffer(new HashMapDataSource(), true), Long.MIN_VALUE)).isNotNull(); + assertThat(new BufferSizeObserver(new WriteBuffer(new HashMapDataSource(), true), null, Long.MIN_VALUE)).isNotNull(); + + assertThat(new BufferSizeObserver(null, null, Long.MAX_VALUE)).isNotNull(); + assertThat(new BufferSizeObserver(null, new WriteBuffer(new HashMapDataSource(), true), Long.MAX_VALUE)).isNotNull(); + assertThat(new BufferSizeObserver(new WriteBuffer(new HashMapDataSource(), true), null, Long.MAX_VALUE)).isNotNull(); + } + + + @Test + void testCreate() { + String TEST_KEY_0 = "TEST_KEY_0"; + String TEST_VALUE_0 = "TEST_VALUE_0"; + String TEST_KEY_1 = "TEST_KEY_1"; + String TEST_VALUE_1 = "TEST_VALUE_1"; + String TEST_KEY_2 = "TEST_KEY_2"; + String TEST_VALUE_2 = "TEST_VALUE_2"; + String TEST_KEY_3 = "TEST_KEY_3"; + String TEST_VALUE_3 = "TEST_VALUE_3"; + String TEST_KEY_4 = "TEST_KEY_4"; + String TEST_VALUE_4 = "TEST_VALUE_4"; + String TEST_KEY_5 = "TEST_KEY_5"; + String TEST_VALUE_5 = "TEST_VALUE_5"; + + buffer = new WriteBuffer<>(new HashMapDataSource<>(), false); + observer = BufferSizeObserver.create(buffer, Long.MIN_VALUE); + buffer.put(TEST_KEY_0, TEST_VALUE_0); + buffer.put(TEST_KEY_1, TEST_VALUE_1); + buffer.put(TEST_KEY_2, TEST_VALUE_2); + buffer.put(TEST_KEY_3, TEST_VALUE_3); + buffer.put(TEST_KEY_4, TEST_VALUE_4); + + assertThatThrownBy(() -> buffer.put(null, null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> buffer.put("NOT_NULL", null)).isInstanceOf(NullPointerException.class); + + assertThat(buffer.get(TEST_KEY_0)).isPresent(); + assertThat(buffer.getCacheEntry(TEST_KEY_0)).isPresent(); + assertTrue(buffer.evaluateSize() >= Long.MIN_VALUE, "Needed db flush"); + + observer.flush(); + assertThat(buffer.getCacheEntry(TEST_KEY_0)).isNotPresent(); + assertThat(buffer.getUpstream().get(TEST_KEY_0)).isPresent(); + + buffer.put(TEST_KEY_5, TEST_VALUE_5); + + assertThat(buffer.getUpstream().get(TEST_KEY_5)).isNotPresent(); + assertThat(buffer.getCacheEntry(TEST_KEY_5)).isPresent(); + + observer.commit(); + assertThat(buffer.getUpstream().get(TEST_KEY_5)).isPresent(); + assertThat(buffer.getUpstream().get(TEST_KEY_5)).hasValue(TEST_VALUE_5); + + } + + @Test + void testFlush() { + buffer.put(TEST_KEY, TEST_VALUE); + assertThat(buffer.get(TEST_KEY)).isPresent(); + assertThat(buffer.get(TEST_KEY)).hasValue(TEST_VALUE); + + observer.flush(); + assertThat(buffer.getUpstream().get(TEST_KEY)).isPresent(); + assertThat(buffer.getUpstream().get(TEST_KEY)).hasValue(TEST_VALUE); + + buffer.getUpstream().remove(TEST_KEY); + assertThat(buffer.get(TEST_KEY)).isNotPresent(); + assertThat(buffer.getUpstream().get(TEST_KEY)).isNotPresent(); + + } + + @Test + void testCommit() { + commitTrack.put(TEST_KEY, TEST_VALUE); + assertThat(commitTrack.get(TEST_KEY)).isPresent(); + assertThat(commitTrack.get(TEST_KEY)).hasValue(TEST_VALUE); + assertThat(commitTrack.getUpstream().get(TEST_KEY)).isNotPresent(); + + observer.commit(); + assertThat(commitTrack.get(TEST_KEY)).isPresent(); + assertThat(commitTrack.getUpstream().get(TEST_KEY)).isPresent(); + assertThat(commitTrack.getUpstream().get(TEST_KEY)).hasValue(TEST_VALUE); + + commitTrack.getUpstream().remove(TEST_KEY); + assertThat(commitTrack.get(TEST_KEY)).isNotPresent(); + assertThat(commitTrack.getUpstream().get(TEST_KEY)).isNotPresent(); + assertThat(buffer.getUpstream().get(TEST_KEY)).isNotPresent(); + } +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java index a9fd15c65..1bdbafe6c 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java @@ -10,16 +10,16 @@ import static org.assertj.core.api.Assertions.assertThat; -public class RocksDbSourceTest { +class RocksDbSourceTest { @AfterEach @BeforeEach - public void cleanUp() throws IOException { + void cleanUp() throws IOException { FileUtil.removeRecursively("test-db"); } @Test - public void basicOperations() { + void basicOperations() { RocksDbSource rocksDb = new RocksDbSource(Paths.get("test-db")); rocksDb.open(); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java index c7781f2ec..d19d98fcc 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java @@ -8,7 +8,7 @@ import static org.assertj.core.api.Assertions.*; -public class AbstractLinkedDataSourceTest { +class AbstractLinkedDataSourceTest { private final String TEST_KEY = "test_key"; private final String TEST_VALUE = "test_value"; @@ -18,7 +18,7 @@ public class AbstractLinkedDataSourceTest { private AbstractLinkedDataSource dataSource; @BeforeEach - public void setUp() { + void setUp() { dataSource = new AbstractLinkedDataSource(new HashMapDataSource<>()) { public Optional get(@Nonnull String key) { return getUpstream().get(key); @@ -37,7 +37,7 @@ public void remove(@Nonnull String key) { } @Test - public void testInvalidSourceCreation() { + void testInvalidSourceCreation() { assertThatThrownBy(() -> new AbstractLinkedDataSource(null) { public Optional get(@Nonnull Object key) { return Optional.empty(); @@ -54,7 +54,7 @@ public void remove(@Nonnull Object key) { } @Test - public void testGetPutRemoveUpstreamFlush() { + void testGetPutRemoveUpstreamFlush() { dataSource = new AbstractLinkedDataSource(new HashMapDataSource() { public void flush() { getStore().put(TEST_FLUSH, TEST_FLUSH); @@ -92,7 +92,7 @@ protected void doFlush() { } @Test - public void testFlushIsFalse() { + void testFlushIsFalse() { dataSource = new AbstractLinkedDataSource(new HashMapDataSource() { public void flush() { getStore().put(TEST_FLUSH, TEST_FLUSH); @@ -119,7 +119,7 @@ protected void doFlush() { } @Test - public void testGetUpstream() { + void testGetUpstream() { assertThat(dataSource.getUpstream()).isNotNull(); } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java index eaeaab107..fa86cde5f 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java @@ -11,19 +11,19 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; -public class CodecSourceTest { +class CodecSourceTest { private CodecSource source; @BeforeEach - public void setUp() { + void setUp() { source = new CodecSource<>(new HashMapDataSource<>(), Function.identity(), Function.identity(), Function.identity()); assertThat(source).isNotNull(); } @ParameterizedTest @MethodSource("nullArgumentsProvider") - public void testInvalidSourceCreation(DataSource ds, Function f1, Function f2, Function f3) { + void testInvalidSourceCreation(DataSource ds, Function f1, Function f2, Function f3) { assertThatThrownBy(() -> new CodecSource(ds, f1, f2, f3)) .isInstanceOf(NullPointerException.class); } @@ -39,7 +39,7 @@ private static Stream nullArgumentsProvider() { @ParameterizedTest @MethodSource("keyOnlyCodecSourceArgumentsProvider") - public void testInvalidKeyOnlyCreation(DataSource ds, Function f1) { + void testInvalidKeyOnlyCreation(DataSource ds, Function f1) { assertThatThrownBy(() -> new CodecSource.KeyOnly<>(ds, f1)) .isInstanceOf(NullPointerException.class); } @@ -53,7 +53,7 @@ private static Stream keyOnlyCodecSourceArgumentsProvider() { @ParameterizedTest @MethodSource("valueOnlyCodecSourceArgumentsProvider") - public void testInvalidValueOnlyCreation(DataSource ds, Function f1, Function f2) { + void testInvalidValueOnlyCreation(DataSource ds, Function f1, Function f2) { assertThatThrownBy(() -> new CodecSource.ValueOnly<>(ds, f1, f2)) .isInstanceOf(NullPointerException.class); } @@ -68,7 +68,7 @@ private static Stream valueOnlyCodecSourceArgumentsProvider() { @ParameterizedTest @MethodSource("keyValueArgumentsProvider") - public void testPutGetRemove(String key, String value) { + void testPutGetRemove(String key, String value) { assertThat(source.get(key)).isNotPresent(); source.put(key, value); @@ -86,7 +86,7 @@ private static Stream keyValueArgumentsProvider() { @ParameterizedTest @MethodSource("keyValueArgumentsProvider") - public void testKeyConversion(String key, String value) { + void testKeyConversion(String key, String value) { source = new CodecSource<>(new HashMapDataSource<>(), k -> encode(k, key), Function.identity(), Function.identity()); assertThat(source).isNotNull(); assertThat(source.get(key)).isNotPresent(); @@ -101,7 +101,7 @@ private String encode(String value, String valueModifier) { @ParameterizedTest @MethodSource("keyValueArgumentsProvider") - public void testValueTargetValueToUpValueConversion(String key, String value) { + void testValueTargetValueToUpValueConversion(String key, String value) { source = new CodecSource<>(new HashMapDataSource<>(), k -> encode(k, key), k -> encode(k, value), Function.identity()); assertThat(source).isNotNull(); assertThat(source.get(key)).isNotPresent(); @@ -112,7 +112,7 @@ public void testValueTargetValueToUpValueConversion(String key, String value) { @ParameterizedTest @MethodSource("keyValueArgumentsProvider") - public void testValueUpValueToTargetValueConversion(String key, String value) { + void testValueUpValueToTargetValueConversion(String key, String value) { source = new CodecSource<>(new HashMapDataSource<>(), k -> encode(k, key), k -> encode(k, value), k -> decode()); assertThat(source).isNotNull(); assertThat(source.get(key)).isNotPresent(); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java index 1a0dfa391..eee8b7d04 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java @@ -6,7 +6,7 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -public class HoleyListTest { +class HoleyListTest { private final Long TEST_KEY_0 = 0L; private final Long TEST_KEY_1 = 1L; @@ -17,7 +17,7 @@ public class HoleyListTest { private HoleyList list; @BeforeEach - public void setUp() { + void setUp() { list = new HoleyList() { private final Map store = new HashMap<>(); @@ -38,7 +38,7 @@ public Optional get(long idx) { } @Test - public void testAdd() { + void testAdd() { list.put(TEST_KEY_0, TEST_VALUE); final long indexToAdd = list.size(); list.add(TEST_VALUE); @@ -48,7 +48,7 @@ public void testAdd() { } @Test - public void testAddNull() { + void testAddNull() { list.put(TEST_KEY_0, TEST_VALUE); list.add(null); @@ -56,20 +56,20 @@ public void testAddNull() { } @Test - public void testUpdateExistingValue() { + void testUpdateExistingValue() { list.put(TEST_KEY_0, TEST_VALUE); assertThat(list.update(TEST_KEY_0, key -> "")).isPresent().hasValue(""); } @Test - public void testUpdateExistingValueOverIndex() { + void testUpdateExistingValueOverIndex() { list.put(TEST_KEY_0, TEST_VALUE); assertThat(list.update(TEST_KEY_1, key -> "")).isNotPresent(); assertThat(list.update(TEST_KEY_LESS_ZERO, key -> "")).isNotPresent(); } @Test - public void testUpdateExistingValueOrPutDefault() { + void testUpdateExistingValueOrPutDefault() { list.put(TEST_KEY_0, TEST_VALUE); assertThat(list.update(TEST_KEY_0, key -> "", () -> TEST_DEFAULT_VALUE)).isEqualTo(""); assertThat(list.update(TEST_KEY_1, key -> "", () -> TEST_DEFAULT_VALUE)).isEqualTo(TEST_DEFAULT_VALUE); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java index b5d0e0e00..b93d96456 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java @@ -9,12 +9,12 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; -public class LinkedDataSourceTest { +class LinkedDataSourceTest { private LinkedDataSource dataSource; @BeforeEach - public void setUp() { + void setUp() { dataSource = new LinkedDataSource() { public Optional get(@Nonnull String key) { return Optional.empty(); @@ -42,17 +42,17 @@ public DataSource getUpstream() { } @Test - public void testSetUpstream() { + void testSetUpstream() { assertThatThrownBy(() -> dataSource.setUpstream(new HashMapDataSource<>())).isInstanceOf(UnsupportedOperationException.class); } @Test - public void testGetNullUpstream() { + void testGetNullUpstream() { assertThat(dataSource.getUpstream()).isNull(); } @Test - public void testGetUpstream() { + void testGetUpstream() { dataSource = new LinkedDataSource() { public Optional get(@Nonnull String key) { return Optional.empty(); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java index e68508aa4..7e558df26 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java @@ -11,12 +11,12 @@ import static org.assertj.core.api.Assertions.*; -public class DataSourceListTest { +class DataSourceListTest { private DataSourceList dataSourceList; @BeforeEach - public void setUp() { + void setUp() { dataSourceList = new DataSourceList<>(new HashMapDataSource<>(), serialize(), deserialize()); assertThat(dataSourceList).isNotNull(); assertThat(dataSourceList.size()).isEqualTo(0); @@ -32,7 +32,7 @@ private Function deserialize() { @ParameterizedTest @MethodSource("nullArgumentsProvider") - public void testInvalidSourceCreation(DataSource ds, Function f1, Function f2) { + void testInvalidSourceCreation(DataSource ds, Function f1, Function f2) { assertThatThrownBy(() -> new DataSourceList<>(ds, f1, f2)) .isInstanceOf(NullPointerException.class); } @@ -46,7 +46,7 @@ private static Stream nullArgumentsProvider() { @ParameterizedTest @MethodSource("putGetSizeArgumentsProvider") - public void testPutGetSizeSerialization(Long key, String value, int expectedSize) { + void testPutGetSizeSerialization(Long key, String value, int expectedSize) { assertThat(dataSourceList.get(key)).isNotPresent(); dataSourceList.put(key, value); assertThat(dataSourceList.size()).isEqualTo(expectedSize); @@ -61,7 +61,7 @@ private static Stream putGetSizeArgumentsProvider() { } @Test - public void testGetOverIndex() { + void testGetOverIndex() { final Long TEST_KEY_0 = 0L; final Long TEST_KEY_1 = 1L; final Long TEST_KEY_LESS_ZERO = -1L; diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java index 00e4aa0ba..11baf4574 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java @@ -9,7 +9,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Java6Assertions.assertThatThrownBy; -public class DelegateDataSourceTest { +class DelegateDataSourceTest { private final String TEST_KEY = "test_key"; private final String TEST_VALUE = "test_value"; @@ -18,13 +18,13 @@ public class DelegateDataSourceTest { private DelegateDataSource delegateDataSource; @BeforeEach - public void setUp() { + void setUp() { delegateDataSource = new DelegateDataSource<>(new HashMapDataSource<>()); assertThat(delegateDataSource).isNotNull(); } @Test - public void testPutGetRemove() { + void testPutGetRemove() { delegateDataSource.put(TEST_KEY, TEST_VALUE); assertThat(delegateDataSource.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); @@ -34,7 +34,7 @@ public void testPutGetRemove() { @ParameterizedTest @MethodSource("nullArgumentsProvider") - public void testInvalidSourceCreation(String key, String value) { + void testInvalidSourceCreation(String key, String value) { assertThatThrownBy(() -> delegateDataSource.put(key, value)).isInstanceOf(NullPointerException.class); } @@ -46,7 +46,7 @@ private static Stream nullArgumentsProvider() { } @Test - public void testFlush() { + void testFlush() { delegateDataSource = new DelegateDataSource<>(new HashMapDataSource() { public void flush() { store.put(TEST_FLUSH, TEST_FLUSH); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java index 74908cf32..ff9fe5446 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java @@ -9,12 +9,12 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -public class HashMapHoleyListTest { +class HashMapHoleyListTest { private HoleyList map; @BeforeEach - public void setUp() { + void setUp() { map = new HashMapHoleyList<>(); assertThat(map).isNotNull(); assertThat(map.size()).isEqualTo(0L); @@ -22,7 +22,7 @@ public void setUp() { @ParameterizedTest @MethodSource("keyValueArgumentsProvider") - public void testPutSize(Long key, String value, Long size) { + void testPutSize(Long key, String value, Long size) { map.put(key, value); assertThat(map.size()).isEqualTo(size); } @@ -36,7 +36,7 @@ private static Stream keyValueArgumentsProvider() { @ParameterizedTest @MethodSource("keyValueGetArgumentsProvider") - public void testValidGet(Long key, String value) { + void testValidGet(Long key, String value) { map.put(key, value); assertThat(map.get(key)).isPresent().hasValue(value); } @@ -49,7 +49,7 @@ private static Stream keyValueGetArgumentsProvider() { @ParameterizedTest @MethodSource("invalidKeyArgumentsProvider") - public void testGetOverIndex(Long key, String value, Long wrongKey) { + void testGetOverIndex(Long key, String value, Long wrongKey) { map.put(key, value); assertThat(map.get(wrongKey)).isNotPresent(); } @@ -62,7 +62,7 @@ private static Stream invalidKeyArgumentsProvider() { } @Test - public void testPutSameKey() { + void testPutSameKey() { final Long TEST_KEY = 0L; final Long TEST_KEY_1 = 1L; final String TEST_VALUE = "test_value"; diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java index dc5fd67fa..d5632d9bd 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java @@ -5,10 +5,10 @@ import static org.assertj.core.api.Assertions.assertThat; -public class MemSizeEvaluatorTest { +class MemSizeEvaluatorTest { @Test - public void bytesValueEvaluator() { + void bytesValueEvaluator() { long evaluatedSize = MemSizeEvaluators.BytesValueEvaluator.apply(BytesValue.wrap(new byte[1000])); System.out.println("Evaluated size: " + evaluatedSize); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java index d75b66c1c..0a301ef1c 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java @@ -1,15 +1,15 @@ package org.ethereum.beacon.db.source.impl; -import org.junit.Test; +import org.junit.jupiter.api.Test; import tech.pegasys.artemis.util.bytes.BytesValue; import static org.assertj.core.api.Assertions.*; -public class XorDataSourceTest { +class XorDataSourceTest { @Test - public void testDataSourceCreation() { + void testDataSourceCreation() { assertThatThrownBy(() -> new XorDataSource<>(null, BytesValue.EMPTY)) .isInstanceOf(NullPointerException.class); From 452ffa1bb8666df7d7ec3765f46f3e9253327bbf Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Thu, 5 Sep 2019 12:32:53 +0300 Subject: [PATCH 21/44] test: add param tests to BufferSizeObserverTest --- .../db/flush/BufferSizeObserverTest.java | 100 +++++++++++------- 1 file changed, 61 insertions(+), 39 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java b/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java index 5d4c6713e..3428b9e36 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java @@ -3,6 +3,11 @@ import org.ethereum.beacon.db.source.WriteBuffer; import org.ethereum.beacon.db.source.impl.HashMapDataSource; import org.junit.jupiter.api.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; @@ -11,8 +16,6 @@ class BufferSizeObserverTest { - private final String TEST_KEY = "TEST_KEY"; - private final String TEST_VALUE = "TEST_VALUE"; private WriteBuffer buffer; private WriteBuffer commitTrack; private BufferSizeObserver observer; @@ -28,20 +31,39 @@ void setUp() { assertThat(observer).isNotNull(); } - @Test - void testBufferSizeObserverCreation() { - assertThat(new BufferSizeObserver(null, null, Long.MIN_VALUE)).isNotNull(); - assertThat(new BufferSizeObserver(null, new WriteBuffer(new HashMapDataSource(), true), Long.MIN_VALUE)).isNotNull(); - assertThat(new BufferSizeObserver(new WriteBuffer(new HashMapDataSource(), true), null, Long.MIN_VALUE)).isNotNull(); - - assertThat(new BufferSizeObserver(null, null, Long.MAX_VALUE)).isNotNull(); - assertThat(new BufferSizeObserver(null, new WriteBuffer(new HashMapDataSource(), true), Long.MAX_VALUE)).isNotNull(); - assertThat(new BufferSizeObserver(new WriteBuffer(new HashMapDataSource(), true), null, Long.MAX_VALUE)).isNotNull(); + @ParameterizedTest + @MethodSource("nullArgumentsProvider") + void testBufferSizeObserverCreation(WriteBuffer buffer, WriteBuffer commitTrack, long bufferLimitSize) { + assertThat(new BufferSizeObserver(buffer, commitTrack, bufferLimitSize)).isNotNull(); + } + + private static Stream nullArgumentsProvider() { + return Stream.of( + Arguments.of(null, null, Long.MIN_VALUE), + Arguments.of(null, new WriteBuffer(new HashMapDataSource(), true), Long.MIN_VALUE), + Arguments.of(new WriteBuffer(new HashMapDataSource(), true), null, Long.MIN_VALUE), + Arguments.of(null, null, Long.MAX_VALUE), + Arguments.of(null, new WriteBuffer(new HashMapDataSource(), true), Long.MAX_VALUE), + Arguments.of(new WriteBuffer(new HashMapDataSource(), true), null, Long.MAX_VALUE) + ); + } + + @ParameterizedTest + @MethodSource("nullKeyValueArgumentsProvider") + void testPutNullKeyValue(String key, String value) { + assertThatThrownBy(() -> buffer.put(key, value)).isInstanceOf(NullPointerException.class); } + private static Stream nullKeyValueArgumentsProvider() { + return Stream.of( + Arguments.of(null, null), + Arguments.of("not_null", null) + ); + } @Test void testCreate() { + String TEST_KEY_0 = "TEST_KEY_0"; String TEST_VALUE_0 = "TEST_VALUE_0"; String TEST_KEY_1 = "TEST_KEY_1"; @@ -63,8 +85,6 @@ void testCreate() { buffer.put(TEST_KEY_3, TEST_VALUE_3); buffer.put(TEST_KEY_4, TEST_VALUE_4); - assertThatThrownBy(() -> buffer.put(null, null)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> buffer.put("NOT_NULL", null)).isInstanceOf(NullPointerException.class); assertThat(buffer.get(TEST_KEY_0)).isPresent(); assertThat(buffer.getCacheEntry(TEST_KEY_0)).isPresent(); @@ -80,42 +100,44 @@ void testCreate() { assertThat(buffer.getCacheEntry(TEST_KEY_5)).isPresent(); observer.commit(); - assertThat(buffer.getUpstream().get(TEST_KEY_5)).isPresent(); - assertThat(buffer.getUpstream().get(TEST_KEY_5)).hasValue(TEST_VALUE_5); + assertThat(buffer.getUpstream().get(TEST_KEY_5)).isPresent().hasValue(TEST_VALUE_5); + } + private static Stream keyValueArgumentsProvider() { + return Stream.of( + Arguments.of("test_key", "test_value") + ); } - @Test - void testFlush() { - buffer.put(TEST_KEY, TEST_VALUE); - assertThat(buffer.get(TEST_KEY)).isPresent(); - assertThat(buffer.get(TEST_KEY)).hasValue(TEST_VALUE); + @ParameterizedTest + @MethodSource("keyValueArgumentsProvider") + void testFlush(String key, String value) { + buffer.put(key, value); + assertThat(buffer.get(key)).isPresent().hasValue(value); observer.flush(); - assertThat(buffer.getUpstream().get(TEST_KEY)).isPresent(); - assertThat(buffer.getUpstream().get(TEST_KEY)).hasValue(TEST_VALUE); + assertThat(buffer.getUpstream().get(key)).isPresent().hasValue(value); - buffer.getUpstream().remove(TEST_KEY); - assertThat(buffer.get(TEST_KEY)).isNotPresent(); - assertThat(buffer.getUpstream().get(TEST_KEY)).isNotPresent(); + buffer.getUpstream().remove(key); + assertThat(buffer.get(key)).isNotPresent(); + assertThat(buffer.getUpstream().get(key)).isNotPresent(); } - @Test - void testCommit() { - commitTrack.put(TEST_KEY, TEST_VALUE); - assertThat(commitTrack.get(TEST_KEY)).isPresent(); - assertThat(commitTrack.get(TEST_KEY)).hasValue(TEST_VALUE); - assertThat(commitTrack.getUpstream().get(TEST_KEY)).isNotPresent(); + @ParameterizedTest + @MethodSource("keyValueArgumentsProvider") + void testCommit(String key, String value) { + commitTrack.put(key, value); + assertThat(commitTrack.get(key)).isPresent().hasValue(value); + assertThat(commitTrack.getUpstream().get(key)).isNotPresent(); observer.commit(); - assertThat(commitTrack.get(TEST_KEY)).isPresent(); - assertThat(commitTrack.getUpstream().get(TEST_KEY)).isPresent(); - assertThat(commitTrack.getUpstream().get(TEST_KEY)).hasValue(TEST_VALUE); - - commitTrack.getUpstream().remove(TEST_KEY); - assertThat(commitTrack.get(TEST_KEY)).isNotPresent(); - assertThat(commitTrack.getUpstream().get(TEST_KEY)).isNotPresent(); - assertThat(buffer.getUpstream().get(TEST_KEY)).isNotPresent(); + assertThat(commitTrack.get(key)).isPresent(); + assertThat(commitTrack.getUpstream().get(key)).isPresent().hasValue(value); + + commitTrack.getUpstream().remove(key); + assertThat(commitTrack.get(key)).isNotPresent(); + assertThat(commitTrack.getUpstream().get(key)).isNotPresent(); + assertThat(buffer.getUpstream().get(key)).isNotPresent(); } } From 9d4d65de7b9c08662b65c51846d2fafaa223eba9 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Tue, 10 Sep 2019 11:49:51 +0300 Subject: [PATCH 22/44] test: TransactionalDataSourceTest, WriteBufferTest, HashMapDataSourceTest --- .../source/TransactionalDataSourceTest.java | 128 ++++++++++++++++++ .../beacon/db/source/WriteBufferTest.java | 90 ++++++++++++ .../db/source/impl/HashMapDataSourceTest.java | 51 +++++++ 3 files changed, 269 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/TransactionalDataSourceTest.java create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/WriteBufferTest.java create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapDataSourceTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/TransactionalDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/TransactionalDataSourceTest.java new file mode 100644 index 000000000..8c0d7fa8e --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/TransactionalDataSourceTest.java @@ -0,0 +1,128 @@ +package org.ethereum.beacon.db.source; + + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; + +import javax.annotation.Nonnull; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ConcurrentHashMap; + +import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; + +public class TransactionalDataSourceTest { + + private final String TEST_KEY = "test_key"; + private final String TEST_VALUE = "test_value"; + private final String TEST_FLUSH = "flush"; + + private TransactionalDataSource.Transaction transaction; + private TransactionalDataSource transactionalDataSource; + + @BeforeEach + public void setUp() + { + Map store = new ConcurrentHashMap<>(); + transaction = new TransactionalDataSource.Transaction() { + @Override + public void rollback() { + store.clear(); + } + + @Override + public Optional get(@Nonnull String key) { + return Optional.ofNullable(store.get(key)); + } + + @Override + public void put(@Nonnull String key, @Nonnull String value) { + store.put(key, value); + } + + @Override + public void remove(@Nonnull String key) { + store.remove(key); + } + + @Override + public void flush() { + store.put(TEST_FLUSH, TEST_FLUSH); + } + }; + assertThat(transaction).isNotNull(); + + + transactionalDataSource = new TransactionalDataSource() { + @Override + public Transaction startTransaction(TransactionOptions transactionOptions) { + return transaction; + } + + @Override + public Optional get(@Nonnull String key) { + return transaction.get(key); + } + }; + + assertThat(transactionalDataSource).isNotNull(); + } + + @Test + public void testValidStartTransaction() { + assertThat((TransactionalDataSource.TransactionOptions) () -> TransactionalDataSource.IsolationLevel.Snapshot).isNotNull(); + assertThat((TransactionalDataSource.TransactionOptions) () -> TransactionalDataSource.IsolationLevel.RepeatableReads).isNotNull(); + assertThat((TransactionalDataSource.TransactionOptions) () -> TransactionalDataSource.IsolationLevel.ReadUncommitted).isNotNull(); + assertThat((TransactionalDataSource.TransactionOptions) () -> TransactionalDataSource.IsolationLevel.ReadCommitted).isNotNull(); + + TransactionalDataSource.TransactionOptions transactionOptions = () -> TransactionalDataSource.IsolationLevel.Snapshot; + assertThat(transactionalDataSource.startTransaction(transactionOptions)).isEqualTo(transaction); + assertThat(transactionOptions.getIsolationLevel()).isIn(TransactionalDataSource.IsolationLevel.values()); + } + + @Test + public void testInvalidStartTransaction() { + TransactionalDataSource.TransactionOptions transactionOptions = () -> TransactionalDataSource.IsolationLevel.valueOf("illegalArgument"); + assertThat(transactionOptions).isNotNull(); + assertThat(transactionalDataSource.startTransaction(transactionOptions)).isEqualTo(transaction); + assertThat(transactionalDataSource.startTransaction(null)).isEqualTo(transaction); + assertThatThrownBy( () -> transactionOptions.getIsolationLevel().equals(TransactionalDataSource.IsolationLevel.Snapshot)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void testGetPutRemoveElementsInDb() { + transaction.put(TEST_KEY, TEST_VALUE); + assertThat(transactionalDataSource.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); + assertThat(transaction.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); + transaction.remove(TEST_KEY); + assertThat(transaction.get(TEST_KEY)).isNotPresent(); + transaction.commit(); + assertThat(transaction.get(TEST_FLUSH)).isPresent().hasValue(TEST_FLUSH); + } + + @Test + void testRollback() { + transaction.put("test_key_1", "test_value_1"); + transaction.put("test_key_2", "test_value_2"); + assertThat(transactionalDataSource.get("test_key_1")).isPresent().hasValue("test_value_1"); + assertThat(transaction.get("test_key_1")).isPresent().hasValue("test_value_1"); + transaction.rollback(); + assertThat(transaction.get("test_value_1")).isNotPresent(); + assertThat(transaction.get("test_key_2")).isNotPresent(); + } + + @Test + void testNullValues() { + assertThatThrownBy(() -> transaction.put(null, null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> transaction.put("not_null", null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> transaction.put(null, "not_null")).isInstanceOf(NullPointerException.class); + } + + @Test + public void testException() { + assertThat(new TransactionalDataSource.TransactionException("exception")).isNotNull(); + assertThat(new TransactionalDataSource.TransactionException("exception", new Throwable(""))).isNotNull(); + } +} \ No newline at end of file diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/WriteBufferTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteBufferTest.java new file mode 100644 index 000000000..d7674c339 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteBufferTest.java @@ -0,0 +1,90 @@ +package org.ethereum.beacon.db.source; + +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Optional; +import java.util.function.Function; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.*; + +class WriteBufferTest { + + private WriteBuffer buffer; + private CacheSizeEvaluator evaluator; + private Function keyValueEvaluator; + private HashMapDataSource dataSource; + + @BeforeEach + void setUp() { + keyValueEvaluator = s -> 1L; + evaluator = CacheSizeEvaluator.getInstance(keyValueEvaluator); + assertThat(keyValueEvaluator).isNotNull(); + assertThat(evaluator).isNotNull(); + dataSource = new HashMapDataSource(); + buffer = new WriteBuffer<>(dataSource, evaluator, true); + assertThat(buffer).isNotNull(); + } + + @Test + void testInvalidWriteBufferCreation() { + assertThatThrownBy(() -> new WriteBuffer(null, null, false)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> new WriteBuffer(null, null, true)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> new WriteBuffer(null, evaluator, false)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> new WriteBuffer(new HashMapDataSource(), null, false)).isInstanceOf(NullPointerException.class); + + assertThatThrownBy(() -> new WriteBuffer(null,false)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> new WriteBuffer(null,true)).isInstanceOf(NullPointerException.class); + } + + @Test + void testGetPutRemoveFlushReset() + { + assertThat(buffer.evaluateSize()).isEqualTo(0); + buffer.put("test_key_0","test_value_0"); + buffer.put("test_key_1","test_value_1"); + buffer.put("test_key_2","test_value_2"); + buffer.put("test_key_3","test_value_3"); + buffer.put("test_key_4","test_value_4"); + assertThat(buffer.evaluateSize()).isGreaterThan(0); + assertThat(buffer.getCacheEntry("test_key_0")).isPresent().hasValue(Optional.of("test_value_0")); + buffer.doFlush(); + assertThat(buffer.evaluateSize()).isEqualTo(0); + assertThat(buffer.getUpstream().get("test_key_0")).isPresent().hasValue("test_value_0"); + buffer.reset(); + assertThat(buffer.evaluateSize()).isEqualTo(0); + assertThat(buffer.getUpstream().get("test_key_0")).isPresent().hasValue("test_value_0"); + } + + @Test + void testGetPutRemoveFlushResetNoSize() + { + buffer = new WriteBuffer<>(new HashMapDataSource<>(), true); + assertThat(buffer.evaluateSize()).isEqualTo(0); + buffer.put("test_key_0","test_value_0"); + buffer.put("test_key_1","test_value_1"); + buffer.put("test_key_2","test_value_2"); + buffer.put("test_key_3","test_value_3"); + buffer.put("test_key_4","test_value_4"); + assertThat(buffer.evaluateSize()).isEqualTo(0); + assertThat(buffer.getCacheEntry("test_key_0")).isPresent().hasValue(Optional.of("test_value_0")); + buffer.doFlush(); + assertThat(buffer.evaluateSize()).isEqualTo(0); + assertThat(buffer.getUpstream().get("test_key_0")).isPresent().hasValue("test_value_0"); + buffer.reset(); + assertThat(buffer.evaluateSize()).isEqualTo(0); + assertThat(buffer.getUpstream().get("test_key_0")).isPresent().hasValue("test_value_0"); + } + + @Test + void testNullValues() { + assertThatThrownBy(() -> buffer.get(null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> buffer.put(null, null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> buffer.put("not_null", null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> buffer.put(null, "not_null")).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> buffer.remove(null)).isInstanceOf(NullPointerException.class); + } +} \ No newline at end of file diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapDataSourceTest.java new file mode 100644 index 000000000..78d056dfa --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapDataSourceTest.java @@ -0,0 +1,51 @@ +package org.ethereum.beacon.db.source.impl; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.*; + +class HashMapDataSourceTest { + + private final String TEST_KEY = "test_key"; + private final String TEST_VALUE = "test_value"; + private HashMapDataSource dataSource; + + @BeforeEach + void setUp() { + dataSource = new HashMapDataSource<>(); + assertThat(dataSource).isNotNull(); + } + + @Test + void testGetPutRemove() { + assertThat(dataSource.store).doesNotContainKeys(TEST_KEY); + dataSource.put(TEST_KEY, TEST_VALUE); + assertThat(dataSource.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); + dataSource.remove(TEST_KEY); + assertThat(dataSource.get(TEST_KEY)).isNotPresent(); + } + + @Test + void testFlush() { + dataSource.getStore().put("test_flush", "test_flush"); + assertThat(dataSource.getStore().get("test_flush")).isEqualTo("test_flush"); +} + + @Test + void testGetStore() { + dataSource.put(TEST_KEY, TEST_VALUE); + assertThat(dataSource.getStore().get(TEST_KEY)).isEqualTo(TEST_VALUE); + dataSource.getStore().remove(TEST_KEY); + assertThat(dataSource.get(TEST_KEY)).isNotPresent(); + } + + @Test + void testNullValues() { + assertThatThrownBy(() -> dataSource.put(null, null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.put("not_null", null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.put(null, "not_null")).isInstanceOf(NullPointerException.class); + } +} \ No newline at end of file From 44a569ae0c9cb6f8914e91db01ae4c6b4f324ecf Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Thu, 12 Sep 2019 17:27:49 +0300 Subject: [PATCH 23/44] test: add parameters into tests --- .../db/flush/BufferSizeObserverTest.java | 11 +--- .../beacon/db/source/WriteBufferTest.java | 58 +++++++++++++---- .../db/source/impl/HashMapDataSourceTest.java | 65 ++++++++++++------- 3 files changed, 88 insertions(+), 46 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java b/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java index 3428b9e36..b8ae3cabb 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java @@ -5,6 +5,7 @@ import org.junit.jupiter.api.*; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.CsvSource; import org.junit.jupiter.params.provider.MethodSource; import java.util.stream.Stream; @@ -103,14 +104,8 @@ void testCreate() { assertThat(buffer.getUpstream().get(TEST_KEY_5)).isPresent().hasValue(TEST_VALUE_5); } - private static Stream keyValueArgumentsProvider() { - return Stream.of( - Arguments.of("test_key", "test_value") - ); - } - @ParameterizedTest - @MethodSource("keyValueArgumentsProvider") + @CsvSource({ "test_key, test_value"}) void testFlush(String key, String value) { buffer.put(key, value); assertThat(buffer.get(key)).isPresent().hasValue(value); @@ -125,7 +120,7 @@ void testFlush(String key, String value) { } @ParameterizedTest - @MethodSource("keyValueArgumentsProvider") + @CsvSource({ "test_key, test_value"}) void testCommit(String key, String value) { commitTrack.put(key, value); assertThat(commitTrack.get(key)).isPresent().hasValue(value); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/WriteBufferTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteBufferTest.java index d7674c339..9eeab1ec0 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/WriteBufferTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteBufferTest.java @@ -3,9 +3,13 @@ import org.ethereum.beacon.db.source.impl.HashMapDataSource; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import java.util.Optional; import java.util.function.Function; +import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; @@ -14,7 +18,7 @@ class WriteBufferTest { private WriteBuffer buffer; - private CacheSizeEvaluator evaluator; + private static CacheSizeEvaluator evaluator; private Function keyValueEvaluator; private HashMapDataSource dataSource; @@ -29,15 +33,34 @@ void setUp() { assertThat(buffer).isNotNull(); } - @Test - void testInvalidWriteBufferCreation() { - assertThatThrownBy(() -> new WriteBuffer(null, null, false)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> new WriteBuffer(null, null, true)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> new WriteBuffer(null, evaluator, false)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> new WriteBuffer(new HashMapDataSource(), null, false)).isInstanceOf(NullPointerException.class); + @ParameterizedTest + @MethodSource("invalidArgumentsProvider") + void testInvalidWriteBufferCreation(DataSource ds, CacheSizeEvaluator evaluator, boolean upstreamFlush) { + assertThatThrownBy(() -> new WriteBuffer(ds, evaluator, upstreamFlush)).isInstanceOf(NullPointerException.class); + } - assertThatThrownBy(() -> new WriteBuffer(null,false)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> new WriteBuffer(null,true)).isInstanceOf(NullPointerException.class); + private static Stream invalidArgumentsProvider() { + return Stream.of( + Arguments.of(null, null, false), + Arguments.of(null, null, true), + Arguments.of(null, evaluator, false), + Arguments.of(null, evaluator, true), + Arguments.of(new HashMapDataSource<>(), null, false), + Arguments.of(new HashMapDataSource<>(), null, true) + ); + } + + @ParameterizedTest + @MethodSource("invalidArgsProvider") + void testInvalidArgsWriteBufferCreation(DataSource ds, boolean upstreamFlush) { + assertThatThrownBy(() -> new WriteBuffer(ds, upstreamFlush)).isInstanceOf(NullPointerException.class); + } + + private static Stream invalidArgsProvider() { + return Stream.of( + Arguments.of(null, false), + Arguments.of(null, true) + ); } @Test @@ -79,12 +102,19 @@ void testGetPutRemoveFlushResetNoSize() assertThat(buffer.getUpstream().get("test_key_0")).isPresent().hasValue("test_value_0"); } - @Test - void testNullValues() { + @ParameterizedTest + @MethodSource("nullArgumentsProvider") + void testNullValues(String key, String value) { + assertThatThrownBy(() -> buffer.put(key, value)).isInstanceOf(NullPointerException.class); assertThatThrownBy(() -> buffer.get(null)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> buffer.put(null, null)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> buffer.put("not_null", null)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> buffer.put(null, "not_null")).isInstanceOf(NullPointerException.class); assertThatThrownBy(() -> buffer.remove(null)).isInstanceOf(NullPointerException.class); } + + private static Stream nullArgumentsProvider() { + return Stream.of( + Arguments.of(null, null), + Arguments.of("not_null", null), + Arguments.of(null, "not_null") + ); + } } \ No newline at end of file diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapDataSourceTest.java index 78d056dfa..9a09c3dc0 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapDataSourceTest.java @@ -2,6 +2,13 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; @@ -9,8 +16,6 @@ class HashMapDataSourceTest { - private final String TEST_KEY = "test_key"; - private final String TEST_VALUE = "test_value"; private HashMapDataSource dataSource; @BeforeEach @@ -19,33 +24,45 @@ void setUp() { assertThat(dataSource).isNotNull(); } - @Test - void testGetPutRemove() { - assertThat(dataSource.store).doesNotContainKeys(TEST_KEY); - dataSource.put(TEST_KEY, TEST_VALUE); - assertThat(dataSource.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); - dataSource.remove(TEST_KEY); - assertThat(dataSource.get(TEST_KEY)).isNotPresent(); + @ParameterizedTest + @CsvSource({ "test_key, test_value"}) + void testGetPutRemove(String key, String value) { + assertThat(dataSource.store).doesNotContainKeys(key); + dataSource.put(key, value); + assertThat(dataSource.get(key)).isPresent().hasValue(value); + dataSource.remove(key); + assertThat(dataSource.get(key)).isNotPresent(); } - @Test - void testFlush() { - dataSource.getStore().put("test_flush", "test_flush"); - assertThat(dataSource.getStore().get("test_flush")).isEqualTo("test_flush"); + @ParameterizedTest + @ValueSource(strings = "test_flush") + void testFlush(String flush) { + dataSource.getStore().put(flush, flush); + assertThat(dataSource.getStore().get(flush)).isEqualTo(flush); } - @Test - void testGetStore() { - dataSource.put(TEST_KEY, TEST_VALUE); - assertThat(dataSource.getStore().get(TEST_KEY)).isEqualTo(TEST_VALUE); - dataSource.getStore().remove(TEST_KEY); - assertThat(dataSource.get(TEST_KEY)).isNotPresent(); + @ParameterizedTest + @CsvSource({ "test_key, test_value"}) + void testGetStore(String key, String value) { + dataSource.put(key, value); + assertThat(dataSource.getStore().get(key)).isEqualTo(value); + dataSource.getStore().remove(key); + assertThat(dataSource.get(key)).isNotPresent(); + } + + + + @ParameterizedTest + @MethodSource("nullArgumentsProvider") + void testNullValues(String key, String value) { + assertThatThrownBy(() -> dataSource.put(key, value)).isInstanceOf(NullPointerException.class); } - @Test - void testNullValues() { - assertThatThrownBy(() -> dataSource.put(null, null)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> dataSource.put("not_null", null)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> dataSource.put(null, "not_null")).isInstanceOf(NullPointerException.class); + private static Stream nullArgumentsProvider() { + return Stream.of( + Arguments.of(null, null), + Arguments.of("not_null", null), + Arguments.of(null, "not_null") + ); } } \ No newline at end of file From ac23ca674c9041eee1397a35f5b3e13177039832 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Mon, 16 Sep 2019 17:17:27 +0300 Subject: [PATCH 24/44] test: BatchUpdateDataSourceTest/CacheDataSourceTest/CacheSizeEvaluatorTest/DataSourceTest/ReadonlyDataSourceTest/StorageEngineSourceTest --- .../db/source/BatchUpdateDataSourceTest.java | 90 ++++++++++++ .../beacon/db/source/CacheDataSourceTest.java | 119 ++++++++++++++++ .../db/source/CacheSizeEvaluatorTest.java | 131 ++++++++++++++++++ .../beacon/db/source/DataSourceTest.java | 67 +++++++++ .../db/source/ReadonlyDataSourceTest.java | 39 ++++++ .../db/source/StorageEngineSourceTest.java | 109 +++++++++++++++ 6 files changed, 555 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/BatchUpdateDataSourceTest.java create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/CacheDataSourceTest.java create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/CacheSizeEvaluatorTest.java create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/DataSourceTest.java create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/ReadonlyDataSourceTest.java create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/source/StorageEngineSourceTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/BatchUpdateDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/BatchUpdateDataSourceTest.java new file mode 100644 index 000000000..1116f78c5 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/BatchUpdateDataSourceTest.java @@ -0,0 +1,90 @@ +package org.ethereum.beacon.db.source; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import javax.annotation.Nonnull; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.*; + +class BatchUpdateDataSourceTest { + + private BatchUpdateDataSource dataSource; + + @BeforeEach + void setUp() + { + final HashMap store = new HashMap<>(); + dataSource = new BatchUpdateDataSource() { + @Override + public void batchUpdate(Map updates) { + updates.forEach(this::put); + } + + @Override + public Optional get(@Nonnull String key) { + Objects.requireNonNull(key); + return Optional.ofNullable(store.get(key)); + } + + @Override + public void put(@Nonnull String key, @Nonnull String value) { + Objects.requireNonNull(key); + Objects.requireNonNull(value); + store.put(key, value); + } + + @Override + public void remove(@Nonnull String key) { + Objects.requireNonNull(key); + store.remove(key); + } + + @Override + public void flush() { + store.put("test_flush", "test_flush"); + } + }; + + assertThat(dataSource).isNotNull(); + } + + @Test + void testGetPutRemoveFlushBatchUpdate() { + assertThat(dataSource.get("test_key_0")).isNotPresent(); + dataSource.put("test_key_0", "test_value_0"); + assertThat(dataSource.get("test_key_0")).isPresent().hasValue("test_value_0"); + final Map updates = new HashMap<>(); + updates.put("test_key_1", "test_value_1"); + updates.put("test_key_2", "test_value_2"); + updates.put("test_key_3", "test_value_3"); + updates.put("test_key_4", "test_value_4"); + updates.put("test_key_5", "test_value_5"); + dataSource.batchUpdate(updates); + dataSource.remove("test_key_5"); + assertThat(dataSource.get("test_valu_5")).isNotPresent(); + dataSource.flush(); + assertThat(dataSource.get("test_flush")).isPresent().hasValue("test_flush"); + } + + @Test + void testNullValues() { + assertThatThrownBy(() -> dataSource.put(null, null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.put("not_null", null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.put(null, "not_null")).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.get(null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.remove(null)).isInstanceOf(NullPointerException.class); + + final HashMap updates = new HashMap(); + updates.put(null, null); + updates.put(null, "test_value_0"); + updates.put("test_value_0", null); + assertThatThrownBy(() -> dataSource.batchUpdate(updates)).isInstanceOf(NullPointerException.class); + } +} \ No newline at end of file diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/CacheDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/CacheDataSourceTest.java new file mode 100644 index 000000000..09aca886c --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/CacheDataSourceTest.java @@ -0,0 +1,119 @@ +package org.ethereum.beacon.db.source; + +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import javax.annotation.Nonnull; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.function.Function; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.*; + +class CacheDataSourceTest { + + private CacheDataSource dataSource; + private long size; + + @BeforeEach + void setUp() { + final Function keyEvaluator = getKeyValueEvaluator(); + final Function valueEvaluator = keyEvaluator; + + final Map store = new HashMap<>(); + final HashMapDataSource upStream = new HashMapDataSource<>(); + dataSource = new CacheDataSource() { + @Override + public Optional> getCacheEntry(@Nonnull String key) { + Objects.requireNonNull(key); + String entry = store.get(key); + return Optional.ofNullable(entry == null ? null : Optional.ofNullable(entry)); + } + + @Override + public long evaluateSize() { + return size; + } + + @Nonnull + @Override + public DataSource getUpstream() { + return upStream; + } + + @Override + public Optional get(@Nonnull String key) { + Objects.requireNonNull(key); + return Optional.ofNullable(store.get(key)); + } + + @Override + public void put(@Nonnull String key, @Nonnull String value) { + Objects.requireNonNull(key); + Objects.requireNonNull(value); + store.put(key, value); + size += keyEvaluator.apply(key); + size += valueEvaluator.apply(value); + + } + + @Override + public void remove(@Nonnull String key) { + Objects.requireNonNull(key); + store.remove(key); + size -= keyEvaluator.apply(key); + size -= valueEvaluator.apply(key); + } + + @Override + public void flush() { + store.forEach(upStream::put); + size = 0; + store.clear(); + } + }; + + assertThat(dataSource).isNotNull(); + } + + @Test + void testGetPutRemoveFlushCacheEntrySize(){ + assertThat(dataSource.get("test_key_0")).isNotPresent(); + dataSource.put("test_key_0", "test_value_0"); + assertThat(dataSource.evaluateSize()).isGreaterThan(0); + + dataSource.put("test_key_1", "test_value_1"); + dataSource.put("test_key_2", "test_value_2"); + dataSource.put("test_key_3", "test_value_3"); + assertThat(dataSource.getCacheEntry("test_key_0")).isPresent().hasValue(Optional.ofNullable("test_value_0")); + + dataSource.remove("test_key_0"); + assertThat(dataSource.getCacheEntry("test_key_0")).isNotPresent(); + assertThat(dataSource.getCacheEntry("test_key_1")).isPresent().hasValue(Optional.ofNullable("test_value_1")); + + dataSource.flush(); + assertThat(dataSource.evaluateSize()).isEqualTo(0); + assertThat(dataSource.get("test_key_1")).isNotPresent(); + assertThat(dataSource.getUpstream().get("test_key_1")).isPresent().hasValue("test_value_1"); + + } + + @Test + void testNullValues() { + assertThatThrownBy(() -> dataSource.put(null, null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.put("not_null", null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.put(null, "not_null")).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.get(null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.remove(null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.getCacheEntry(null)).isInstanceOf(NullPointerException.class); + } + + private Function getKeyValueEvaluator() { + return s -> 1L; + } +} \ No newline at end of file diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/CacheSizeEvaluatorTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/CacheSizeEvaluatorTest.java new file mode 100644 index 000000000..ac18f0dff --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/CacheSizeEvaluatorTest.java @@ -0,0 +1,131 @@ +package org.ethereum.beacon.db.source; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +class CacheSizeEvaluatorTest { + + private long size; + private CacheSizeEvaluator cacheSizeEvaluator; + + @BeforeEach + void setUp() { + size = 0; + final Function keyEvaluator = s -> 1L; + cacheSizeEvaluator = new CacheSizeEvaluator() { + @Override + public long getEvaluatedSize() { + return size; + } + + @Override + public void reset() { + size = 0; + } + + @Override + public void added(String key, String value) { + size += keyEvaluator.apply(key); + } + + @Override + public void removed(String key, String value) { + size -= keyEvaluator.apply(key); + } + }; + assertThat(cacheSizeEvaluator).isNotNull(); + } + + @Test + void testAddedRemoveResetSize(){ + cacheSizeEvaluator.added("key_0", "value_0"); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(0); + long evaluatedSize = cacheSizeEvaluator.getEvaluatedSize(); + cacheSizeEvaluator.removed("key_0", "value_0"); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + cacheSizeEvaluator.added("key_1", "value_1"); + cacheSizeEvaluator.added("key_2", "value_2"); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(evaluatedSize); + + cacheSizeEvaluator.reset(); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + } + + @Test + void testNoSizeEvaluator() { + cacheSizeEvaluator = CacheSizeEvaluator.noSizeEvaluator(); + assertThat(cacheSizeEvaluator).isNotNull(); + cacheSizeEvaluator.added("key_0", "value_0"); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + size = cacheSizeEvaluator.getEvaluatedSize(); + cacheSizeEvaluator.removed("key_0", "value_0"); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + cacheSizeEvaluator.added("key_1", "value_1"); + cacheSizeEvaluator.added("key_2", "value_2"); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(size); + + cacheSizeEvaluator.reset(); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + } + + @Test + void testKeySizeGetIntance(){ + final Function keyEvaluator = s -> 1L; + cacheSizeEvaluator = CacheSizeEvaluator.getInstance(keyEvaluator); + assertThat(cacheSizeEvaluator).isNotNull(); + + cacheSizeEvaluator.added("key_0", "value_0"); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(0); + size = cacheSizeEvaluator.getEvaluatedSize(); + cacheSizeEvaluator.removed("key_0", "value_0"); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + cacheSizeEvaluator.added("key_1", "value_1"); + cacheSizeEvaluator.added("key_2", "value_2"); + cacheSizeEvaluator.added("key_3", "value_3"); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(size); + + cacheSizeEvaluator.reset(); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + + } + + @Test + void testKeyValueSizeGetInstance() { + final Function keyEvaluator = s -> 1L; + final Function valueEvaluator = keyEvaluator; + cacheSizeEvaluator = CacheSizeEvaluator.getInstance(keyEvaluator, valueEvaluator); + assertThat(cacheSizeEvaluator).isNotNull(); + cacheSizeEvaluator.added("key_0", "value_0"); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(0); + size = cacheSizeEvaluator.getEvaluatedSize(); + cacheSizeEvaluator.removed("key_0", "value_0"); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + cacheSizeEvaluator.added("key_1", "value_1"); + cacheSizeEvaluator.added("key_2", "value_2"); + cacheSizeEvaluator.added("key_3", "value_3"); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(size); + + cacheSizeEvaluator.reset(); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + } + + @Test + void testNullValuesCreation() { + assertThat(CacheSizeEvaluator.getInstance(null, null)).isNotNull(); + assertThat(CacheSizeEvaluator.getInstance(null)).isNotNull(); + } + + @Test + void testNullValues() { + cacheSizeEvaluator.added(null, null); + cacheSizeEvaluator.added(null, "not_null"); + cacheSizeEvaluator.added("not_null", null); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(0); + } + +} \ No newline at end of file diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/DataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/DataSourceTest.java new file mode 100644 index 000000000..2303cdf15 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/DataSourceTest.java @@ -0,0 +1,67 @@ +package org.ethereum.beacon.db.source; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import javax.annotation.Nonnull; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ConcurrentHashMap; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Java6Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.*; + +class DataSourceTest { + + private DataSource dataSource; + + @BeforeEach + void setUp() { + final Map store = new ConcurrentHashMap<>(); + dataSource = new DataSource() { + @Override + public Optional get(@Nonnull String key) { + return Optional.ofNullable(store.get(key)); + } + + @Override + public void put(@Nonnull String key, @Nonnull String value) { + store.put(key, value); + } + + @Override + public void remove(@Nonnull String key) { + store.remove(key); + } + + @Override + public void flush() { + store.put("test_flush", "test_flush"); + } + }; + } + + @Test + void testGetPutRemoveFlush() { + assertThat(dataSource.get("test_key_0")).isNotPresent(); + dataSource.put("test_key_0", "test_value_0"); + dataSource.put("test_key_1", "test_value_1"); + assertThat(dataSource.get("test_key_0")).isPresent().hasValue("test_value_0"); + assertThat(dataSource.get("test_key_1")).isPresent().hasValue("test_value_1"); + dataSource.remove("test_key_0"); + assertThat(dataSource.get("test_key_0")).isNotPresent(); + + dataSource.flush(); + assertThat(dataSource.get("test_flush")).isPresent().hasValue("test_flush"); + } + + @Test + void testNullValues() { + assertThatThrownBy(() -> dataSource.get(null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.put(null, null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.put("not_null", null)).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.put(null, "not_null")).isInstanceOf(NullPointerException.class); + assertThatThrownBy(() -> dataSource.remove(null)).isInstanceOf(NullPointerException.class); + } +} \ No newline at end of file diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/ReadonlyDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/ReadonlyDataSourceTest.java new file mode 100644 index 000000000..e949efffe --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/ReadonlyDataSourceTest.java @@ -0,0 +1,39 @@ +package org.ethereum.beacon.db.source; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.Objects; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +class ReadonlyDataSourceTest { + + private ReadonlyDataSource readonlyDataSource; + + @BeforeEach + void setUp() { + final HashMap store = new HashMap<>(); + readonlyDataSource = key -> { + Objects.requireNonNull(key); + return Optional.ofNullable(store.get(key)); + }; + + assertThat(readonlyDataSource).isNotNull(); + + store.put("test_key_0", "test_value_0"); + } + + @Test + void testGet() { + assertThat(readonlyDataSource.get("test_key_0")).isPresent().hasValue("test_value_0"); + } + + @Test + void testNullValue(){ + assertThatThrownBy(() -> readonlyDataSource.get(null)).isInstanceOf(NullPointerException.class); + } +} \ No newline at end of file diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/StorageEngineSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/StorageEngineSourceTest.java new file mode 100644 index 000000000..cb1365e19 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/StorageEngineSourceTest.java @@ -0,0 +1,109 @@ +package org.ethereum.beacon.db.source; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.artemis.util.bytes.BytesValue; + +import javax.annotation.Nonnull; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ConcurrentHashMap; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.*; + +class StorageEngineSourceTest { + + private StorageEngineSource storageEngineSource; + private boolean opened; + + @BeforeEach + void setUp() { + final Map store = new ConcurrentHashMap<>(); + storageEngineSource = new StorageEngineSource() { + @Override + public void open() { + opened = true; + } + + @Override + public void close() { + opened = false; + } + + @Override + public void batchUpdate(Map updates) { + assertTrue(opened); + store.putAll(updates); + } + + @Override + public Optional get(@Nonnull BytesValue key) { + assertTrue(opened); + return Optional.ofNullable(store.get(key)); + } + + @Override + public void put(@Nonnull BytesValue key, @Nonnull String value) { + assertTrue(opened); + store.put(key, value); + } + + @Override + public void remove(@Nonnull BytesValue key) { + assertTrue(opened); + store.remove(key); + } + + @Override + public void flush() { + assertTrue(opened); + store.put(wrap("test_flush"), "test_flush"); + } + }; + + assertThat(storageEngineSource).isNotNull(); + } + + @Test + void testBasicOperations(){ + storageEngineSource.open(); + storageEngineSource.put(wrap("key_0"), "value_0"); + assertThat(storageEngineSource.get(wrap("key_0")).get()).isEqualTo("value_0"); + + Map batch = new HashMap<>(); + batch.put(wrap("key_2"), "value_2"); + batch.put(wrap("key_3"), "value_3"); + batch.put(wrap("key_4"), "value_4"); + + storageEngineSource.batchUpdate(batch); + + assertThat("value_2").isEqualTo(storageEngineSource.get(wrap("key_2")).get()); + assertThat("value_3").isEqualTo(storageEngineSource.get(wrap("key_3")).get()); + assertThat("value_4").isEqualTo(storageEngineSource.get(wrap("key_4")).get()); + + batch.put(wrap("key_1"), null); + assertThatThrownBy(() -> storageEngineSource.batchUpdate(batch)).isInstanceOf(NullPointerException.class); + assertThat(storageEngineSource.get(wrap("key_1"))).isNotPresent(); + + storageEngineSource.remove(wrap("key_3")); + assertThat(storageEngineSource.get(wrap("key_3"))).isNotPresent(); + + storageEngineSource.close(); + storageEngineSource.open(); + + assertThat(storageEngineSource.get(wrap("key_1"))).isNotPresent(); + assertThat("value_2").isEqualTo(storageEngineSource.get(wrap("key_2")).get()); + assertThat(storageEngineSource.get(wrap("key_3"))).isNotPresent(); + assertThat("value_4").isEqualTo(storageEngineSource.get(wrap("key_4")).get()); + assertThat(storageEngineSource.get(wrap("key_5"))).isNotPresent(); + + storageEngineSource.close(); + } + + private BytesValue wrap(String value) { + return BytesValue.wrap(value.getBytes()); + } +} \ No newline at end of file From 22b2e1e689e9001b51e461dd92105c83491b1456 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Mon, 16 Sep 2019 19:01:06 +0300 Subject: [PATCH 25/44] test: fix after review --- .../beacon/db/flush/BufferSizeObserver.java | 7 ++- .../org/ethereum/beacon/db/DatabaseTest.java | 18 +++--- .../beacon/db/InMemoryDatabaseTest.java | 4 +- .../beacon/db/XorKeyDatabaseTest.java | 31 ++++++---- .../db/flush/BufferSizeObserverTest.java | 58 ++++++++----------- .../beacon/db/flush/InstantFlusherTest.java | 11 ++-- .../source/AbstractLinkedDataSourceTest.java | 24 ++++---- .../db/source/BatchUpdateDataSourceTest.java | 30 +++++++--- .../beacon/db/source/CacheDataSourceTest.java | 15 +++-- .../db/source/CacheSizeEvaluatorTest.java | 46 ++++++++------- .../beacon/db/source/CodecSourceTest.java | 7 +-- .../beacon/db/source/DataSourceTest.java | 35 ++++++++--- .../beacon/db/source/HoleyListTest.java | 9 ++- .../db/source/LinkedDataSourceTest.java | 11 +--- .../db/source/ReadonlyDataSourceTest.java | 10 +++- .../db/source/SingleValueSourceTest.java | 10 ++-- .../db/source/StorageEngineSourceTest.java | 8 +-- .../source/TransactionalDataSourceTest.java | 33 ++++------- .../beacon/db/source/WriteBufferTest.java | 8 +-- .../impl/CacheSizeEvaluatorImplTest.java | 8 ++- .../db/source/impl/DataSourceListTest.java | 16 ++--- .../source/impl/DelegateDataSourceTest.java | 11 ++-- .../db/source/impl/HashMapDataSourceTest.java | 5 +- .../db/source/impl/HashMapHoleyListTest.java | 11 ++-- .../db/source/impl/XorDataSourceTest.java | 11 +++- .../beacon/db/util/AutoCloseableLockTest.java | 26 ++++++--- 26 files changed, 248 insertions(+), 215 deletions(-) diff --git a/db/core/src/main/java/org/ethereum/beacon/db/flush/BufferSizeObserver.java b/db/core/src/main/java/org/ethereum/beacon/db/flush/BufferSizeObserver.java index 865105b79..589b5a58f 100644 --- a/db/core/src/main/java/org/ethereum/beacon/db/flush/BufferSizeObserver.java +++ b/db/core/src/main/java/org/ethereum/beacon/db/flush/BufferSizeObserver.java @@ -4,6 +4,9 @@ import org.apache.logging.log4j.Logger; import org.ethereum.beacon.db.source.WriteBuffer; +import javax.annotation.Nonnull; +import java.util.Objects; + /** * Flushing strategy that observes a size of given buffer and emits a flush whenever size limit is * exceeded. @@ -19,7 +22,9 @@ public class BufferSizeObserver implements DatabaseFlusher { /** A limit of buffer size in bytes. */ private final long bufferSizeLimit; - BufferSizeObserver(WriteBuffer buffer, WriteBuffer commitTrack, long bufferSizeLimit) { + BufferSizeObserver(@Nonnull WriteBuffer buffer, @Nonnull WriteBuffer commitTrack, long bufferSizeLimit) { + Objects.requireNonNull(buffer); + Objects.requireNonNull(commitTrack); this.buffer = buffer; this.commitTrack = commitTrack; this.bufferSizeLimit = bufferSizeLimit; diff --git a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java index 1a9f7a8ca..ad52dd5b1 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -2,24 +2,22 @@ import org.ethereum.beacon.db.source.DataSource; import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.*; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import tech.pegasys.artemis.util.bytes.BytesValue; import java.util.stream.Stream; -import static org.assertj.core.api.Assertions.*; -import static org.junit.jupiter.api.Assertions.*; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; class DatabaseTest { - @Test - void inMemoryDB() { - final Database database = Database.inMemoryDB(); - assertThat(database).isNotNull(); - } - @Tag("FIX") @ParameterizedTest @MethodSource("invalidArgumentsProvider") diff --git a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java index 2c83eeac2..d4eefdebc 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java @@ -14,12 +14,10 @@ class InMemoryDatabaseTest { void testGetBackingDataSource(String param) { final InMemoryDatabase database = new InMemoryDatabase(); final DataSource dataSource = database.getBackingDataSource(); - assertThat(dataSource).isNotNull(); - final BytesValue key = BytesValue.wrap(param.getBytes()); final BytesValue value = BytesValue.EMPTY; dataSource.put(key, value); - assertThat(dataSource.get(key)).isPresent(); + assertThat(dataSource.get(key)).isPresent().hasValue(value); } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java index 98e398bd8..632d44387 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java @@ -2,7 +2,8 @@ import org.ethereum.beacon.db.source.DataSource; import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import tech.pegasys.artemis.util.bytes.BytesValue; import java.util.function.Function; @@ -30,29 +31,35 @@ public void close() { @Test void testCreateStorage_EmptyStorage() { final DataSource storage1 = db.createStorage("Storage1"); - storage1.put(BytesValue.of(1, 2, 3), BytesValue.of(1, 4)); - assertThat(storage1.get(BytesValue.of(1, 2, 3))).isPresent(); + final BytesValue key = BytesValue.of(1, 2, 3); + final BytesValue value = BytesValue.of(1, 4); + storage1.put(key, value); + assertThat(storage1.get(key)).isPresent().hasValue(value); } @Test void testCreateStorage() { final DataSource storage0 = db.createStorage("Storage1"); - storage0.put(BytesValue.of(1, 2, 3), BytesValue.of(1, 4)); + final BytesValue key = BytesValue.of(1, 2, 3); + final BytesValue value = BytesValue.of(1, 4); + storage0.put(key, value); final DataSource storage1 = db.createStorage("Storage1"); - assertThat(storage1.get(BytesValue.of(1, 2, 3))).isPresent(); + assertThat(storage1.get(key)).isPresent().hasValue(value); } @Test void testCreateStorage_1() { final DataSource storage0 = db.createStorage("Storage1"); - storage0.put(BytesValue.of(1, 2, 3), BytesValue.of(1, 4)); + final BytesValue key = BytesValue.of(1, 2, 3); + final BytesValue storage0_value = BytesValue.of(1, 4); + storage0.put(key, storage0_value); + final DataSource storage1 = db.createStorage("Storage2"); - assertThat(storage1.get(BytesValue.of(1, 2, 3))).isNotPresent(); - storage1.put(BytesValue.of(1, 2, 3), BytesValue.of(1, 4, 5)); - assertThat(storage1.get(BytesValue.of(1, 2, 3))).isPresent(); - assertThat(storage1.get(BytesValue.of(1, 2, 3)).get()).isEqualTo(BytesValue.of(1, 4, 5)); + assertThat(storage1.get(key)).isNotPresent(); - assertThat(storage0.get(BytesValue.of(1, 2, 3))).isPresent(); - assertThat(storage0.get(BytesValue.of(1, 2, 3)).get()).isEqualTo(BytesValue.of(1, 4)); + final BytesValue storage1_value = BytesValue.of(1, 4, 5); + storage1.put(key, storage1_value); + assertThat(storage1.get(key)).isPresent().hasValue(storage1_value); + assertThat(storage0.get(key)).isPresent().hasValue(storage0_value); } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java b/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java index b8ae3cabb..ed3daad84 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java @@ -2,7 +2,8 @@ import org.ethereum.beacon.db.source.WriteBuffer; import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.CsvSource; @@ -15,37 +16,38 @@ import static org.junit.jupiter.api.Assertions.assertTrue; +//TODO: need more tests class BufferSizeObserverTest { private WriteBuffer buffer; private WriteBuffer commitTrack; private BufferSizeObserver observer; - @BeforeEach void setUp() { - buffer = new WriteBuffer<>(new HashMapDataSource<>(), true); - commitTrack = new WriteBuffer<>(new HashMapDataSource<>(), true); - observer = new BufferSizeObserver(buffer, commitTrack, Long.MIN_VALUE); - assertThat(observer).isNotNull(); + final HashMapDataSource upstream = new HashMapDataSource<>(); + buffer = new WriteBuffer<>(upstream, true); + assertThat(buffer.getUpstream()).isEqualTo(upstream); + assertThat(buffer.evaluateSize()).isEqualTo(0); + + commitTrack = new WriteBuffer<>(upstream, true); + assertThat(commitTrack.getUpstream()).isEqualTo(upstream); + assertThat(commitTrack.evaluateSize()).isEqualTo(0); + observer = new BufferSizeObserver(buffer, commitTrack, Long.MAX_VALUE); - assertThat(observer).isNotNull(); } @ParameterizedTest @MethodSource("nullArgumentsProvider") - void testBufferSizeObserverCreation(WriteBuffer buffer, WriteBuffer commitTrack, long bufferLimitSize) { - assertThat(new BufferSizeObserver(buffer, commitTrack, bufferLimitSize)).isNotNull(); + void testInvalidCreation(WriteBuffer buffer, WriteBuffer commitTrack, long bufferLimitSize) { + assertThatThrownBy(() -> new BufferSizeObserver(buffer, commitTrack, bufferLimitSize)).isInstanceOf(NullPointerException.class); } private static Stream nullArgumentsProvider() { return Stream.of( - Arguments.of(null, null, Long.MIN_VALUE), - Arguments.of(null, new WriteBuffer(new HashMapDataSource(), true), Long.MIN_VALUE), - Arguments.of(new WriteBuffer(new HashMapDataSource(), true), null, Long.MIN_VALUE), Arguments.of(null, null, Long.MAX_VALUE), - Arguments.of(null, new WriteBuffer(new HashMapDataSource(), true), Long.MAX_VALUE), - Arguments.of(new WriteBuffer(new HashMapDataSource(), true), null, Long.MAX_VALUE) + Arguments.of(null, new WriteBuffer(new HashMapDataSource<>(), true), Long.MAX_VALUE), + Arguments.of(new WriteBuffer(new HashMapDataSource<>(), true), null, Long.MAX_VALUE) ); } @@ -69,39 +71,27 @@ void testCreate() { String TEST_VALUE_0 = "TEST_VALUE_0"; String TEST_KEY_1 = "TEST_KEY_1"; String TEST_VALUE_1 = "TEST_VALUE_1"; - String TEST_KEY_2 = "TEST_KEY_2"; - String TEST_VALUE_2 = "TEST_VALUE_2"; - String TEST_KEY_3 = "TEST_KEY_3"; - String TEST_VALUE_3 = "TEST_VALUE_3"; - String TEST_KEY_4 = "TEST_KEY_4"; - String TEST_VALUE_4 = "TEST_VALUE_4"; - String TEST_KEY_5 = "TEST_KEY_5"; - String TEST_VALUE_5 = "TEST_VALUE_5"; buffer = new WriteBuffer<>(new HashMapDataSource<>(), false); - observer = BufferSizeObserver.create(buffer, Long.MIN_VALUE); + observer = BufferSizeObserver.create(buffer, Long.MAX_VALUE); buffer.put(TEST_KEY_0, TEST_VALUE_0); - buffer.put(TEST_KEY_1, TEST_VALUE_1); - buffer.put(TEST_KEY_2, TEST_VALUE_2); - buffer.put(TEST_KEY_3, TEST_VALUE_3); - buffer.put(TEST_KEY_4, TEST_VALUE_4); - assertThat(buffer.get(TEST_KEY_0)).isPresent(); + assertThat(buffer.get(TEST_KEY_0)).isPresent().hasValue(TEST_VALUE_0); assertThat(buffer.getCacheEntry(TEST_KEY_0)).isPresent(); assertTrue(buffer.evaluateSize() >= Long.MIN_VALUE, "Needed db flush"); observer.flush(); assertThat(buffer.getCacheEntry(TEST_KEY_0)).isNotPresent(); - assertThat(buffer.getUpstream().get(TEST_KEY_0)).isPresent(); + assertThat(buffer.getUpstream().get(TEST_KEY_0)).isPresent().hasValue(TEST_VALUE_0); - buffer.put(TEST_KEY_5, TEST_VALUE_5); + buffer.put(TEST_KEY_1, TEST_VALUE_1); - assertThat(buffer.getUpstream().get(TEST_KEY_5)).isNotPresent(); - assertThat(buffer.getCacheEntry(TEST_KEY_5)).isPresent(); + assertThat(buffer.getUpstream().get(TEST_KEY_1)).isNotPresent(); + assertThat(buffer.getCacheEntry(TEST_KEY_1)).isPresent(); observer.commit(); - assertThat(buffer.getUpstream().get(TEST_KEY_5)).isPresent().hasValue(TEST_VALUE_5); + assertThat(buffer.getUpstream().get(TEST_KEY_1)).isPresent().hasValue(TEST_VALUE_1); } @ParameterizedTest @@ -127,7 +117,7 @@ void testCommit(String key, String value) { assertThat(commitTrack.getUpstream().get(key)).isNotPresent(); observer.commit(); - assertThat(commitTrack.get(key)).isPresent(); + assertThat(commitTrack.get(key)).isPresent().hasValue(value); assertThat(commitTrack.getUpstream().get(key)).isPresent().hasValue(value); commitTrack.getUpstream().remove(key); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/flush/InstantFlusherTest.java b/db/core/src/test/java/org/ethereum/beacon/db/flush/InstantFlusherTest.java index e4c56d245..e846eb09d 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/flush/InstantFlusherTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/flush/InstantFlusherTest.java @@ -2,11 +2,14 @@ import org.ethereum.beacon.db.source.WriteBuffer; import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; -import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; class InstantFlusherTest { @@ -47,8 +50,6 @@ public void flush() { } }; - assertThat(instantFlusher).isNotNull(); - assertThat(doFlush).isFalse(); assertThat(datasourceFlush).isFalse(); assertThat(instantFlushed).isFalse(); @@ -78,8 +79,6 @@ public void flush() { } }; - assertThat(instantFlusher).isNotNull(); - assertThat(doFlush).isFalse(); assertThat(datasourceFlush).isFalse(); assertThat(instantFlushed).isFalse(); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java index d19d98fcc..e92455e06 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/AbstractLinkedDataSourceTest.java @@ -1,12 +1,14 @@ package org.ethereum.beacon.db.source; import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import javax.annotation.Nonnull; import java.util.Optional; -import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; class AbstractLinkedDataSourceTest { @@ -19,7 +21,8 @@ class AbstractLinkedDataSourceTest { @BeforeEach void setUp() { - dataSource = new AbstractLinkedDataSource(new HashMapDataSource<>()) { + final HashMapDataSource upstream = new HashMapDataSource<>(); + dataSource = new AbstractLinkedDataSource(upstream) { public Optional get(@Nonnull String key) { return getUpstream().get(key); } @@ -33,7 +36,7 @@ public void remove(@Nonnull String key) { } }; - assertThat(dataSource).isNotNull(); + assertThat(dataSource.getUpstream()).isEqualTo(upstream); } @Test @@ -55,11 +58,12 @@ public void remove(@Nonnull Object key) { @Test void testGetPutRemoveUpstreamFlush() { - dataSource = new AbstractLinkedDataSource(new HashMapDataSource() { + final HashMapDataSource upstream = new HashMapDataSource() { public void flush() { getStore().put(TEST_FLUSH, TEST_FLUSH); } - }, true) { + }; + dataSource = new AbstractLinkedDataSource(upstream, true) { public Optional get(@Nonnull String key) { return getUpstream().get(key); } @@ -77,8 +81,7 @@ protected void doFlush() { } }; - assertThat(dataSource).isNotNull(); - assertThat(dataSource.getUpstream()).isNotNull(); + assertThat(dataSource.getUpstream()).isEqualTo(upstream); dataSource.put(TEST_KEY, TEST_VALUE); assertThat(dataSource.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); @@ -117,9 +120,4 @@ protected void doFlush() { assertThat(dataSource.get(TEST_FLUSH)).isNotPresent(); assertThat(dataSource.get(TEST_DO_FLUSH)).isPresent().hasValue(TEST_DO_FLUSH); } - - @Test - void testGetUpstream() { - assertThat(dataSource.getUpstream()).isNotNull(); - } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/BatchUpdateDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/BatchUpdateDataSourceTest.java index 1116f78c5..b9b0f8738 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/BatchUpdateDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/BatchUpdateDataSourceTest.java @@ -11,7 +11,6 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.junit.jupiter.api.Assertions.*; class BatchUpdateDataSourceTest { @@ -52,14 +51,11 @@ public void flush() { } }; - assertThat(dataSource).isNotNull(); + assertThat(dataSource.get("something")).isNotPresent(); } @Test - void testGetPutRemoveFlushBatchUpdate() { - assertThat(dataSource.get("test_key_0")).isNotPresent(); - dataSource.put("test_key_0", "test_value_0"); - assertThat(dataSource.get("test_key_0")).isPresent().hasValue("test_value_0"); + void testBatchUpdate() { final Map updates = new HashMap<>(); updates.put("test_key_1", "test_value_1"); updates.put("test_key_2", "test_value_2"); @@ -67,12 +63,28 @@ void testGetPutRemoveFlushBatchUpdate() { updates.put("test_key_4", "test_value_4"); updates.put("test_key_5", "test_value_5"); dataSource.batchUpdate(updates); - dataSource.remove("test_key_5"); - assertThat(dataSource.get("test_valu_5")).isNotPresent(); + assertThat(dataSource.get("test_key_1")).isPresent().hasValue("test_value_1"); + assertThat(dataSource.get("test_key_2")).isPresent().hasValue("test_value_2"); + assertThat(dataSource.get("test_key_3")).isPresent().hasValue("test_value_3"); + assertThat(dataSource.get("test_key_4")).isPresent().hasValue("test_value_4"); + assertThat(dataSource.get("test_key_5")).isPresent().hasValue("test_value_5"); + } + + @Test + void testFlush() { dataSource.flush(); assertThat(dataSource.get("test_flush")).isPresent().hasValue("test_flush"); } + @Test + void testPutGetRemove() { + assertThat(dataSource.get("test_key_0")).isNotPresent(); + dataSource.put("test_key_0", "test_value_0"); + assertThat(dataSource.get("test_key_0")).isPresent().hasValue("test_value_0"); + dataSource.remove("test_key_0"); + assertThat(dataSource.get("test_key_0")).isNotPresent(); + } + @Test void testNullValues() { assertThatThrownBy(() -> dataSource.put(null, null)).isInstanceOf(NullPointerException.class); @@ -87,4 +99,4 @@ void testNullValues() { updates.put("test_value_0", null); assertThatThrownBy(() -> dataSource.batchUpdate(updates)).isInstanceOf(NullPointerException.class); } -} \ No newline at end of file +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/CacheDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/CacheDataSourceTest.java index 09aca886c..b91a5e516 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/CacheDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/CacheDataSourceTest.java @@ -13,12 +13,11 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.junit.jupiter.api.Assertions.*; class CacheDataSourceTest { - private CacheDataSource dataSource; private long size; + private CacheDataSource dataSource; @BeforeEach void setUp() { @@ -78,7 +77,11 @@ public void flush() { } }; - assertThat(dataSource).isNotNull(); + assertThat(dataSource.evaluateSize()).isEqualTo(size); + } + + private Function getKeyValueEvaluator() { + return s -> 1L; } @Test @@ -112,8 +115,4 @@ void testNullValues() { assertThatThrownBy(() -> dataSource.remove(null)).isInstanceOf(NullPointerException.class); assertThatThrownBy(() -> dataSource.getCacheEntry(null)).isInstanceOf(NullPointerException.class); } - - private Function getKeyValueEvaluator() { - return s -> 1L; - } -} \ No newline at end of file +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/CacheSizeEvaluatorTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/CacheSizeEvaluatorTest.java index ac18f0dff..fb0f180da 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/CacheSizeEvaluatorTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/CacheSizeEvaluatorTest.java @@ -6,17 +6,17 @@ import java.util.function.Function; import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; class CacheSizeEvaluatorTest { + private static final int emptySize = 0; + private long size; private CacheSizeEvaluator cacheSizeEvaluator; @BeforeEach void setUp() { - size = 0; - final Function keyEvaluator = s -> 1L; + final Function keyEvaluator = getKeyValueEvaluator(); cacheSizeEvaluator = new CacheSizeEvaluator() { @Override public long getEvaluatedSize() { @@ -38,59 +38,63 @@ public void removed(String key, String value) { size -= keyEvaluator.apply(key); } }; - assertThat(cacheSizeEvaluator).isNotNull(); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(size); + } + + private Function getKeyValueEvaluator() { + return s -> 1L; } @Test void testAddedRemoveResetSize(){ cacheSizeEvaluator.added("key_0", "value_0"); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(emptySize); long evaluatedSize = cacheSizeEvaluator.getEvaluatedSize(); cacheSizeEvaluator.removed("key_0", "value_0"); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(emptySize); cacheSizeEvaluator.added("key_1", "value_1"); cacheSizeEvaluator.added("key_2", "value_2"); assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(evaluatedSize); cacheSizeEvaluator.reset(); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(emptySize); } @Test void testNoSizeEvaluator() { cacheSizeEvaluator = CacheSizeEvaluator.noSizeEvaluator(); - assertThat(cacheSizeEvaluator).isNotNull(); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(emptySize); cacheSizeEvaluator.added("key_0", "value_0"); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(emptySize); size = cacheSizeEvaluator.getEvaluatedSize(); cacheSizeEvaluator.removed("key_0", "value_0"); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(emptySize); cacheSizeEvaluator.added("key_1", "value_1"); cacheSizeEvaluator.added("key_2", "value_2"); assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(size); cacheSizeEvaluator.reset(); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(emptySize); } @Test void testKeySizeGetIntance(){ final Function keyEvaluator = s -> 1L; cacheSizeEvaluator = CacheSizeEvaluator.getInstance(keyEvaluator); - assertThat(cacheSizeEvaluator).isNotNull(); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(emptySize); cacheSizeEvaluator.added("key_0", "value_0"); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(emptySize); size = cacheSizeEvaluator.getEvaluatedSize(); cacheSizeEvaluator.removed("key_0", "value_0"); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(emptySize); cacheSizeEvaluator.added("key_1", "value_1"); cacheSizeEvaluator.added("key_2", "value_2"); cacheSizeEvaluator.added("key_3", "value_3"); assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(size); cacheSizeEvaluator.reset(); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(emptySize); } @@ -99,19 +103,19 @@ void testKeyValueSizeGetInstance() { final Function keyEvaluator = s -> 1L; final Function valueEvaluator = keyEvaluator; cacheSizeEvaluator = CacheSizeEvaluator.getInstance(keyEvaluator, valueEvaluator); - assertThat(cacheSizeEvaluator).isNotNull(); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(emptySize); cacheSizeEvaluator.added("key_0", "value_0"); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(emptySize); size = cacheSizeEvaluator.getEvaluatedSize(); cacheSizeEvaluator.removed("key_0", "value_0"); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(emptySize); cacheSizeEvaluator.added("key_1", "value_1"); cacheSizeEvaluator.added("key_2", "value_2"); cacheSizeEvaluator.added("key_3", "value_3"); assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(size); cacheSizeEvaluator.reset(); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isEqualTo(emptySize); } @Test @@ -125,7 +129,7 @@ void testNullValues() { cacheSizeEvaluator.added(null, null); cacheSizeEvaluator.added(null, "not_null"); cacheSizeEvaluator.added("not_null", null); - assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(0); + assertThat(cacheSizeEvaluator.getEvaluatedSize()).isGreaterThan(emptySize); } -} \ No newline at end of file +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java index fa86cde5f..fd0b44211 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/CodecSourceTest.java @@ -3,7 +3,8 @@ import org.ethereum.beacon.db.source.impl.HashMapDataSource; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.*; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import java.util.function.Function; import java.util.stream.Stream; @@ -18,7 +19,6 @@ class CodecSourceTest { @BeforeEach void setUp() { source = new CodecSource<>(new HashMapDataSource<>(), Function.identity(), Function.identity(), Function.identity()); - assertThat(source).isNotNull(); } @ParameterizedTest @@ -88,7 +88,6 @@ private static Stream keyValueArgumentsProvider() { @MethodSource("keyValueArgumentsProvider") void testKeyConversion(String key, String value) { source = new CodecSource<>(new HashMapDataSource<>(), k -> encode(k, key), Function.identity(), Function.identity()); - assertThat(source).isNotNull(); assertThat(source.get(key)).isNotPresent(); source.put(key, value); @@ -103,7 +102,6 @@ private String encode(String value, String valueModifier) { @MethodSource("keyValueArgumentsProvider") void testValueTargetValueToUpValueConversion(String key, String value) { source = new CodecSource<>(new HashMapDataSource<>(), k -> encode(k, key), k -> encode(k, value), Function.identity()); - assertThat(source).isNotNull(); assertThat(source.get(key)).isNotPresent(); source.put(key, value); @@ -114,7 +112,6 @@ void testValueTargetValueToUpValueConversion(String key, String value) { @MethodSource("keyValueArgumentsProvider") void testValueUpValueToTargetValueConversion(String key, String value) { source = new CodecSource<>(new HashMapDataSource<>(), k -> encode(k, key), k -> encode(k, value), k -> decode()); - assertThat(source).isNotNull(); assertThat(source.get(key)).isNotPresent(); source.put(key, value); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/DataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/DataSourceTest.java index 2303cdf15..4dad9f6cb 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/DataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/DataSourceTest.java @@ -2,15 +2,18 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import javax.annotation.Nonnull; import java.util.Map; import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; +import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Java6Assertions.assertThatThrownBy; -import static org.junit.jupiter.api.Assertions.*; class DataSourceTest { @@ -40,11 +43,12 @@ public void flush() { store.put("test_flush", "test_flush"); } }; + + assertThat(dataSource.get("something")).isNotPresent(); } @Test - void testGetPutRemoveFlush() { - assertThat(dataSource.get("test_key_0")).isNotPresent(); + void testPutGetRemoveFlush() { dataSource.put("test_key_0", "test_value_0"); dataSource.put("test_key_1", "test_value_1"); assertThat(dataSource.get("test_key_0")).isPresent().hasValue("test_value_0"); @@ -56,12 +60,27 @@ void testGetPutRemoveFlush() { assertThat(dataSource.get("test_flush")).isPresent().hasValue("test_flush"); } + @ParameterizedTest + @MethodSource("invalidArgumentsProvider") + void testPutNull(String key, String value) { + assertThatThrownBy(() -> dataSource.put(key, value)).isInstanceOf(NullPointerException.class); + } + + private static Stream invalidArgumentsProvider() { + return Stream.of( + Arguments.of(null, null), + Arguments.of("not_null", null), + Arguments.of(null, "not_null") + ); + } + @Test - void testNullValues() { + void testGetNull() { assertThatThrownBy(() -> dataSource.get(null)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> dataSource.put(null, null)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> dataSource.put("not_null", null)).isInstanceOf(NullPointerException.class); - assertThatThrownBy(() -> dataSource.put(null, "not_null")).isInstanceOf(NullPointerException.class); + } + + @Test + void testRemoveNull() { assertThatThrownBy(() -> dataSource.remove(null)).isInstanceOf(NullPointerException.class); } -} \ No newline at end of file +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java index eee8b7d04..63789952e 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/HoleyListTest.java @@ -1,8 +1,11 @@ package org.ethereum.beacon.db.source; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; -import java.util.*; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; @@ -34,7 +37,7 @@ public Optional get(long idx) { } }; - assertThat(list).isNotNull(); + assertThat(list.size()).isEqualTo(0); } @Test diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java index b93d96456..f497226f8 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/LinkedDataSourceTest.java @@ -1,7 +1,8 @@ package org.ethereum.beacon.db.source; import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import javax.annotation.Nonnull; import java.util.Optional; @@ -38,7 +39,7 @@ public DataSource getUpstream() { } }; - assertThat(dataSource).isNotNull(); + assertThat(dataSource.getUpstream()).isNull(); } @Test @@ -46,11 +47,6 @@ void testSetUpstream() { assertThatThrownBy(() -> dataSource.setUpstream(new HashMapDataSource<>())).isInstanceOf(UnsupportedOperationException.class); } - @Test - void testGetNullUpstream() { - assertThat(dataSource.getUpstream()).isNull(); - } - @Test void testGetUpstream() { dataSource = new LinkedDataSource() { @@ -75,7 +71,6 @@ public DataSource getUpstream() { return new HashMapDataSource<>(); } }; - assertThat(dataSource).isNotNull(); assertThat(dataSource.getUpstream()).isNotNull(); } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/ReadonlyDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/ReadonlyDataSourceTest.java index e949efffe..3e029a5b0 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/ReadonlyDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/ReadonlyDataSourceTest.java @@ -22,9 +22,8 @@ void setUp() { return Optional.ofNullable(store.get(key)); }; - assertThat(readonlyDataSource).isNotNull(); - store.put("test_key_0", "test_value_0"); + assertThat(store.get("test_key_0")).isNotNull(); } @Test @@ -32,8 +31,13 @@ void testGet() { assertThat(readonlyDataSource.get("test_key_0")).isPresent().hasValue("test_value_0"); } + @Test + void testInvalidGet() { + assertThat(readonlyDataSource.get("test_key_1")).isNotPresent(); + } + @Test void testNullValue(){ assertThatThrownBy(() -> readonlyDataSource.get(null)).isInstanceOf(NullPointerException.class); } -} \ No newline at end of file +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/SingleValueSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/SingleValueSourceTest.java index 19260a5b5..9a268cf24 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/SingleValueSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/SingleValueSourceTest.java @@ -1,9 +1,12 @@ package org.ethereum.beacon.db.source; import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.*; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import java.util.Optional; import java.util.function.Function; @@ -39,7 +42,6 @@ public void remove() { } }; - assertThat(source).isNotNull(); assertThat(source.get()).isEmpty(); } @@ -100,7 +102,6 @@ void testValidFromDataSource() { @Test void testGetSetRemoveSourceValue() { source = SingleValueSource.fromDataSource(new HashMapDataSource<>(), TEST_KEY, Function.identity(), Function.identity()); - assertThat(source).isNotNull(); assertThat(source.get()).isNotPresent(); source.set(TEST_VALUE); assertThat(source.get()).isPresent().hasValue(TEST_VALUE); @@ -129,7 +130,6 @@ void testGetSetRemoveWithEncodeDecode() { @Test void memSourceGetSetRemoveTest() { source = SingleValueSource.memSource(); - assertThat(source).isNotNull(); assertThat(source.get()).isNotPresent(); source.set(TEST_VALUE); assertThat(source.get()).isPresent().hasValue(TEST_VALUE); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/StorageEngineSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/StorageEngineSourceTest.java index cb1365e19..f38369e0b 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/StorageEngineSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/StorageEngineSourceTest.java @@ -12,7 +12,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertTrue; class StorageEngineSourceTest { @@ -63,8 +63,6 @@ public void flush() { store.put(wrap("test_flush"), "test_flush"); } }; - - assertThat(storageEngineSource).isNotNull(); } @Test @@ -73,7 +71,7 @@ void testBasicOperations(){ storageEngineSource.put(wrap("key_0"), "value_0"); assertThat(storageEngineSource.get(wrap("key_0")).get()).isEqualTo("value_0"); - Map batch = new HashMap<>(); + final Map batch = new HashMap<>(); batch.put(wrap("key_2"), "value_2"); batch.put(wrap("key_3"), "value_3"); batch.put(wrap("key_4"), "value_4"); @@ -106,4 +104,4 @@ void testBasicOperations(){ private BytesValue wrap(String value) { return BytesValue.wrap(value.getBytes()); } -} \ No newline at end of file +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/TransactionalDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/TransactionalDataSourceTest.java index 8c0d7fa8e..a2f5715ba 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/TransactionalDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/TransactionalDataSourceTest.java @@ -2,7 +2,6 @@ import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import javax.annotation.Nonnull; @@ -10,10 +9,10 @@ import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; -import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -public class TransactionalDataSourceTest { +class TransactionalDataSourceTest { private final String TEST_KEY = "test_key"; private final String TEST_VALUE = "test_value"; @@ -23,8 +22,7 @@ public class TransactionalDataSourceTest { private TransactionalDataSource transactionalDataSource; @BeforeEach - public void setUp() - { + void setUp() { Map store = new ConcurrentHashMap<>(); transaction = new TransactionalDataSource.Transaction() { @Override @@ -52,8 +50,6 @@ public void flush() { store.put(TEST_FLUSH, TEST_FLUSH); } }; - assertThat(transaction).isNotNull(); - transactionalDataSource = new TransactionalDataSource() { @Override @@ -66,29 +62,22 @@ public Optional get(@Nonnull String key) { return transaction.get(key); } }; - - assertThat(transactionalDataSource).isNotNull(); } @Test - public void testValidStartTransaction() { - assertThat((TransactionalDataSource.TransactionOptions) () -> TransactionalDataSource.IsolationLevel.Snapshot).isNotNull(); - assertThat((TransactionalDataSource.TransactionOptions) () -> TransactionalDataSource.IsolationLevel.RepeatableReads).isNotNull(); - assertThat((TransactionalDataSource.TransactionOptions) () -> TransactionalDataSource.IsolationLevel.ReadUncommitted).isNotNull(); - assertThat((TransactionalDataSource.TransactionOptions) () -> TransactionalDataSource.IsolationLevel.ReadCommitted).isNotNull(); - - TransactionalDataSource.TransactionOptions transactionOptions = () -> TransactionalDataSource.IsolationLevel.Snapshot; + void testValidStartTransaction() { + final TransactionalDataSource.TransactionOptions transactionOptions = () -> TransactionalDataSource.IsolationLevel.Snapshot; assertThat(transactionalDataSource.startTransaction(transactionOptions)).isEqualTo(transaction); assertThat(transactionOptions.getIsolationLevel()).isIn(TransactionalDataSource.IsolationLevel.values()); } @Test - public void testInvalidStartTransaction() { - TransactionalDataSource.TransactionOptions transactionOptions = () -> TransactionalDataSource.IsolationLevel.valueOf("illegalArgument"); - assertThat(transactionOptions).isNotNull(); + void testInvalidStartTransaction() { + final TransactionalDataSource.TransactionOptions transactionOptions = () -> TransactionalDataSource.IsolationLevel.valueOf("illegalArgument"); assertThat(transactionalDataSource.startTransaction(transactionOptions)).isEqualTo(transaction); assertThat(transactionalDataSource.startTransaction(null)).isEqualTo(transaction); - assertThatThrownBy( () -> transactionOptions.getIsolationLevel().equals(TransactionalDataSource.IsolationLevel.Snapshot)).isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> transactionOptions.getIsolationLevel().equals(TransactionalDataSource.IsolationLevel.Snapshot)) + .isInstanceOf(IllegalArgumentException.class); } @Test @@ -121,8 +110,8 @@ void testNullValues() { } @Test - public void testException() { + void testException() { assertThat(new TransactionalDataSource.TransactionException("exception")).isNotNull(); assertThat(new TransactionalDataSource.TransactionException("exception", new Throwable(""))).isNotNull(); } -} \ No newline at end of file +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/WriteBufferTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteBufferTest.java index 9eeab1ec0..f73396d8d 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/WriteBufferTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/WriteBufferTest.java @@ -13,7 +13,6 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.junit.jupiter.api.Assertions.*; class WriteBufferTest { @@ -26,11 +25,10 @@ class WriteBufferTest { void setUp() { keyValueEvaluator = s -> 1L; evaluator = CacheSizeEvaluator.getInstance(keyValueEvaluator); - assertThat(keyValueEvaluator).isNotNull(); - assertThat(evaluator).isNotNull(); dataSource = new HashMapDataSource(); buffer = new WriteBuffer<>(dataSource, evaluator, true); - assertThat(buffer).isNotNull(); + assertThat(buffer.evaluateSize()).isEqualTo(evaluator.getEvaluatedSize()); + assertThat(buffer.getUpstream()).isEqualTo(dataSource); } @ParameterizedTest @@ -117,4 +115,4 @@ private static Stream nullArgumentsProvider() { Arguments.of(null, "not_null") ); } -} \ No newline at end of file +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/CacheSizeEvaluatorImplTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/CacheSizeEvaluatorImplTest.java index e2ad37552..c582f2f6f 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/CacheSizeEvaluatorImplTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/CacheSizeEvaluatorImplTest.java @@ -1,11 +1,14 @@ package org.ethereum.beacon.db.source.impl; import org.ethereum.beacon.db.source.CacheSizeEvaluator; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import java.util.function.Function; -import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; class CacheSizeEvaluatorImplTest { @@ -19,7 +22,6 @@ class CacheSizeEvaluatorImplTest { @BeforeEach void setUp() { cacheSizeEvaluator = new CacheSizeEvaluatorImpl<>(key -> (long) key.length(), key -> (long) key.length()); - assertThat(cacheSizeEvaluator).isNotNull(); createdStorageSize = cacheSizeEvaluator.getEvaluatedSize(); assertThat(createdStorageSize).isEqualTo(EMPTY_SIZE); } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java index 7e558df26..13c05c2da 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DataSourceListTest.java @@ -1,15 +1,18 @@ package org.ethereum.beacon.db.source.impl; import org.ethereum.beacon.db.source.DataSource; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.*; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import tech.pegasys.artemis.util.bytes.BytesValue; import java.util.function.Function; import java.util.stream.Stream; -import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; class DataSourceListTest { @@ -18,7 +21,6 @@ class DataSourceListTest { @BeforeEach void setUp() { dataSourceList = new DataSourceList<>(new HashMapDataSource<>(), serialize(), deserialize()); - assertThat(dataSourceList).isNotNull(); assertThat(dataSourceList.size()).isEqualTo(0); } @@ -62,9 +64,9 @@ private static Stream putGetSizeArgumentsProvider() { @Test void testGetOverIndex() { - final Long TEST_KEY_0 = 0L; - final Long TEST_KEY_1 = 1L; - final Long TEST_KEY_LESS_ZERO = -1L; + final long TEST_KEY_0 = 0L; + final long TEST_KEY_1 = 1L; + final long TEST_KEY_LESS_ZERO = -1L; final String TEST_VALUE = "test_value"; dataSourceList.put(TEST_KEY_0, TEST_VALUE); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java index 11baf4574..3ca6221b1 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/DelegateDataSourceTest.java @@ -1,8 +1,10 @@ package org.ethereum.beacon.db.source.impl; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.*; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import java.util.stream.Stream; @@ -20,7 +22,7 @@ class DelegateDataSourceTest { @BeforeEach void setUp() { delegateDataSource = new DelegateDataSource<>(new HashMapDataSource<>()); - assertThat(delegateDataSource).isNotNull(); + assertThat(delegateDataSource.get(TEST_KEY)).isNotPresent(); } @Test @@ -52,11 +54,12 @@ public void flush() { store.put(TEST_FLUSH, TEST_FLUSH); } }); - assertThat(delegateDataSource).isNotNull(); + assertThat(delegateDataSource.get(TEST_KEY)).isNotPresent(); delegateDataSource.put(TEST_KEY, TEST_VALUE); assertThat(delegateDataSource.get(TEST_KEY)).isPresent().hasValue(TEST_VALUE); + assertThat(delegateDataSource.get(TEST_FLUSH)).isNotPresent(); delegateDataSource.flush(); assertThat(delegateDataSource.get(TEST_FLUSH)).isPresent().hasValue(TEST_FLUSH); } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapDataSourceTest.java index 9a09c3dc0..8e8a58a13 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapDataSourceTest.java @@ -1,7 +1,6 @@ package org.ethereum.beacon.db.source.impl; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.CsvSource; @@ -12,7 +11,6 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.junit.jupiter.api.Assertions.*; class HashMapDataSourceTest { @@ -21,7 +19,6 @@ class HashMapDataSourceTest { @BeforeEach void setUp() { dataSource = new HashMapDataSource<>(); - assertThat(dataSource).isNotNull(); } @ParameterizedTest @@ -65,4 +62,4 @@ private static Stream nullArgumentsProvider() { Arguments.of(null, "not_null") ); } -} \ No newline at end of file +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java index ff9fe5446..06044cfe2 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/HashMapHoleyListTest.java @@ -1,9 +1,11 @@ package org.ethereum.beacon.db.source.impl; import org.ethereum.beacon.db.source.HoleyList; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.*; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import java.util.stream.Stream; @@ -16,7 +18,6 @@ class HashMapHoleyListTest { @BeforeEach void setUp() { map = new HashMapHoleyList<>(); - assertThat(map).isNotNull(); assertThat(map.size()).isEqualTo(0L); } @@ -63,8 +64,8 @@ private static Stream invalidKeyArgumentsProvider() { @Test void testPutSameKey() { - final Long TEST_KEY = 0L; - final Long TEST_KEY_1 = 1L; + final long TEST_KEY = 0L; + final long TEST_KEY_1 = 1L; final String TEST_VALUE = "test_value"; final String TEST_VALUE_NEW = "NewTestValue"; diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java index 0a301ef1c..a009df537 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/XorDataSourceTest.java @@ -4,7 +4,8 @@ import org.junit.jupiter.api.Test; import tech.pegasys.artemis.util.bytes.BytesValue; -import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; class XorDataSourceTest { @@ -16,7 +17,11 @@ void testDataSourceCreation() { assertThatThrownBy(() -> new XorDataSource<>(null, null)) .isInstanceOf(NullPointerException.class); - assertThat(new XorDataSource<>(new HashMapDataSource<>(), null)).isNotNull(); - assertThat(new XorDataSource<>(new HashMapDataSource<>(), BytesValue.of(1,2,3))).isNotNull(); + final HashMapDataSource upstream = new HashMapDataSource<>(); + XorDataSource actual = new XorDataSource<>(upstream, null); + assertThat(actual.getUpstream()).isEqualTo(upstream); + + actual = new XorDataSource<>(upstream, BytesValue.of(1, 2, 3)); + assertThat(actual.getUpstream()).isEqualTo(upstream); } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/util/AutoCloseableLockTest.java b/db/core/src/test/java/org/ethereum/beacon/db/util/AutoCloseableLockTest.java index 5bf9b25e2..e80e278f1 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/util/AutoCloseableLockTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/util/AutoCloseableLockTest.java @@ -1,15 +1,21 @@ package org.ethereum.beacon.db.util; import org.jetbrains.annotations.NotNull; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.*; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import java.util.concurrent.TimeUnit; -import java.util.concurrent.locks.*; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; import java.util.stream.Stream; -import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; class AutoCloseableLockTest { @@ -23,8 +29,10 @@ void testInvalidCreation() { @ParameterizedTest @MethodSource("creationArgumentsProvider") void testValidCreation(Lock lock) { - final AutoCloseable result = new AutoCloseableLock(lock); - assertThat(result).isNotNull(); + final AutoCloseableLock result = new AutoCloseableLock(lock); + result + .lock() + .unlock(); } private static Stream creationArgumentsProvider() { @@ -38,8 +46,10 @@ private static Stream creationArgumentsProvider() { @ParameterizedTest @MethodSource("creationArgumentsProvider") void wrap(Lock lock) { - final AutoCloseable result = AutoCloseableLock.wrap(lock); - assertThat(result).isNotNull(); + final AutoCloseableLock result = AutoCloseableLock.wrap(lock); + result + .lock() + .unlock(); } private boolean locked; From 9f0ccfc082dcbf7bfbf014fef5d7f3211a7be39c Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Mon, 16 Sep 2019 19:15:45 +0300 Subject: [PATCH 26/44] test: add non-null checking into BufferSizeObserver --- .../java/org/ethereum/beacon/db/flush/BufferSizeObserver.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/db/core/src/main/java/org/ethereum/beacon/db/flush/BufferSizeObserver.java b/db/core/src/main/java/org/ethereum/beacon/db/flush/BufferSizeObserver.java index 589b5a58f..606c863dd 100644 --- a/db/core/src/main/java/org/ethereum/beacon/db/flush/BufferSizeObserver.java +++ b/db/core/src/main/java/org/ethereum/beacon/db/flush/BufferSizeObserver.java @@ -30,7 +30,8 @@ public class BufferSizeObserver implements DatabaseFlusher { this.bufferSizeLimit = bufferSizeLimit; } - public static BufferSizeObserver create(WriteBuffer buffer, long bufferSizeLimit) { + public static BufferSizeObserver create(@Nonnull WriteBuffer buffer, long bufferSizeLimit) { + Objects.requireNonNull(buffer); WriteBuffer commitTrack = new WriteBuffer<>(buffer, false); return new BufferSizeObserver(buffer, commitTrack, bufferSizeLimit); } From e1db551b0b142aa029a9380cc2081eaa6b4365a6 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Tue, 17 Sep 2019 14:57:13 +0300 Subject: [PATCH 27/44] test: add flush test into BufferSizeObserver --- .../db/flush/BufferSizeObserverTest.java | 38 +++++++++++++++---- 1 file changed, 31 insertions(+), 7 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java b/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java index ed3daad84..04fe26621 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/flush/BufferSizeObserverTest.java @@ -13,7 +13,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; -import static org.junit.jupiter.api.Assertions.assertTrue; //TODO: need more tests @@ -23,14 +22,32 @@ class BufferSizeObserverTest { private WriteBuffer commitTrack; private BufferSizeObserver observer; + private boolean commitTrackDoFlush; + private boolean bufferFlushed; + @BeforeEach void setUp() { - final HashMapDataSource upstream = new HashMapDataSource<>(); - buffer = new WriteBuffer<>(upstream, true); + commitTrackDoFlush = false; + bufferFlushed = false; + + final HashMapDataSource upstream = new HashMapDataSource() { + @Override + public void flush() { + bufferFlushed = true; + super.flush(); + } + }; + buffer = new WriteBuffer<>(upstream, false); assertThat(buffer.getUpstream()).isEqualTo(upstream); assertThat(buffer.evaluateSize()).isEqualTo(0); - commitTrack = new WriteBuffer<>(upstream, true); + commitTrack = new WriteBuffer(upstream, false) { + @Override + public void doFlush() { + commitTrackDoFlush = true; + super.doFlush(); + } + }; assertThat(commitTrack.getUpstream()).isEqualTo(upstream); assertThat(commitTrack.evaluateSize()).isEqualTo(0); @@ -60,7 +77,8 @@ void testPutNullKeyValue(String key, String value) { private static Stream nullKeyValueArgumentsProvider() { return Stream.of( Arguments.of(null, null), - Arguments.of("not_null", null) + Arguments.of("not_null", null), + Arguments.of(null, "not_null") ); } @@ -79,7 +97,6 @@ void testCreate() { assertThat(buffer.get(TEST_KEY_0)).isPresent().hasValue(TEST_VALUE_0); assertThat(buffer.getCacheEntry(TEST_KEY_0)).isPresent(); - assertTrue(buffer.evaluateSize() >= Long.MIN_VALUE, "Needed db flush"); observer.flush(); assertThat(buffer.getCacheEntry(TEST_KEY_0)).isNotPresent(); @@ -111,14 +128,21 @@ void testFlush(String key, String value) { @ParameterizedTest @CsvSource({ "test_key, test_value"}) - void testCommit(String key, String value) { + void testCommitWithoutBufferFlushing(String key, String value) { commitTrack.put(key, value); assertThat(commitTrack.get(key)).isPresent().hasValue(value); assertThat(commitTrack.getUpstream().get(key)).isNotPresent(); + assertThat(buffer.getUpstream().get(key)).isNotPresent(); + assertThat(commitTrackDoFlush).isFalse(); + assertThat(bufferFlushed).isFalse(); observer.commit(); + assertThat(commitTrackDoFlush).isTrue(); + assertThat(bufferFlushed).isFalse(); assertThat(commitTrack.get(key)).isPresent().hasValue(value); assertThat(commitTrack.getUpstream().get(key)).isPresent().hasValue(value); + assertThat(buffer.get(key)).isPresent().hasValue(value); + assertThat(buffer.getUpstream().get(key)).isPresent().hasValue(value); commitTrack.getUpstream().remove(key); assertThat(commitTrack.get(key)).isNotPresent(); From 08825959f0ff43c2de38a5f1c4d4b102aec75bff Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Tue, 17 Sep 2019 18:44:14 +0300 Subject: [PATCH 28/44] test: add junit5 into gradle --- db/core/build.gradle | 17 ++++++++++++++++- test/src/test/resources/eth2.0-spec-tests | 2 +- 2 files changed, 17 insertions(+), 2 deletions(-) diff --git a/db/core/build.gradle b/db/core/build.gradle index 9d228310f..4e763afb7 100644 --- a/db/core/build.gradle +++ b/db/core/build.gradle @@ -1,7 +1,22 @@ dependencies { - api project(':types') + api(project(':types')) { + exclude group: 'junit' + } + api project(':crypto') api "org.rocksdb:rocksdbjni" api "com.googlecode.concurrent-locks:concurrent-locks" + + testImplementation 'org.junit.jupiter:junit-jupiter:5.5.1' + + test { + useJUnitPlatform { + excludeTags 'FIX' + } + } +} + +configurations { + testImplementation.exclude group: 'junit', module: 'junit' } diff --git a/test/src/test/resources/eth2.0-spec-tests b/test/src/test/resources/eth2.0-spec-tests index ae6dd9011..aaa1673f5 160000 --- a/test/src/test/resources/eth2.0-spec-tests +++ b/test/src/test/resources/eth2.0-spec-tests @@ -1 +1 @@ -Subproject commit ae6dd9011df05fab8c7e651c09cf9c940973bf81 +Subproject commit aaa1673f508103e11304833e0456e4149f880065 From ab80471770c89cd6fefbf2119e23f66e73777297 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Tue, 17 Sep 2019 18:48:09 +0300 Subject: [PATCH 29/44] test: replace junit4 with junit5 in java code --- .../beacon/db/EngineDrivenDatabaseTest.java | 133 ++++++++---------- .../beacon/db/RocksDbDrivenDatabaseTest.java | 68 +++++---- .../beacon/db/rocksdb/RocksDbSourceTest.java | 49 +++---- .../db/source/impl/MemSizeEvaluatorTest.java | 11 +- 4 files changed, 123 insertions(+), 138 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java index 28f27f043..fc708f596 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java @@ -1,32 +1,21 @@ package org.ethereum.beacon.db; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Random; -import java.util.Set; -import javax.annotation.Nonnull; -import org.ethereum.beacon.db.source.DataSource; -import org.ethereum.beacon.db.source.StorageEngineSource; +import org.ethereum.beacon.db.source.*; import org.ethereum.beacon.db.source.impl.MemSizeEvaluators; -import org.junit.Ignore; -import org.junit.Test; -import tech.pegasys.artemis.util.bytes.Bytes32; -import tech.pegasys.artemis.util.bytes.BytesValue; +import org.junit.jupiter.api.*; +import tech.pegasys.artemis.util.bytes.*; import tech.pegasys.artemis.util.uint.UInt64; -public class EngineDrivenDatabaseTest { +import javax.annotation.Nonnull; +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +class EngineDrivenDatabaseTest { @Test - public void generalCasesAreCorrect() { + void generalCasesAreCorrect() { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource); @@ -36,21 +25,21 @@ public void generalCasesAreCorrect() { storage.put(wrap("TWO"), wrap("SECOND")); assertTrue(engineSource.source.isEmpty()); - assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get()); - assertEquals(wrap("SECOND"), storage.get(wrap("TWO")).get()); - assertFalse(storage.get(wrap("THREE")).isPresent()); + assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get()); + assertThat(wrap("SECOND")).isEqualTo(storage.get(wrap("TWO")).get()); + assertThat(storage.get(wrap("THREE"))).isNotPresent(); db.commit(); - assertFalse(db.getWriteBuffer().getCacheEntry(wrap("ONE")).isPresent()); - assertFalse(db.getWriteBuffer().getCacheEntry(wrap("TWO")).isPresent()); - assertEquals(0L, db.getWriteBuffer().evaluateSize()); + assertThat(db.getWriteBuffer().getCacheEntry(wrap("ONE"))).isNotPresent(); + assertThat(db.getWriteBuffer().getCacheEntry(wrap("TWO"))).isNotPresent(); + assertThat(0L).isEqualTo(db.getWriteBuffer().evaluateSize()); assertTrue(engineSource.source.containsValue(wrap("FIRST"))); assertTrue(engineSource.source.containsValue(wrap("SECOND"))); - assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get()); - assertEquals(wrap("SECOND"), storage.get(wrap("TWO")).get()); - assertFalse(storage.get(wrap("THREE")).isPresent()); + assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get()); + assertThat(wrap("SECOND")).isEqualTo(storage.get(wrap("TWO")).get()); + assertThat(storage.get(wrap("THREE"))).isNotPresent(); storage.remove(wrap("SECOND")); storage.put(wrap("THREE"), wrap("THIRD")); @@ -60,9 +49,9 @@ public void generalCasesAreCorrect() { assertTrue(engineSource.source.containsValue(wrap("SECOND"))); assertFalse(engineSource.source.containsValue(wrap("THIRD"))); - assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get()); - assertFalse(storage.get(wrap("TWO")).isPresent()); - assertEquals(wrap("THIRD"), storage.get(wrap("THREE")).get()); + assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get()); + assertThat(storage.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("THIRD")).isEqualTo(storage.get(wrap("THREE")).get()); db.commit(); @@ -70,13 +59,13 @@ public void generalCasesAreCorrect() { assertFalse(engineSource.source.containsValue(wrap("SECOND"))); assertTrue(engineSource.source.containsValue(wrap("THIRD"))); - assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get()); - assertFalse(storage.get(wrap("TWO")).isPresent()); - assertEquals(wrap("THIRD"), storage.get(wrap("THREE")).get()); + assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get()); + assertThat(storage.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("THIRD")).isEqualTo(storage.get(wrap("THREE")).get()); } @Test - public void multipleStorageCase() { + void multipleStorageCase() { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource); @@ -90,39 +79,39 @@ public void multipleStorageCase() { dos.put(wrap("FOUR"), wrap("DOS_FOURTH")); db.commit(); - assertEquals(wrap("FIRST"), uno.get(wrap("ONE")).get()); - assertEquals(wrap("SECOND"), uno.get(wrap("TWO")).get()); - assertEquals(wrap("SECOND"), dos.get(wrap("TWO")).get()); - assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get()); - assertEquals(wrap("DOS_FOURTH"), dos.get(wrap("FOUR")).get()); - assertFalse(uno.get(wrap("FOUR")).isPresent()); - assertFalse(dos.get(wrap("ONE")).isPresent()); - assertFalse(dos.get(wrap("THREE")).isPresent()); + assertThat(wrap("FIRST")).isEqualTo(uno.get(wrap("ONE")).get()); + assertThat(wrap("SECOND")).isEqualTo(uno.get(wrap("TWO")).get()); + assertThat(wrap("SECOND")).isEqualTo(dos.get(wrap("TWO")).get()); + assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get()); + assertThat(wrap("DOS_FOURTH")).isEqualTo(dos.get(wrap("FOUR")).get()); + assertThat(uno.get(wrap("FOUR"))).isNotPresent(); + assertThat(dos.get(wrap("ONE"))).isNotPresent(); + assertThat(dos.get(wrap("THREE"))).isNotPresent(); uno.remove(wrap("TWO")); dos.put(wrap("THREE"), wrap("DOS_THIRD")); - assertFalse(uno.get(wrap("TWO")).isPresent()); - assertEquals(wrap("DOS_THIRD"), dos.get(wrap("THREE")).get()); - assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get()); + assertThat(uno.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("DOS_THIRD")).isEqualTo(dos.get(wrap("THREE")).get()); + assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get()); db.commit(); - assertFalse(uno.get(wrap("TWO")).isPresent()); - assertEquals(wrap("DOS_THIRD"), dos.get(wrap("THREE")).get()); - assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get()); + assertThat(uno.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("DOS_THIRD")).isEqualTo(dos.get(wrap("THREE")).get()); + assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get()); dos.remove(wrap("FOUR")); uno.put(wrap("FOUR"), wrap("UNO_FOURTH")); - assertEquals(wrap("UNO_FOURTH"), uno.get(wrap("FOUR")).get()); - assertFalse(dos.get(wrap("FOUR")).isPresent()); + assertThat(wrap("UNO_FOURTH")).isEqualTo(uno.get(wrap("FOUR")).get()); + assertThat(dos.get(wrap("FOUR"))).isNotPresent(); db.commit(); - assertEquals(wrap("UNO_FOURTH"), uno.get(wrap("FOUR")).get()); - assertFalse(dos.get(wrap("FOUR")).isPresent()); + assertThat(wrap("UNO_FOURTH")).isEqualTo(uno.get(wrap("FOUR")).get()); + assertThat(dos.get(wrap("FOUR"))).isNotPresent(); } @Test - public void checkBufferSizeFlusher() { + void checkBufferSizeFlusher() { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.create(engineSource, 512); @@ -142,29 +131,29 @@ public void checkBufferSizeFlusher() { // should be flushed now db.commit(); - assertEquals(4, engineSource.source.size()); - assertEquals(0L, db.getWriteBuffer().evaluateSize()); - assertFalse(db.getWriteBuffer().getCacheEntry(wrap("ONE")).isPresent()); - assertFalse(db.getWriteBuffer().getCacheEntry(wrap("TWO")).isPresent()); - assertFalse(db.getWriteBuffer().getCacheEntry(wrap("THREE")).isPresent()); - assertFalse(db.getWriteBuffer().getCacheEntry(wrap("FOUR")).isPresent()); + assertThat(4).isEqualTo(engineSource.source.size()); + assertThat(0L).isEqualTo(db.getWriteBuffer().evaluateSize()); + assertThat(db.getWriteBuffer().getCacheEntry(wrap("ONE"))).isNotPresent(); + assertThat(db.getWriteBuffer().getCacheEntry(wrap("TWO"))).isNotPresent(); + assertThat(db.getWriteBuffer().getCacheEntry(wrap("THREE"))).isNotPresent(); + assertThat(db.getWriteBuffer().getCacheEntry(wrap("FOUR"))).isNotPresent(); storage.put(wrap("FIVE"), Bytes32.random(rnd)); storage.put(wrap("SIX"), Bytes32.random(rnd)); - assertEquals( - 4 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd)), + assertThat( + 4 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))).isEqualTo( db.getWriteBuffer().evaluateSize()); storage.remove(wrap("FIVE")); - assertEquals( - 2 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd)), + assertThat( + 2 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))).isEqualTo( db.getWriteBuffer().evaluateSize()); } @Test - @Ignore - public void checkWithConcurrentAccessTake1() throws InterruptedException { + @Disabled + void checkWithConcurrentAccessTake1() throws InterruptedException { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource); @@ -204,12 +193,12 @@ public void checkWithConcurrentAccessTake1() throws InterruptedException { Set expectedValues = new HashSet<>(writtenToOne.values()); expectedValues.addAll(writtenToTwo.values()); - assertEquals(expectedValues, sourceValues); + assertThat(expectedValues).isEqualTo(sourceValues); } @Test - @Ignore - public void checkWithConcurrentAccessTake2() throws InterruptedException { + @Disabled + void checkWithConcurrentAccessTake2() throws InterruptedException { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java index 6cdccc574..bf6577f56 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java @@ -1,26 +1,24 @@ package org.ethereum.beacon.db; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; - -import java.io.IOException; import org.ethereum.beacon.db.source.DataSource; import org.ethereum.beacon.db.util.FileUtil; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.*; import tech.pegasys.artemis.util.bytes.BytesValue; -public class RocksDbDrivenDatabaseTest { +import java.io.IOException; + +import static org.assertj.core.api.Assertions.assertThat; + +class RocksDbDrivenDatabaseTest { - @After - @Before - public void cleanUp() throws IOException { + @AfterEach + @BeforeEach + void cleanUp() throws IOException { FileUtil.removeRecursively("test-db"); } @Test - public void basicOperations() { + void basicOperations() { Database db = Database.rocksDB("test-db", -1); DataSource uno = db.createStorage("uno"); @@ -33,42 +31,42 @@ public void basicOperations() { dos.put(wrap("FOUR"), wrap("DOS_FOURTH")); db.commit(); - assertEquals(wrap("FIRST"), uno.get(wrap("ONE")).get()); - assertEquals(wrap("SECOND"), uno.get(wrap("TWO")).get()); - assertEquals(wrap("SECOND"), dos.get(wrap("TWO")).get()); - assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get()); - assertEquals(wrap("DOS_FOURTH"), dos.get(wrap("FOUR")).get()); - assertFalse(uno.get(wrap("FOUR")).isPresent()); - assertFalse(dos.get(wrap("ONE")).isPresent()); - assertFalse(dos.get(wrap("THREE")).isPresent()); - assertFalse(uno.get(wrap("FOUR")).isPresent()); + assertThat(wrap("FIRST")).isEqualTo(uno.get(wrap("ONE")).get()); + assertThat(wrap("SECOND")).isEqualTo(uno.get(wrap("TWO")).get()); + assertThat(wrap("SECOND")).isEqualTo(dos.get(wrap("TWO")).get()); + assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get()); + assertThat(wrap("DOS_FOURTH")).isEqualTo(dos.get(wrap("FOUR")).get()); + assertThat(uno.get(wrap("FOUR"))).isNotPresent(); + assertThat(dos.get(wrap("ONE"))).isNotPresent(); + assertThat(dos.get(wrap("THREE"))).isNotPresent(); + assertThat(uno.get(wrap("FOUR"))).isNotPresent(); uno.remove(wrap("TWO")); dos.put(wrap("THREE"), wrap("DOS_THIRD")); - assertFalse(uno.get(wrap("TWO")).isPresent()); - assertEquals(wrap("DOS_THIRD"), dos.get(wrap("THREE")).get()); - assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get()); + assertThat(uno.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("DOS_THIRD")).isEqualTo(dos.get(wrap("THREE")).get()); + assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get()); db.commit(); - assertFalse(uno.get(wrap("TWO")).isPresent()); - assertEquals(wrap("DOS_THIRD"), dos.get(wrap("THREE")).get()); - assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get()); + assertThat(uno.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("DOS_THIRD")).isEqualTo(dos.get(wrap("THREE")).get()); + assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get()); dos.remove(wrap("FOUR")); uno.put(wrap("FOUR"), wrap("UNO_FOURTH")); - assertEquals(wrap("UNO_FOURTH"), uno.get(wrap("FOUR")).get()); - assertFalse(dos.get(wrap("FOUR")).isPresent()); + assertThat(wrap("UNO_FOURTH")).isEqualTo(uno.get(wrap("FOUR")).get()); + assertThat(dos.get(wrap("FOUR"))).isNotPresent(); db.commit(); - assertEquals(wrap("UNO_FOURTH"), uno.get(wrap("FOUR")).get()); - assertFalse(dos.get(wrap("FOUR")).isPresent()); + assertThat(wrap("UNO_FOURTH")).isEqualTo(uno.get(wrap("FOUR")).get()); + assertThat(dos.get(wrap("FOUR"))).isNotPresent(); db.close(); } @Test - public void reopenWithoutFlush() { + void reopenWithoutFlush() { Database db = Database.rocksDB("test-db", -1); DataSource storage = db.createStorage("uno"); @@ -81,9 +79,9 @@ public void reopenWithoutFlush() { storage = db.createStorage("uno"); - assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get()); - assertEquals(wrap("SECOND"), storage.get(wrap("TWO")).get()); - assertEquals(wrap("THIRD"), storage.get(wrap("THREE")).get()); + assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get()); + assertThat(wrap("SECOND")).isEqualTo(storage.get(wrap("TWO")).get()); + assertThat(wrap("THIRD")).isEqualTo(storage.get(wrap("THREE")).get()); db.close(); } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java index ce9a837f5..1bdbafe6c 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java @@ -1,35 +1,32 @@ package org.ethereum.beacon.db.rocksdb; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; +import org.ethereum.beacon.db.util.FileUtil; +import org.junit.jupiter.api.*; +import tech.pegasys.artemis.util.bytes.BytesValue; import java.io.IOException; import java.nio.file.Paths; -import java.util.HashMap; -import java.util.Map; -import org.ethereum.beacon.db.util.FileUtil; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import tech.pegasys.artemis.util.bytes.BytesValue; +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; -public class RocksDbSourceTest { +class RocksDbSourceTest { - @After - @Before - public void cleanUp() throws IOException { + @AfterEach + @BeforeEach + void cleanUp() throws IOException { FileUtil.removeRecursively("test-db"); } @Test - public void basicOperations() { + void basicOperations() { RocksDbSource rocksDb = new RocksDbSource(Paths.get("test-db")); rocksDb.open(); rocksDb.put(wrap("ONE"), wrap("FIRST")); - assertFalse(rocksDb.get(wrap("TWO")).isPresent()); - assertEquals(wrap("FIRST"), rocksDb.get(wrap("ONE")).get()); + assertThat(rocksDb.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("FIRST")).isEqualTo(rocksDb.get(wrap("ONE")).get()); Map batch = new HashMap<>(); batch.put(wrap("ONE"), null); @@ -39,22 +36,22 @@ public void basicOperations() { rocksDb.batchUpdate(batch); - assertFalse(rocksDb.get(wrap("ONE")).isPresent()); - assertEquals(wrap("SECOND"), rocksDb.get(wrap("TWO")).get()); - assertEquals(wrap("THIRD"), rocksDb.get(wrap("THREE")).get()); - assertEquals(wrap("FOURTH"), rocksDb.get(wrap("FOUR")).get()); + assertThat(rocksDb.get(wrap("ONE"))).isNotPresent(); + assertThat(wrap("SECOND")).isEqualTo(rocksDb.get(wrap("TWO")).get()); + assertThat(wrap("THIRD")).isEqualTo(rocksDb.get(wrap("THREE")).get()); + assertThat(wrap("FOURTH")).isEqualTo(rocksDb.get(wrap("FOUR")).get()); rocksDb.remove(wrap("THREE")); - assertFalse(rocksDb.get(wrap("THREE")).isPresent()); + assertThat(rocksDb.get(wrap("THREE"))).isNotPresent(); rocksDb.close(); rocksDb.open(); - assertFalse(rocksDb.get(wrap("ONE")).isPresent()); - assertEquals(wrap("SECOND"), rocksDb.get(wrap("TWO")).get()); - assertFalse(rocksDb.get(wrap("THREE")).isPresent()); - assertEquals(wrap("FOURTH"), rocksDb.get(wrap("FOUR")).get()); - assertFalse(rocksDb.get(wrap("FIVE")).isPresent()); + assertThat(rocksDb.get(wrap("ONE"))).isNotPresent(); + assertThat(wrap("SECOND")).isEqualTo(rocksDb.get(wrap("TWO")).get()); + assertThat(rocksDb.get(wrap("THREE"))).isNotPresent(); + assertThat(wrap("FOURTH")).isEqualTo(rocksDb.get(wrap("FOUR")).get()); + assertThat(rocksDb.get(wrap("FIVE"))).isNotPresent(); rocksDb.close(); } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java index 3a203e477..d5632d9bd 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java @@ -1,16 +1,17 @@ package org.ethereum.beacon.db.source.impl; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; import tech.pegasys.artemis.util.bytes.BytesValue; -public class MemSizeEvaluatorTest { +import static org.assertj.core.api.Assertions.assertThat; + +class MemSizeEvaluatorTest { @Test - public void bytesValueEvaluator() { + void bytesValueEvaluator() { long evaluatedSize = MemSizeEvaluators.BytesValueEvaluator.apply(BytesValue.wrap(new byte[1000])); System.out.println("Evaluated size: " + evaluatedSize); - Assert.assertTrue(evaluatedSize > 1000); + assertThat(evaluatedSize).isGreaterThan(1000); } } From 173a95ca3570f1b6f468b04b233c9a82cd3f244e Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Tue, 17 Sep 2019 19:15:34 +0300 Subject: [PATCH 30/44] test: db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest --- .../org/ethereum/beacon/db/DatabaseTest.java | 102 ++++++++++++++++++ 1 file changed, 102 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java diff --git a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java new file mode 100644 index 000000000..8b918e352 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -0,0 +1,102 @@ +package org.ethereum.beacon.db; + +import org.ethereum.beacon.db.source.DataSource; +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import tech.pegasys.artemis.util.bytes.BytesValue; + +import java.nio.file.InvalidPathException; +import java.util.stream.Stream; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class DatabaseTest { + + @Tag("FIX") + @ParameterizedTest + @MethodSource("invalidArgumentsProvider") + void testInvalidCreation(String path, long bufferLimitsInBytes) { + assertThatThrownBy(() -> Database.rocksDB(path, bufferLimitsInBytes)).isInstanceOf(InvalidPathException.class); + } + + @Test + void testInvalidCreationWithNull() { + assertThatThrownBy(() -> Database.rocksDB(null, 0)).isInstanceOf(NullPointerException.class); + } + + private static Stream invalidArgumentsProvider() { + return Stream.of( + Arguments.of("null", 0), + Arguments.of("", 0), + Arguments.of("0123", 0) + ); + } + + @ParameterizedTest + @MethodSource("validArgumentsProvider") + void testValidCreation(String path, long bufferLimitsInBytes) { + final Database database = Database.rocksDB(path, bufferLimitsInBytes); + assertThat(database).isNotNull(); + } + + private static Stream validArgumentsProvider() { + return Stream.of( + Arguments.of("/tmp", 0), + Arguments.of("/tmp", Long.MAX_VALUE), + Arguments.of("/tmp", Long.MIN_VALUE) + ); + } + + + private static final String TEST_STORAGE_NAME = "TEST_STORAGE_NAME"; + + private boolean committed; + private boolean closed; + private String storageName; + + @Test + void testDatabaseCommitCloseCreateStorage() { + final DataSource dataSource = new HashMapDataSource<>(); + committed = false; + closed = false; + storageName = null; + + final Database db = new Database() { + @Override + public DataSource createStorage(String name) { + storageName = name; + return dataSource; + } + + @Override + public void commit() { + committed = true; + } + + @Override + public void close() { + closed = true; + } + }; + + final DataSource storage = db.createStorage(TEST_STORAGE_NAME); + assertThat(storage).isNotNull(); + assertThat(storage).isEqualTo(dataSource); + assertThat(storageName).isEqualTo(TEST_STORAGE_NAME); + + assertFalse(committed); + db.commit(); + assertTrue(committed); + + assertFalse(closed); + db.close(); + assertTrue(closed); + } +} From 01478a7e29510b49ff15b11e67c4e3f30f6d1108 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Tue, 17 Sep 2019 19:50:26 +0300 Subject: [PATCH 31/44] test: db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest --- .../java/org/ethereum/beacon/db/DatabaseTest.java | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java index 8b918e352..99cc76c78 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -14,8 +14,6 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; class DatabaseTest { @@ -87,16 +85,15 @@ public void close() { }; final DataSource storage = db.createStorage(TEST_STORAGE_NAME); - assertThat(storage).isNotNull(); assertThat(storage).isEqualTo(dataSource); assertThat(storageName).isEqualTo(TEST_STORAGE_NAME); - assertFalse(committed); + assertThat(committed).isFalse(); db.commit(); - assertTrue(committed); + assertThat(committed).isTrue(); - assertFalse(closed); + assertThat(closed).isFalse(); db.close(); - assertTrue(closed); + assertThat(closed).isTrue(); } } From 0f07f8db215c9c4d633ae5e8d306983e6738a3cb Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 14:10:16 +0300 Subject: [PATCH 32/44] test: add junit4 dependency into test module --- test/build.gradle | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/build.gradle b/test/build.gradle index 6a5d5561b..ddd5433c6 100644 --- a/test/build.gradle +++ b/test/build.gradle @@ -14,6 +14,7 @@ dependencies { testImplementation project(':start:simulator') testImplementation project(':util') testImplementation project(':pow:core') + testImplementation 'junit:junit' } task activateLfs(type:Exec) { @@ -35,4 +36,4 @@ task submodulesUpdate(type:Exec) { group 'Build Setup' } -test.dependsOn(submodulesUpdate) \ No newline at end of file +test.dependsOn(submodulesUpdate) From 2b935f66c078675b75eb110e258ac389b2d4a70d Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 14:37:45 +0300 Subject: [PATCH 33/44] test: fix junit 4/5 dependencies --- db/core/build.gradle | 8 +++----- test/build.gradle | 5 +++-- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/db/core/build.gradle b/db/core/build.gradle index 4e763afb7..6ee6126af 100644 --- a/db/core/build.gradle +++ b/db/core/build.gradle @@ -3,7 +3,9 @@ dependencies { exclude group: 'junit' } - api project(':crypto') + api(project(':crypto')) { + exclude group: 'junit' + } api "org.rocksdb:rocksdbjni" api "com.googlecode.concurrent-locks:concurrent-locks" @@ -16,7 +18,3 @@ dependencies { } } } - -configurations { - testImplementation.exclude group: 'junit', module: 'junit' -} diff --git a/test/build.gradle b/test/build.gradle index ddd5433c6..761796a80 100644 --- a/test/build.gradle +++ b/test/build.gradle @@ -9,12 +9,13 @@ dependencies { testImplementation project(':consensus') testImplementation project(':core') testImplementation project(':start:config') - testImplementation project(':db:core') + testImplementation(project(':db:core')) { + exclude group: 'org.junit.jupiter' + } testImplementation project(':chain') testImplementation project(':start:simulator') testImplementation project(':util') testImplementation project(':pow:core') - testImplementation 'junit:junit' } task activateLfs(type:Exec) { From 042ee95644a816565d53c21704bebc4cff0f54d0 Mon Sep 17 00:00:00 2001 From: Dmitrii Shmatko Date: Wed, 18 Sep 2019 15:50:48 +0300 Subject: [PATCH 34/44] Community tests updated to be in line with develop --- test/src/test/resources/eth2.0-spec-tests | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/test/resources/eth2.0-spec-tests b/test/src/test/resources/eth2.0-spec-tests index aaa1673f5..ae6dd9011 160000 --- a/test/src/test/resources/eth2.0-spec-tests +++ b/test/src/test/resources/eth2.0-spec-tests @@ -1 +1 @@ -Subproject commit aaa1673f508103e11304833e0456e4149f880065 +Subproject commit ae6dd9011df05fab8c7e651c09cf9c940973bf81 From aac0059ccaf00b4f115113a26f3c3cbb08c2ad15 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 15:56:21 +0300 Subject: [PATCH 35/44] test: reformat code --- .../org/ethereum/beacon/db/DatabaseTest.java | 134 +++++++++--------- .../beacon/db/EngineDrivenDatabaseTest.java | 32 +++-- .../beacon/db/RocksDbDrivenDatabaseTest.java | 4 +- .../beacon/db/rocksdb/RocksDbSourceTest.java | 7 +- test/src/test/resources/eth2.0-spec-tests | 2 +- 5 files changed, 95 insertions(+), 84 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java index 99cc76c78..f138da453 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -17,83 +17,79 @@ class DatabaseTest { - @Tag("FIX") - @ParameterizedTest - @MethodSource("invalidArgumentsProvider") - void testInvalidCreation(String path, long bufferLimitsInBytes) { - assertThatThrownBy(() -> Database.rocksDB(path, bufferLimitsInBytes)).isInstanceOf(InvalidPathException.class); - } - - @Test - void testInvalidCreationWithNull() { - assertThatThrownBy(() -> Database.rocksDB(null, 0)).isInstanceOf(NullPointerException.class); - } - - private static Stream invalidArgumentsProvider() { - return Stream.of( - Arguments.of("null", 0), - Arguments.of("", 0), - Arguments.of("0123", 0) - ); - } - - @ParameterizedTest - @MethodSource("validArgumentsProvider") - void testValidCreation(String path, long bufferLimitsInBytes) { - final Database database = Database.rocksDB(path, bufferLimitsInBytes); - assertThat(database).isNotNull(); - } - - private static Stream validArgumentsProvider() { - return Stream.of( - Arguments.of("/tmp", 0), - Arguments.of("/tmp", Long.MAX_VALUE), - Arguments.of("/tmp", Long.MIN_VALUE) - ); - } - - - private static final String TEST_STORAGE_NAME = "TEST_STORAGE_NAME"; - - private boolean committed; - private boolean closed; - private String storageName; - - @Test - void testDatabaseCommitCloseCreateStorage() { - final DataSource dataSource = new HashMapDataSource<>(); - committed = false; - closed = false; - storageName = null; - - final Database db = new Database() { - @Override - public DataSource createStorage(String name) { + @Tag("FIX") + @ParameterizedTest + @MethodSource("invalidArgumentsProvider") + void testInvalidCreation(String path, long bufferLimitsInBytes) { + assertThatThrownBy(() -> Database.rocksDB(path, bufferLimitsInBytes)) + .isInstanceOf(InvalidPathException.class); + } + + @Test + void testInvalidCreationWithNull() { + assertThatThrownBy(() -> Database.rocksDB(null, 0)).isInstanceOf(NullPointerException.class); + } + + private static Stream invalidArgumentsProvider() { + return Stream.of(Arguments.of("null", 0), Arguments.of("", 0), Arguments.of("0123", 0)); + } + + @ParameterizedTest + @MethodSource("validArgumentsProvider") + void testValidCreation(String path, long bufferLimitsInBytes) { + final Database database = Database.rocksDB(path, bufferLimitsInBytes); + assertThat(database).isNotNull(); + } + + private static Stream validArgumentsProvider() { + return Stream.of( + Arguments.of("/tmp", 0), + Arguments.of("/tmp", Long.MAX_VALUE), + Arguments.of("/tmp", Long.MIN_VALUE)); + } + + private static final String TEST_STORAGE_NAME = "TEST_STORAGE_NAME"; + + private boolean committed; + private boolean closed; + private String storageName; + + @Test + void testDatabaseCommitCloseCreateStorage() { + final DataSource dataSource = new HashMapDataSource<>(); + committed = false; + closed = false; + storageName = null; + + final Database db = + new Database() { + @Override + public DataSource createStorage(String name) { storageName = name; return dataSource; - } + } - @Override - public void commit() { + @Override + public void commit() { committed = true; - } + } - @Override - public void close() { + @Override + public void close() { closed = true; - } + } }; - final DataSource storage = db.createStorage(TEST_STORAGE_NAME); - assertThat(storage).isEqualTo(dataSource); - assertThat(storageName).isEqualTo(TEST_STORAGE_NAME); + final DataSource storage = db.createStorage(TEST_STORAGE_NAME); + assertThat(storage).isEqualTo(dataSource); + assertThat(storageName).isEqualTo(TEST_STORAGE_NAME); - assertThat(committed).isFalse(); - db.commit(); - assertThat(committed).isTrue(); + assertThat(committed).isFalse(); + db.commit(); + assertThat(committed).isTrue(); - assertThat(closed).isFalse(); - db.close(); - assertThat(closed).isTrue(); - } + assertThat(closed).isFalse(); + db.close(); + assertThat(closed).isTrue(); + } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java index fc708f596..e9273951a 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java @@ -1,16 +1,28 @@ package org.ethereum.beacon.db; -import org.ethereum.beacon.db.source.*; +import org.ethereum.beacon.db.source.DataSource; +import org.ethereum.beacon.db.source.StorageEngineSource; import org.ethereum.beacon.db.source.impl.MemSizeEvaluators; -import org.junit.jupiter.api.*; -import tech.pegasys.artemis.util.bytes.*; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import tech.pegasys.artemis.util.bytes.Bytes32; +import tech.pegasys.artemis.util.bytes.BytesValue; import tech.pegasys.artemis.util.uint.UInt64; import javax.annotation.Nonnull; -import java.util.*; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Random; +import java.util.Set; import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; class EngineDrivenDatabaseTest { @@ -140,15 +152,13 @@ void checkBufferSizeFlusher() { storage.put(wrap("FIVE"), Bytes32.random(rnd)); storage.put(wrap("SIX"), Bytes32.random(rnd)); - assertThat( - 4 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))).isEqualTo( - db.getWriteBuffer().evaluateSize()); + assertThat(4 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))) + .isEqualTo(db.getWriteBuffer().evaluateSize()); storage.remove(wrap("FIVE")); - assertThat( - 2 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))).isEqualTo( - db.getWriteBuffer().evaluateSize()); + assertThat(2 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))) + .isEqualTo(db.getWriteBuffer().evaluateSize()); } @Test diff --git a/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java index bf6577f56..cb4c196f4 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java @@ -2,7 +2,9 @@ import org.ethereum.beacon.db.source.DataSource; import org.ethereum.beacon.db.util.FileUtil; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import tech.pegasys.artemis.util.bytes.BytesValue; import java.io.IOException; diff --git a/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java index 1bdbafe6c..2d662dc98 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java @@ -1,12 +1,15 @@ package org.ethereum.beacon.db.rocksdb; import org.ethereum.beacon.db.util.FileUtil; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import tech.pegasys.artemis.util.bytes.BytesValue; import java.io.IOException; import java.nio.file.Paths; -import java.util.*; +import java.util.HashMap; +import java.util.Map; import static org.assertj.core.api.Assertions.assertThat; diff --git a/test/src/test/resources/eth2.0-spec-tests b/test/src/test/resources/eth2.0-spec-tests index ae6dd9011..aaa1673f5 160000 --- a/test/src/test/resources/eth2.0-spec-tests +++ b/test/src/test/resources/eth2.0-spec-tests @@ -1 +1 @@ -Subproject commit ae6dd9011df05fab8c7e651c09cf9c940973bf81 +Subproject commit aaa1673f508103e11304833e0456e4149f880065 From 01e17cb8cb963b4f009793e7a2b9d0a84c1d9421 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 16:41:56 +0300 Subject: [PATCH 36/44] test: update subproject --- test/src/test/resources/eth2.0-spec-tests | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/test/resources/eth2.0-spec-tests b/test/src/test/resources/eth2.0-spec-tests index aaa1673f5..ae6dd9011 160000 --- a/test/src/test/resources/eth2.0-spec-tests +++ b/test/src/test/resources/eth2.0-spec-tests @@ -1 +1 @@ -Subproject commit aaa1673f508103e11304833e0456e4149f880065 +Subproject commit ae6dd9011df05fab8c7e651c09cf9c940973bf81 From 4fdb06d52171510294be9332259e0e52742ad5f2 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 20:47:37 +0300 Subject: [PATCH 37/44] test: fix DatabaseTest after code review --- .../org/ethereum/beacon/db/DatabaseTest.java | 78 +++++-------------- 1 file changed, 19 insertions(+), 59 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java index f138da453..d052febc4 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -1,15 +1,13 @@ package org.ethereum.beacon.db; -import org.ethereum.beacon.db.source.DataSource; -import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.jupiter.api.Tag; +import org.ethereum.beacon.db.rocksdb.RocksDbSource; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; +import org.rocksdb.RocksDBException; import tech.pegasys.artemis.util.bytes.BytesValue; -import java.nio.file.InvalidPathException; import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; @@ -17,12 +15,18 @@ class DatabaseTest { - @Tag("FIX") @ParameterizedTest @MethodSource("invalidArgumentsProvider") - void testInvalidCreation(String path, long bufferLimitsInBytes) { - assertThatThrownBy(() -> Database.rocksDB(path, bufferLimitsInBytes)) - .isInstanceOf(InvalidPathException.class); + void testInvalidCreation() { + final EngineDrivenDatabase database = (EngineDrivenDatabase) Database.rocksDB("", 0); + final RocksDbSource upstream = (RocksDbSource) database.getWriteBuffer().getUpstream(); + assertThatThrownBy(upstream::open) + .isInstanceOf(RuntimeException.class) + .hasCauseExactlyInstanceOf(RocksDBException.class); + } + + private static Stream invalidArgumentsProvider() { + return Stream.of(Arguments.of("", 0), Arguments.of("0123", 0)); } @Test @@ -30,66 +34,22 @@ void testInvalidCreationWithNull() { assertThatThrownBy(() -> Database.rocksDB(null, 0)).isInstanceOf(NullPointerException.class); } - private static Stream invalidArgumentsProvider() { - return Stream.of(Arguments.of("null", 0), Arguments.of("", 0), Arguments.of("0123", 0)); - } - @ParameterizedTest @MethodSource("validArgumentsProvider") void testValidCreation(String path, long bufferLimitsInBytes) { - final Database database = Database.rocksDB(path, bufferLimitsInBytes); - assertThat(database).isNotNull(); + final EngineDrivenDatabase database = (EngineDrivenDatabase) Database.rocksDB(path, bufferLimitsInBytes); + final RocksDbSource upstream = (RocksDbSource) database.getWriteBuffer().getUpstream(); + upstream.open(); + upstream.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); + assertThat(database.getWriteBuffer().get(BytesValue.of(123))).isPresent().hasValue(BytesValue.of(1, 2, 3)); + upstream.close(); } private static Stream validArgumentsProvider() { return Stream.of( + Arguments.of("", 0), Arguments.of("/tmp", 0), Arguments.of("/tmp", Long.MAX_VALUE), Arguments.of("/tmp", Long.MIN_VALUE)); } - - private static final String TEST_STORAGE_NAME = "TEST_STORAGE_NAME"; - - private boolean committed; - private boolean closed; - private String storageName; - - @Test - void testDatabaseCommitCloseCreateStorage() { - final DataSource dataSource = new HashMapDataSource<>(); - committed = false; - closed = false; - storageName = null; - - final Database db = - new Database() { - @Override - public DataSource createStorage(String name) { - storageName = name; - return dataSource; - } - - @Override - public void commit() { - committed = true; - } - - @Override - public void close() { - closed = true; - } - }; - - final DataSource storage = db.createStorage(TEST_STORAGE_NAME); - assertThat(storage).isEqualTo(dataSource); - assertThat(storageName).isEqualTo(TEST_STORAGE_NAME); - - assertThat(committed).isFalse(); - db.commit(); - assertThat(committed).isTrue(); - - assertThat(closed).isFalse(); - db.close(); - assertThat(closed).isTrue(); - } } From 23994a6dcf92898fa1eaca49deb099c17289d9c9 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 21:59:47 +0300 Subject: [PATCH 38/44] test: fix DatabaseTest after code review --- .../org/ethereum/beacon/db/DatabaseTest.java | 39 ++++++++----------- 1 file changed, 17 insertions(+), 22 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java index d052febc4..3663f4eb0 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -1,6 +1,6 @@ package org.ethereum.beacon.db; -import org.ethereum.beacon.db.rocksdb.RocksDbSource; +import org.ethereum.beacon.db.source.DataSource; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; @@ -8,27 +8,23 @@ import org.rocksdb.RocksDBException; import tech.pegasys.artemis.util.bytes.BytesValue; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Paths; import java.util.stream.Stream; -import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; class DatabaseTest { - @ParameterizedTest - @MethodSource("invalidArgumentsProvider") + @Test void testInvalidCreation() { - final EngineDrivenDatabase database = (EngineDrivenDatabase) Database.rocksDB("", 0); - final RocksDbSource upstream = (RocksDbSource) database.getWriteBuffer().getUpstream(); - assertThatThrownBy(upstream::open) + final Database database = Database.rocksDB("", 0); + assertThatThrownBy(() -> database.createStorage("test-db")) .isInstanceOf(RuntimeException.class) .hasCauseExactlyInstanceOf(RocksDBException.class); } - private static Stream invalidArgumentsProvider() { - return Stream.of(Arguments.of("", 0), Arguments.of("0123", 0)); - } - @Test void testInvalidCreationWithNull() { assertThatThrownBy(() -> Database.rocksDB(null, 0)).isInstanceOf(NullPointerException.class); @@ -36,20 +32,19 @@ void testInvalidCreationWithNull() { @ParameterizedTest @MethodSource("validArgumentsProvider") - void testValidCreation(String path, long bufferLimitsInBytes) { - final EngineDrivenDatabase database = (EngineDrivenDatabase) Database.rocksDB(path, bufferLimitsInBytes); - final RocksDbSource upstream = (RocksDbSource) database.getWriteBuffer().getUpstream(); - upstream.open(); - upstream.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); - assertThat(database.getWriteBuffer().get(BytesValue.of(123))).isPresent().hasValue(BytesValue.of(1, 2, 3)); - upstream.close(); + void testValidCreation(String path, long bufferLimitsInBytes) throws IOException { + final Database database = Database.rocksDB(path, bufferLimitsInBytes); + final DataSource storage = database.createStorage("test-db"); + storage.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); + database.commit(); + + Files.deleteIfExists(Paths.get(path)); } private static Stream validArgumentsProvider() { return Stream.of( - Arguments.of("", 0), - Arguments.of("/tmp", 0), - Arguments.of("/tmp", Long.MAX_VALUE), - Arguments.of("/tmp", Long.MIN_VALUE)); + Arguments.of("/tmp/rocksdb", 0), + Arguments.of("/tmp/rocksdb", 1), + Arguments.of("/tmp/rocksdb", -1)); } } From 29245fb2e1b20ac5ef1abb4c18eaec0630ca62e0 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 22:22:17 +0300 Subject: [PATCH 39/44] test: delete directories --- .../org/ethereum/beacon/db/DatabaseTest.java | 32 ++++++++++++++----- 1 file changed, 24 insertions(+), 8 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java index 3663f4eb0..801cecd07 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -1,18 +1,21 @@ package org.ethereum.beacon.db; -import org.ethereum.beacon.db.source.DataSource; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import org.rocksdb.RocksDBException; -import tech.pegasys.artemis.util.bytes.BytesValue; import java.io.IOException; +import java.nio.file.FileVisitResult; import java.nio.file.Files; +import java.nio.file.Path; import java.nio.file.Paths; +import java.nio.file.SimpleFileVisitor; +import java.nio.file.attribute.BasicFileAttributes; import java.util.stream.Stream; +import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; class DatabaseTest { @@ -34,17 +37,30 @@ void testInvalidCreationWithNull() { @MethodSource("validArgumentsProvider") void testValidCreation(String path, long bufferLimitsInBytes) throws IOException { final Database database = Database.rocksDB(path, bufferLimitsInBytes); - final DataSource storage = database.createStorage("test-db"); - storage.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); - database.commit(); + database.createStorage("test-db"); + final Path directory = Paths.get(path); + assertThat(Files.exists(directory)).isTrue(); - Files.deleteIfExists(Paths.get(path)); + Files.walkFileTree(directory, new SimpleFileVisitor() { + + @Override + public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { + Files.delete(file); + return FileVisitResult.CONTINUE; + } + + @Override + public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { + Files.delete(dir); + return FileVisitResult.CONTINUE; + } + }); } private static Stream validArgumentsProvider() { return Stream.of( Arguments.of("/tmp/rocksdb", 0), - Arguments.of("/tmp/rocksdb", 1), - Arguments.of("/tmp/rocksdb", -1)); + Arguments.of("/tmp/rocksdb1", Long.MAX_VALUE), + Arguments.of("/tmp/rocksdb2", Long.MIN_VALUE)); } } From 355bc81db92bca4d6d3902d5b813e3c529fb894e Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 22:28:00 +0300 Subject: [PATCH 40/44] test: add relative directories --- .../org/ethereum/beacon/db/DatabaseTest.java | 25 ++++--------------- 1 file changed, 5 insertions(+), 20 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java index 801cecd07..99265d6a2 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -1,5 +1,6 @@ package org.ethereum.beacon.db; +import org.ethereum.beacon.db.util.FileUtil; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; @@ -7,12 +8,9 @@ import org.rocksdb.RocksDBException; import java.io.IOException; -import java.nio.file.FileVisitResult; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.nio.file.SimpleFileVisitor; -import java.nio.file.attribute.BasicFileAttributes; import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; @@ -41,26 +39,13 @@ void testValidCreation(String path, long bufferLimitsInBytes) throws IOException final Path directory = Paths.get(path); assertThat(Files.exists(directory)).isTrue(); - Files.walkFileTree(directory, new SimpleFileVisitor() { - - @Override - public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { - Files.delete(file); - return FileVisitResult.CONTINUE; - } - - @Override - public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { - Files.delete(dir); - return FileVisitResult.CONTINUE; - } - }); + FileUtil.removeRecursively("rocksdb"); } private static Stream validArgumentsProvider() { return Stream.of( - Arguments.of("/tmp/rocksdb", 0), - Arguments.of("/tmp/rocksdb1", Long.MAX_VALUE), - Arguments.of("/tmp/rocksdb2", Long.MIN_VALUE)); + Arguments.of("rocksdb", 0), + Arguments.of("rocksdb2", Long.MAX_VALUE), + Arguments.of("rocksdb3", Long.MIN_VALUE)); } } From b2a818656b193c82d18958189e9079d802a25f32 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Thu, 19 Sep 2019 09:28:22 +0300 Subject: [PATCH 41/44] test: add additional test for Database --- .../org/ethereum/beacon/db/DatabaseTest.java | 45 ++++++++++++++++++- 1 file changed, 44 insertions(+), 1 deletion(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java index 99265d6a2..033629359 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -1,11 +1,13 @@ package org.ethereum.beacon.db; +import org.ethereum.beacon.db.source.DataSource; import org.ethereum.beacon.db.util.FileUtil; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import org.rocksdb.RocksDBException; +import tech.pegasys.artemis.util.bytes.BytesValue; import java.io.IOException; import java.nio.file.Files; @@ -35,10 +37,17 @@ void testInvalidCreationWithNull() { @MethodSource("validArgumentsProvider") void testValidCreation(String path, long bufferLimitsInBytes) throws IOException { final Database database = Database.rocksDB(path, bufferLimitsInBytes); - database.createStorage("test-db"); + final DataSource storage = database.createStorage("test-db"); final Path directory = Paths.get(path); assertThat(Files.exists(directory)).isTrue(); + //TODO: how to test without casting + storage.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); + database.commit(); + storage.remove(BytesValue.of(123)); + database.commit(); + database.close(); + FileUtil.removeRecursively("rocksdb"); } @@ -48,4 +57,38 @@ private static Stream validArgumentsProvider() { Arguments.of("rocksdb2", Long.MAX_VALUE), Arguments.of("rocksdb3", Long.MIN_VALUE)); } + + @Test + void testCreateDifferentStoresForSameDb() throws IOException { + final Database database = Database.rocksDB("rocksdb", Long.MAX_VALUE); + final DataSource s1 = database.createStorage("test-db"); + final DataSource s2 = database.createStorage("test-db2"); + assertThat(Files.exists(Paths.get("rocksdb"))).isTrue(); + + s1.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); + s2.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); + database.commit(); + database.close(); + s1.remove(BytesValue.of(123)); + s2.remove(BytesValue.of(123)); + assertThatThrownBy(database::commit).isInstanceOf(Exception.class); //TODO: should not commit after close + + FileUtil.removeRecursively("rocksdb"); + } + + @Test + void testCreateDuplicateStorage() throws IOException { + final Database database = Database.rocksDB("rocksdb", Long.MAX_VALUE); + final DataSource s1 = database.createStorage("test-db"); + final DataSource s2 = database.createStorage("test-db"); + assertThat(Files.exists(Paths.get("rocksdb"))).isTrue(); + + //TODO: how to test without casting + s1.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); + s2.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); + database.commit(); + database.close(); + + FileUtil.removeRecursively("rocksdb"); + } } From 2ebabd055eee178b6401b7e58481e75a7c464493 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Thu, 19 Sep 2019 10:15:48 +0300 Subject: [PATCH 42/44] test: correct InMemoryDatabaseTest --- .../org/ethereum/beacon/db/InMemoryDatabaseTest.java | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java index d4eefdebc..969ed4f4e 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java @@ -5,6 +5,8 @@ import org.junit.jupiter.params.provider.ValueSource; import tech.pegasys.artemis.util.bytes.BytesValue; +import java.util.Optional; + import static org.assertj.core.api.Assertions.assertThat; class InMemoryDatabaseTest { @@ -18,6 +20,14 @@ void testGetBackingDataSource(String param) { final BytesValue value = BytesValue.EMPTY; dataSource.put(key, value); - assertThat(dataSource.get(key)).isPresent().hasValue(value); + final Optional expected = dataSource.get(key); + assertThat(expected).isPresent().hasValue(value); + assertThat(database.getBackingDataSource().get(key)).isPresent().hasValue(expected.get()); + + dataSource.remove(key); + assertThat(dataSource.get(key)).isNotPresent(); + assertThat(database.getBackingDataSource().get(key)).isNotPresent(); } + + //TODO: commit and close methods do nothing, is it ok? } From 9ffb987c24ec2cf2d3f6e5920816ec8428cac15e Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Thu, 19 Sep 2019 10:24:46 +0300 Subject: [PATCH 43/44] test: correct InMemoryDatabaseTest --- .../beacon/db/InMemoryDatabaseTest.java | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java index 969ed4f4e..c217df6a5 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java @@ -1,6 +1,7 @@ package org.ethereum.beacon.db; import org.ethereum.beacon.db.source.DataSource; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; import tech.pegasys.artemis.util.bytes.BytesValue; @@ -29,5 +30,30 @@ void testGetBackingDataSource(String param) { assertThat(database.getBackingDataSource().get(key)).isNotPresent(); } + @Test + void testPutGetRemove_DifferentDatabase() { + final InMemoryDatabase first = new InMemoryDatabase(); + final InMemoryDatabase second = new InMemoryDatabase(); + + final BytesValue key = BytesValue.of(123); + final BytesValue value = BytesValue.of(1, 2, 3); + + final DataSource firstDS = first.getBackingDataSource(); + final DataSource secondDS = second.getBackingDataSource(); + + firstDS.put(key, value); + assertThat(first.getBackingDataSource().get(key)).isPresent().hasValue(value); + assertThat(secondDS.get(key)).isNotPresent(); + + firstDS.put(key, value); + secondDS.put(key, value); + assertThat(first.getBackingDataSource().get(key)).isPresent().hasValue(value); + assertThat(second.getBackingDataSource().get(key)).isPresent().hasValue(value); + + firstDS.remove(key); + assertThat(first.getBackingDataSource().get(key)).isNotPresent(); + assertThat(second.getBackingDataSource().get(key)).isPresent().hasValue(value); + } + //TODO: commit and close methods do nothing, is it ok? } From 93cbead83f54953116a046ab7d48dfac6986f373 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Thu, 19 Sep 2019 13:31:10 +0300 Subject: [PATCH 44/44] test: temp commit --- .../org/ethereum/beacon/db/DatabaseTest.java | 13 ++++--- .../beacon/db/XorKeyDatabaseTest.java | 36 +++++++++++++++++++ 2 files changed, 44 insertions(+), 5 deletions(-) diff --git a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java index 033629359..99262c1b5 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -41,11 +41,13 @@ void testValidCreation(String path, long bufferLimitsInBytes) throws IOException final Path directory = Paths.get(path); assertThat(Files.exists(directory)).isTrue(); - //TODO: how to test without casting - storage.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); - database.commit(); - storage.remove(BytesValue.of(123)); - database.commit(); + final BytesValue key = BytesValue.of(123); + final BytesValue value = BytesValue.of(1, 2, 3); + storage.put(key, value); + assertThat(storage.get(key)).isPresent().hasValue(value); + + storage.remove(key); + assertThat(storage.get(key)).isNotPresent(); database.close(); FileUtil.removeRecursively("rocksdb"); @@ -69,6 +71,7 @@ void testCreateDifferentStoresForSameDb() throws IOException { s2.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); database.commit(); database.close(); + s1.remove(BytesValue.of(123)); s2.remove(BytesValue.of(123)); assertThatThrownBy(database::commit).isInstanceOf(Exception.class); //TODO: should not commit after close diff --git a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java index 632d44387..431e519e5 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/XorKeyDatabaseTest.java @@ -5,6 +5,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import tech.pegasys.artemis.util.bytes.BytesValue; +import tech.pegasys.artemis.util.bytes.MutableBytesValue; import java.util.function.Function; @@ -26,6 +27,7 @@ public void commit() { public void close() { } }; + assertThat(db.getBackingDataSource()).isEqualTo(mapds); } @Test @@ -62,4 +64,38 @@ void testCreateStorage_1() { assertThat(storage1.get(key)).isPresent().hasValue(storage1_value); assertThat(storage0.get(key)).isPresent().hasValue(storage0_value); } + + @Test + void testSourceNameHasher() { + final HashMapDataSource mapds = new HashMapDataSource<>(); + db = new XorKeyDatabase(mapds, f -> BytesValue.wrap(f, BytesValue.of(99))) { + @Override + public void commit() { + } + + @Override + public void close() { + } + }; + assertThat(db.getBackingDataSource()).isEqualTo(mapds); + + final DataSource storage = db.createStorage("test-db"); + final BytesValue key = BytesValue.of(123); + final BytesValue value = BytesValue.of(1, 2, 3); + storage.put(key, value); + + assertThat(db.getBackingDataSource().get(key)).isNotPresent(); + } + + private BytesValue xorLongest(BytesValue v1, BytesValue v2) { + BytesValue longVal = v1.size() >= v2.size() ? v1 : v2; + BytesValue shortVal = v1.size() < v2.size() ? v1 : v2; + MutableBytesValue ret = longVal.mutableCopy(); + int longLen = longVal.size(); + int shortLen = shortVal.size(); + for (int i = 0; i < shortLen; i++) { + ret.set(longLen - i - 1, (byte) (ret.get(longLen - i - 1) ^ shortVal.get(shortLen - i - 1))); + } + return ret; + } }