Add truncate and pop to ProofListIndexProxy [ECR-3669] (#1272)

Extract these operations to the interface. Move their tests
to the base test of interface operations, make some of them
parameterized.

Author: dmitry-timofeev

exonum-java-binding/CHANGELOG.md

@@ -42,6 +42,7 @@ the [migration guide](https://github.com/exonum/exonum-java-binding/blob/ejb/v0.
   schemas with unique namespaces. (#1181)
 - Implement `run-dev` command support for running the node in development mode. (#1217)
 - `Configurable` interface corresponding to `exonum.Configure`. (#1234)
+- `ProofMapIndexProxy#truncate` and `#removeLast`. (#1272)
 - Java 13 support.
 
 ### Changed

exonum-java-binding/core/rust/src/storage/proof_list_index.rs

@@ -137,6 +137,46 @@ pub extern "system" fn Java_com_exonum_binding_core_storage_indices_ProofListInd
     utils::unwrap_exc_or(&env, res, ptr::null_mut())
 }
 
+/// Removes the last element from a list and returns it, or null pointer if it is empty.
+#[no_mangle]
+pub extern "system" fn Java_com_exonum_binding_core_storage_indices_ProofListIndexProxy_nativeRemoveLast(
+    env: JNIEnv,
+    _: JObject,
+    list_handle: Handle,
+) -> jbyteArray {
+    let res = panic::catch_unwind(|| {
+        let val = match *handle::cast_handle::<IndexType>(list_handle) {
+            IndexType::SnapshotIndex(_) => panic!("Unable to modify snapshot."),
+            IndexType::ForkIndex(ref mut list) => list.pop(),
+        };
+        match val {
+            Some(val) => env.byte_array_from_slice(&val),
+            None => Ok(ptr::null_mut()),
+        }
+    });
+    utils::unwrap_exc_or(&env, res, ptr::null_mut())
+}
+
+/// Shortens the list, keeping the first len elements and dropping the rest.
+#[no_mangle]
+pub extern "system" fn Java_com_exonum_binding_core_storage_indices_ProofListIndexProxy_nativeTruncate(
+    env: JNIEnv,
+    _: JObject,
+    list_handle: Handle,
+    len: jlong,
+) {
+    let res = panic::catch_unwind(|| match *handle::cast_handle::<IndexType>(list_handle) {
+        IndexType::SnapshotIndex(_) => {
+            panic!("Unable to modify snapshot.");
+        }
+        IndexType::ForkIndex(ref mut list) => {
+            list.truncate(len as u64);
+            Ok(())
+        }
+    });
+    utils::unwrap_exc_or_default(&env, res)
+}
+
 /// Returns `true` if the list is empty.
 #[no_mangle]
 pub extern "system" fn Java_com_exonum_binding_core_storage_indices_ProofListIndexProxy_nativeIsEmpty(

exonum-java-binding/core/src/main/java/com/exonum/binding/core/storage/indices/AbstractListIndexProxy.java

@@ -18,6 +18,7 @@
 
 import static com.exonum.binding.core.storage.indices.StoragePreconditions.checkElementIndex;
 import static com.exonum.binding.core.storage.indices.StoragePreconditions.checkNoNulls;
+import static com.google.common.base.Preconditions.checkArgument;
 
 import com.exonum.binding.common.serialization.CheckingSerializerDecorator;
 import com.exonum.binding.core.proxy.NativeHandle;
@@ -91,6 +92,23 @@ public final T getLast() {
     return serializer.fromBytes(e);
   }
 
+  @Override
+  public T removeLast() {
+    notifyModified();
+    byte[] e = nativeRemoveLast(getNativeHandle());
+    if (e == null) {
+      throw new NoSuchElementException("List is empty");
+    }
+    return serializer.fromBytes(e);
+  }
+
+  @Override
+  public void truncate(long newSize) {
+    checkArgument(newSize >= 0, "New size must be non-negative: %s", newSize);
+    notifyModified();
+    nativeTruncate(getNativeHandle(), newSize);
+  }
+
   @Override
   public final void clear() {
     notifyModified();
@@ -133,6 +151,10 @@ public Stream<T> stream() {
 
   abstract byte[] nativeGetLast(long nativeHandle);
 
+  abstract byte[] nativeRemoveLast(long nativeHandle);
+
+  abstract void nativeTruncate(long nativeHandle, long newSize);
+
   abstract void nativeClear(long nativeHandle);
 
   abstract boolean nativeIsEmpty(long nativeHandle);

exonum-java-binding/core/src/main/java/com/exonum/binding/core/storage/indices/ListIndex.java

@@ -89,6 +89,29 @@ public interface ListIndex<T> extends StorageIndex, Iterable<T> {
    */
   T getLast();
 
+  /**
+   * Removes the last element of the list and returns it.
+   *
+   * @return the last element of the list.
+   * @throws NoSuchElementException if the list is empty
+   * @throws IllegalStateException if this list is not valid
+   * @throws UnsupportedOperationException if this list is read-only
+   */
+  T removeLast();
+
+  /**
+   * Truncates the list, reducing its size to {@code newSize}.
+   *
+   * <p>If {@code newSize < size()}, keeps the first {@code newSize} elements, removing the rest.
+   * If {@code newSize >= size()}, has no effect.
+   *
+   * @param newSize the maximum number of elements to keep
+   * @throws IllegalArgumentException if the new size is negative
+   * @throws IllegalStateException if this list is not valid
+   * @throws UnsupportedOperationException if this list is read-only
+   */
+  void truncate(long newSize);
+
   /**
    * Clears the list.
    *

exonum-java-binding/core/src/main/java/com/exonum/binding/core/storage/indices/ListIndexProxy.java

@@ -17,7 +17,6 @@
 package com.exonum.binding.core.storage.indices;
 
 import static com.exonum.binding.core.storage.indices.StoragePreconditions.checkIndexType;
-import static com.google.common.base.Preconditions.checkArgument;
 
 import com.exonum.binding.common.serialization.CheckingSerializerDecorator;
 import com.exonum.binding.common.serialization.Serializer;
@@ -28,7 +27,6 @@
 import com.exonum.binding.core.storage.database.View;
 import com.exonum.binding.core.util.LibraryLoader;
 import com.google.protobuf.MessageLite;
-import java.util.NoSuchElementException;
 import java.util.function.LongSupplier;
 
 /**
@@ -161,40 +159,6 @@ private ListIndexProxy(NativeHandle nativeHandle, IndexAddress address, View vie
     super(nativeHandle, address, view, serializer);
   }
 
-  /**
-   * Removes the last element of the list and returns it.
-   *
-   * @return the last element of the list.
-   * @throws NoSuchElementException if the list is empty
-   * @throws IllegalStateException if this list is not valid
-   * @throws UnsupportedOperationException if this list is read-only
-   */
-  public E removeLast() {
-    notifyModified();
-    byte[] e = nativeRemoveLast(getNativeHandle());
-    if (e == null) {
-      throw new NoSuchElementException("List is empty");
-    }
-    return serializer.fromBytes(e);
-  }
-
-  /**
-   * Truncates the list, reducing its size to {@code newSize}.
-   *
-   * <p>If {@code newSize < size()}, keeps the first {@code newSize} elements, removing the rest.
-   * If {@code newSize >= size()}, has no effect.
-   *
-   * @param newSize the maximum number of elements to keep
-   * @throws IllegalArgumentException if the new size is negative
-   * @throws IllegalStateException if this list is not valid
-   * @throws UnsupportedOperationException if this list is read-only
-   */
-  public void truncate(long newSize) {
-    checkArgument(newSize >= 0, "New size must be non-negative: %s", newSize);
-    notifyModified();
-    nativeTruncate(getNativeHandle(), newSize);
-  }
-
   private static native long nativeCreate(String listName, long viewNativeHandle);
 
   private static native long nativeCreateInGroup(String groupName, byte[] listId,
@@ -214,8 +178,10 @@ private static native long nativeCreateInGroup(String groupName, byte[] listId,
   @Override
   native byte[] nativeGetLast(long nativeHandle);
 
+  @Override
   native byte[] nativeRemoveLast(long nativeHandle);
 
+  @Override
   native void nativeTruncate(long nativeHandle, long newSize);
 
   @Override

exonum-java-binding/core/src/main/java/com/exonum/binding/core/storage/indices/ProofListIndexProxy.java

@@ -234,6 +234,12 @@ public HashCode getIndexHash() {
   @Override
   native byte[] nativeGetLast(long nativeHandle);
 
+  @Override
+  native byte[] nativeRemoveLast(long nativeHandle);
+
+  @Override
+  native void nativeTruncate(long nativeHandle, long newSize);
+
   @Override
   native void nativeClear(long nativeHandle);
 

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

@@ -44,6 +44,8 @@
 import java.util.function.Function;
 import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 /**
  * Base class for common ListIndex tests.
@@ -233,6 +235,114 @@ void getLastTwoElementList() {
     });
   }
 
+  @Test
+  void removeLastEmptyList() {
+    runTestWithView(database::createFork, (l) -> {
+      assertThrows(NoSuchElementException.class, l::removeLast);
+    });
+  }
+
+  @Test
+  void removeLastWithSnapshot() {
+    runTestWithView(database::createSnapshot, (l) -> {
+      assertThrows(UnsupportedOperationException.class, l::removeLast);
+    });
+  }
+
+  @Test
+  void removeLastSingleElementList() {
+    runTestWithView(database::createFork, (l) -> {
+      String addedElement = V1;
+      l.add(addedElement);
+      String last = l.removeLast();
+
+      assertThat(last, equalTo(addedElement));
+      assertTrue(l.isEmpty());
+    });
+  }
+
+  @Test
+  void removeLastTwoElementList() {
+    runTestWithView(database::createFork, (l) -> {
+      l.add(V1);
+      l.add(V2);
+      String last = l.removeLast();
+
+      assertThat(last, equalTo(V2));
+      assertThat(l.size(), equalTo(1L));
+      assertThat(l.get(0), equalTo(V1));
+    });
+  }
+
+  @Test
+  void truncateNonEmptyToZero() {
+    runTestWithView(database::createFork, (l) -> {
+      l.add(V1);
+      l.truncate(0);
+
+      assertTrue(l.isEmpty());
+      assertThat(l.size(), equalTo(0L));
+    });
+  }
+
+  @Test
+  void truncateToSameSize() {
+    runTestWithView(database::createFork, (l) -> {
+      l.add(V1);
+      long newSize = l.size();
+
+      l.truncate(newSize);
+
+      assertThat(l.size(), equalTo(newSize));
+    });
+  }
+
+  @Test
+  void truncateToSmallerSize() {
+    runTestWithView(database::createFork, (l) -> {
+      long newSize = 1;
+      l.add(V1);
+      l.add(V2);
+      l.truncate(newSize);
+
+      assertThat(l.size(), equalTo(newSize));
+    });
+  }
+
+  @ParameterizedTest
+  @ValueSource(longs = {3, 4, Long.MAX_VALUE})
+  void truncateToGreaterSizeHasNoEffect(long newSize) {
+    runTestWithView(database::createFork, (l) -> {
+      // Create a list of two elements
+      l.add(V1);
+      l.add(V2);
+
+      long oldSize = l.size();
+      l.truncate(newSize);
+
+      assertThat(l.size(), equalTo(oldSize));
+    });
+  }
+
+  @ParameterizedTest
+  @ValueSource(longs = {-1, -2, Long.MIN_VALUE})
+  void truncateToNegativeSizeThrows(long invalidSize) {
+    runTestWithView(database::createFork, (l) -> {
+      l.add(V1);
+
+      assertThrows(IllegalArgumentException.class,
+          () -> l.truncate(invalidSize));
+    });
+  }
+
+  @Test
+  void truncateWithSnapshot() {
+    runTestWithView(database::createSnapshot, (l) -> {
+      assertThrows(UnsupportedOperationException.class,
+          () -> l.truncate(0L));
+    });
+  }
+
   @Test
   void clearEmptyHasNoEffect() {
     runTestWithView(database::createFork, (l) -> {