Test iterators for both ProofMap variants [ECR-3871]: (#1280)

Move tests of iterators to the base test to ensure they work
for both ProofMap variants.

Author: dmitry-timofeev

exonum-java-binding/core/src/test/java/com/exonum/binding/core/storage/indices/BaseProofMapIndexProxyIntegrationTestable.java

@@ -33,6 +33,8 @@
 import static com.exonum.binding.test.Bytes.bytes;
 import static com.google.common.base.Preconditions.checkArgument;
 import static java.util.Collections.singletonList;
+import static java.util.Comparator.comparing;
+import static java.util.stream.Collectors.toList;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.notNullValue;
@@ -58,12 +60,12 @@
 import com.google.common.primitives.UnsignedBytes;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
@@ -366,6 +368,52 @@ void isEmptyShouldReturnFalseForNonEmptyMap() {
     });
   }
 
+  @Test
+  void keysTest() {
+    runTestWithView(database::createFork, (map) -> {
+      List<MapEntry<HashCode, String>> entries = createSortedMapEntries();
+
+      putAll(map, entries);
+
+      Iterator<HashCode> keysIterator = map.keys();
+      List<HashCode> keysFromIter = ImmutableList.copyOf(keysIterator);
+      List<HashCode> keysInMap = MapEntries.extractKeys(entries);
+
+      // Keys must appear in a lexicographical order.
+      assertThat(keysFromIter, equalTo(keysInMap));
+    });
+  }
+
+  @Test
+  void valuesTest() {
+    runTestWithView(database::createFork, (map) -> {
+      List<MapEntry<HashCode, String>> entries = createSortedMapEntries();
+
+      putAll(map, entries);
+
+      Iterator<String> valuesIterator = map.values();
+      List<String> valuesFromIter = ImmutableList.copyOf(valuesIterator);
+      List<String> valuesInMap = MapEntries.extractValues(entries);
+
+      // Values must appear in a lexicographical order of keys.
+      assertThat(valuesFromIter, equalTo(valuesInMap));
+    });
+  }
+
+  @Test
+  void entriesTest() {
+    runTestWithView(database::createFork, (map) -> {
+      List<MapEntry<HashCode, String>> entries = createSortedMapEntries();
+
+      putAll(map, entries);
+
+      Iterator<MapEntry<HashCode, String>> entriesIterator = map.entries();
+      List<MapEntry> entriesFromIter = ImmutableList.copyOf(entriesIterator);
+      // Entries must appear in a lexicographical order of keys.
+      assertThat(entriesFromIter, equalTo(entries));
+    });
+  }
+
   @Test
   @DisabledProofTest
   void getProofFromSingleKey() {
@@ -478,7 +526,17 @@ void update(ProofMapIndexProxy<HashCode, String> index) {
     index.put(key1, V1);
   }
 
-  List<MapEntry<HashCode, String>> createMapEntries() {
+  /**
+   * Creates `numOfEntries` map entries, sorted by key in lexicographical order:
+   * [(key0, V1), (key2, V2), … (key_i, Vi)].
+   */
+  private List<MapEntry<HashCode, String>> createSortedMapEntries() {
+    Stream<HashCode> sortedKeys = getTestKeys().stream()
+        .sorted(comparing(HashCode::asBytes, UnsignedBytes.lexicographicalComparator()));
+    return createMapEntries(sortedKeys);
+  }
+
+  private List<MapEntry<HashCode, String>> createMapEntries() {
     return createMapEntries(getTestKeys().stream());
   }
 
@@ -491,6 +549,6 @@ List<MapEntry<HashCode, String>> createMapEntries(Stream<HashCode> proofKeys) {
     Stream<String> roundRobinValues = IntStream.range(0, Integer.MAX_VALUE)
         .mapToObj(i -> values.get(i % values.size()));
     return Streams.zip(keys, roundRobinValues, MapEntry::valueOf)
-        .collect(Collectors.toList());
+        .collect(toList());
   }
 }

exonum-java-binding/core/src/test/java/com/exonum/binding/core/storage/indices/ProofMapIndexProxyGroupNoKeyHashingIntegrationTest.java

@@ -16,7 +16,7 @@
 
 package com.exonum.binding.core.storage.indices;
 
-import static com.exonum.binding.core.storage.indices.ProofMapIndexProxyNoKeyHashingIntegrationTest.SORTED_TEST_KEYS;
+import static com.exonum.binding.core.storage.indices.ProofMapIndexProxyNoKeyHashingIntegrationTest.TEST_KEYS;
 
 import com.exonum.binding.common.hash.HashCode;
 import com.exonum.binding.common.serialization.StandardSerializers;
@@ -26,9 +26,9 @@
 class ProofMapIndexProxyGroupNoKeyHashingIntegrationTest
     extends BaseMapIndexGroupTestable<HashCode> {
 
-  private static final HashCode PK1 = SORTED_TEST_KEYS.get(0);
-  private static final HashCode PK2 = SORTED_TEST_KEYS.get(1);
-  private static final HashCode PK3 = SORTED_TEST_KEYS.get(2);
+  private static final HashCode PK1 = TEST_KEYS.get(0);
+  private static final HashCode PK2 = TEST_KEYS.get(1);
+  private static final HashCode PK3 = TEST_KEYS.get(2);
 
   private static final String GROUP_NAME = "proof_map_group_IT";
 

exonum-java-binding/core/src/test/java/com/exonum/binding/core/storage/indices/ProofMapIndexProxyIntegrationTest.java

@@ -16,7 +16,7 @@
 
 package com.exonum.binding.core.storage.indices;
 
-import static java.util.stream.Collectors.toList;
+import static com.google.common.collect.ImmutableList.toImmutableList;
 
 import com.exonum.binding.common.hash.HashCode;
 import com.exonum.binding.common.serialization.StandardSerializers;
@@ -45,7 +45,7 @@ class ProofMapIndexProxyIntegrationTest
       Bytes.bytes(0x10, 0x10)
   )
       .map(HashCode::fromBytes)
-      .collect(toList());
+      .collect(toImmutableList());
 
   @Override
   List<HashCode> getTestKeys() {

exonum-java-binding/core/src/test/java/com/exonum/binding/core/storage/indices/ProofMapIndexProxyNoKeyHashingIntegrationTest.java

@@ -23,7 +23,7 @@
 import static com.exonum.binding.core.storage.indices.TestStorageItems.V1;
 import static com.exonum.binding.core.storage.indices.TestStorageItems.values;
 import static com.exonum.binding.test.Bytes.createPrefixed;
-import static org.hamcrest.CoreMatchers.equalTo;
+import static com.google.common.collect.ImmutableList.toImmutableList;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
@@ -33,21 +33,17 @@
 import com.exonum.binding.core.storage.database.View;
 import com.exonum.binding.test.Bytes;
 import com.exonum.binding.test.CiOnly;
-import com.google.common.collect.ImmutableList;
-import com.google.common.primitives.UnsignedBytes;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.BitSet;
-import java.util.Iterator;
 import java.util.List;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
 
 class ProofMapIndexProxyNoKeyHashingIntegrationTest
     extends BaseProofMapIndexProxyIntegrationTestable {
 
-  static final List<HashCode> SORTED_TEST_KEYS = Stream.of(
+  static final List<HashCode> TEST_KEYS = Stream.of(
       Bytes.bytes(0x00),
       Bytes.bytes(0x01),
       Bytes.bytes(0x02),
@@ -64,15 +60,14 @@ class ProofMapIndexProxyNoKeyHashingIntegrationTest
       Bytes.bytes(0x10, 0x10)
   )
       .map(BaseProofMapIndexProxyIntegrationTestable::createRawProofKey)
-      .sorted(UnsignedBytes.lexicographicalComparator())
       .map(HashCode::fromBytes)
-      .collect(Collectors.toList());
+      .collect(toImmutableList());
 
   private static final HashCode INVALID_PROOF_KEY = HashCode.fromString("1234");
 
   @Override
   List<HashCode> getTestKeys() {
-    return SORTED_TEST_KEYS;
+    return TEST_KEYS;
   }
 
   @Override
@@ -110,52 +105,6 @@ void removeFailsIfInvalidKey() {
         (map) -> assertThrows(IllegalArgumentException.class, () -> map.remove(INVALID_PROOF_KEY)));
   }
 
-  @Test
-  void keysTest() {
-    runTestWithView(database::createFork, (map) -> {
-      List<MapEntry<HashCode, String>> entries = createSortedMapEntries();
-
-      putAll(map, entries);
-
-      Iterator<HashCode> keysIterator = map.keys();
-      List<HashCode> keysFromIter = ImmutableList.copyOf(keysIterator);
-      List<HashCode> keysInMap = MapEntries.extractKeys(entries);
-
-      // Keys must appear in a lexicographical order.
-      assertThat(keysFromIter, equalTo(keysInMap));
-    });
-  }
-
-  @Test
-  void valuesTest() {
-    runTestWithView(database::createFork, (map) -> {
-      List<MapEntry<HashCode, String>> entries = createSortedMapEntries();
-
-      putAll(map, entries);
-
-      Iterator<String> valuesIterator = map.values();
-      List<String> valuesFromIter = ImmutableList.copyOf(valuesIterator);
-      List<String> valuesInMap = MapEntries.extractValues(entries);
-
-      // Values must appear in a lexicographical order of keys.
-      assertThat(valuesFromIter, equalTo(valuesInMap));
-    });
-  }
-
-  @Test
-  void entriesTest() {
-    runTestWithView(database::createFork, (map) -> {
-      List<MapEntry<HashCode, String>> entries = createSortedMapEntries();
-
-      putAll(map, entries);
-
-      Iterator<MapEntry<HashCode, String>> entriesIterator = map.entries();
-      List<MapEntry> entriesFromIter = ImmutableList.copyOf(entriesIterator);
-      // Entries must appear in a lexicographical order of keys.
-      assertThat(entriesFromIter, equalTo(entries));
-    });
-  }
-
   @Test
   @DisabledProofTest
   void getProof_FourEntryMap_LastByte_Contains1() {
@@ -429,14 +378,6 @@ private static byte[] keyFromString(String prefix) {
     return createPrefixed(keyPrefixBits.toByteArray(), PROOF_MAP_KEY_SIZE);
   }
 
-  /**
-   * Creates `numOfEntries` map entries, sorted by key:
-   * [(00…0PK1, V1), (00…0PK2, V2), … (00…0PKi, Vi)].
-   */
-  List<MapEntry<HashCode, String>> createSortedMapEntries() {
-    return createMapEntries(SORTED_TEST_KEYS.stream());
-  }
-
   /**
    * Creates 257 entries for a ProofMap that, when added to it, will make the underlying
    * Merkle-Patricia tree of the maximum height (256). Leaf nodes will be at depths