You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ozone.apache.org by ad...@apache.org on 2026/07/03 13:30:58 UTC

(ozone) branch master updated: HDDS-12807. Clean up TestKeyManagerImpl unit test (#10640)

This is an automated email from the ASF dual-hosted git repository.

adoroszlai pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ozone.git


The following commit(s) were added to refs/heads/master by this push:
     new 9596e8d41da HDDS-12807. Clean up TestKeyManagerImpl unit test (#10640)
9596e8d41da is described below

commit 9596e8d41da675075290ef3003dd8078a5e4e507
Author: Eric C. Ho <ec...@gmail.com>
AuthorDate: Fri Jul 3 21:30:52 2026 +0800

    HDDS-12807. Clean up TestKeyManagerImpl unit test (#10640)
---
 .../apache/hadoop/ozone/om/TestKeyManagerImpl.java | 450 +++++++++++++++------
 1 file changed, 332 insertions(+), 118 deletions(-)

diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestKeyManagerImpl.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestKeyManagerImpl.java
index 058bce1f997..4883591d401 100644
--- a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestKeyManagerImpl.java
+++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestKeyManagerImpl.java
@@ -41,62 +41,91 @@
 import org.apache.hadoop.ozone.om.helpers.RepeatedOmKeyInfo;
 import org.apache.ratis.util.function.CheckedFunction;
 import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import org.mockito.Mockito;
 
 /**
  * Test class for unit tests KeyManagerImpl.
  */
 public class TestKeyManagerImpl {
-  private static Stream<Arguments> getTableIteratorParameters() {
+  private static Stream<TestCase> getSuccessfulTableIteratorParameters() {
     return Stream.of(
-        Arguments.argumentSet("Fetch first 50 entries for volume 0, bucket 0",
-            5, 10, 100, 0, 0, 0, 0, 0, 50, null),
-        Arguments.argumentSet("Fetch first 50 entries for any volume/bucket", 5, 10, 100, null, null, 0, 0, 0, 50,
-            null),
-        Arguments.argumentSet("Fetch first 30 entries for volume 1, bucket 1", 5, 10, 100, 1, 1, 0, 0, 0, 30, null),
-        Arguments.argumentSet("Fetch 20 entries from offset (2,2,10) for volume 2, bucket 2", 5, 10, 100, 2, 2, 2, 2,
-            10, 20, null),
-        Arguments.argumentSet("Fetch 40 entries from offset (2,2,50) for volume 3, bucket 3", 5, 10, 100, 3, 3, 3, 3,
-            50, 40, null),
-        Arguments.argumentSet("Fetch 200 entries from the very beginning (null start offsets)", 5, 10, 100, null,
-            null, null, null, null, 200, null),
-        Arguments.argumentSet("Fetch 200 entries starting from bucket 3, key 50, spanning 3 buckets", 5, 10, 100,
-            null, null, 0, 3, 50, 200, null),
-        Arguments.argumentSet("Invalid: bucket is set but volume is null", 5, 10, 100, null, 1, 0, 0, 0, 10,
-            IOException.class),
-        Arguments.argumentSet("Invalid: volume is set but bucket is null", 5, 10, 100, 1, null, 0, 0, 0, 10,
-            IOException.class),
-        Arguments.argumentSet("Fetch 50 entries from volume 2, bucket 5, but only 31 exist", 5, 10, 100, 2, 5, 2, 5,
-            70, 50, null),
-        Arguments.argumentSet("Start from last volume (4), second-last bucket (8), key 80 but only 131 entries exist",
-            5, 10, 100, null, null, 4, 8, 80, 200, null)
+        TestCase.newBuilder("Fetch first 50 entries for volume 0, bucket 0")
+            .volumeBucket(0, 0)
+            .start(0, 0, 0)
+            .entries(50)
+            .build(),
+        TestCase.newBuilder("Fetch first 50 entries for any volume/bucket")
+            .start(0, 0, 0)
+            .entries(50)
+            .build(),
+        TestCase.newBuilder("Fetch first 30 entries for volume 1, bucket 1")
+            .volumeBucket(1, 1)
+            .start(0, 0, 0)
+            .entries(30)
+            .build(),
+        TestCase.newBuilder("Fetch 20 entries from offset (2,2,10) for volume 2, bucket 2")
+            .volumeBucket(2, 2)
+            .start(2, 2, 10)
+            .entries(20)
+            .build(),
+        TestCase.newBuilder("Fetch 40 entries from offset (2,2,50) for volume 3, bucket 3")
+            .volumeBucket(3, 3)
+            .start(3, 3, 50)
+            .entries(40)
+            .build(),
+        TestCase.newBuilder("Fetch 200 entries from the very beginning (null start offsets)")
+            .start(null, null, null)
+            .entries(200)
+            .build(),
+        TestCase.newBuilder("Fetch 200 entries starting from bucket 3, key 50, spanning 3 buckets")
+            .start(0, 3, 50)
+            .entries(200)
+            .build(),
+        TestCase.newBuilder("Fetch 50 entries from volume 2, bucket 5, but only 31 exist")
+            .volumeBucket(2, 5)
+            .start(2, 5, 70)
+            .entries(50)
+            .build(),
+        TestCase.newBuilder("Start from last volume (4), second-last bucket (8), key 80 "
+            + "but only 131 entries exist")
+            .start(4, 8, 80)
+            .entries(200)
+            .build()
+    );
+  }
+
+  private static Stream<TestCase> getInvalidTableIteratorParameters() {
+    return Stream.of(
+        TestCase.newBuilder("Invalid: bucket is set but volume is null")
+            .volumeBucket(null, 1)
+            .start(0, 0, 0)
+            .entries(10)
+            .build(),
+        TestCase.newBuilder("Invalid: volume is set but bucket is null")
+            .volumeBucket(1, null)
+            .start(0, 0, 0)
+            .entries(10)
+            .build()
     );
   }
 
-  @SuppressWarnings({"checkstyle:ParameterNumber"})
   private <V> List<Table.KeyValue<String, V>> mockTableIterator(
-      Class<V> valueClass, Table<String, V> table, int numberOfVolumes, int numberOfBucketsPerVolume,
-      int numberOfKeysPerBucket, String volumeNamePrefix, String bucketNamePrefix, String keyPrefix,
-      Integer volumeNumberFilter, Integer bucketNumberFilter, Integer startVolumeNumber, Integer startBucketNumber,
-      Integer startKeyNumber, CheckedFunction<Table.KeyValue<String, V>, Boolean, IOException> filter,
-      int numberOfEntries) throws IOException {
+      Class<V> valueClass, Table<String, V> table, TestCase testCase, String volumeNamePrefix,
+      String bucketNamePrefix, String keyPrefix,
+      CheckedFunction<Table.KeyValue<String, V>, Boolean, IOException> filter) throws IOException {
     TreeMap<String, V> values = new TreeMap<>();
     List<Table.KeyValue<String, V>> keyValues = new ArrayList<>();
-    String startKey = startVolumeNumber == null || startBucketNumber == null || startKeyNumber == null ? null
-        : (String.format("/%s%010d/%s%010d/%s%010d", volumeNamePrefix, startVolumeNumber, bucketNamePrefix,
-        startBucketNumber, keyPrefix, startKeyNumber));
-    for (int i = 0; i < numberOfVolumes; i++) {
-      for (int j = 0; j < numberOfBucketsPerVolume; j++) {
-        for (int k = 0; k < numberOfKeysPerBucket; k++) {
-          String key = String.format("/%s%010d/%s%010d/%s%010d", volumeNamePrefix, i, bucketNamePrefix, j,
-              keyPrefix, k);
-          V value = valueClass == String.class ? (V) key : mock(valueClass);
+    String startKey = getTableKey(volumeNamePrefix, testCase.getStartVolumeNumber(), bucketNamePrefix,
+        testCase.getStartBucketNumber(), keyPrefix, testCase.getStartKeyNumber());
+    for (int i = 0; i < testCase.getNumberOfVolumes(); i++) {
+      for (int j = 0; j < testCase.getNumberOfBucketsPerVolume(); j++) {
+        for (int k = 0; k < testCase.getNumberOfKeysPerBucket(); k++) {
+          String key = getTableKey(volumeNamePrefix, i, bucketNamePrefix, j, keyPrefix, k);
+          V value = valueClass == String.class ? valueClass.cast(key) : mock(valueClass);
           values.put(key, value);
 
-          if ((volumeNumberFilter == null || i == volumeNumberFilter) &&
-              (bucketNumberFilter == null || j == bucketNumberFilter) &&
+          if ((testCase.getVolumeNumber() == null || i == testCase.getVolumeNumber()) &&
+              (testCase.getBucketNumber() == null || j == testCase.getBucketNumber()) &&
               (startKey == null || startKey.compareTo(key) <= 0)) {
             keyValues.add(Table.newKeyValue(key, value));
           }
@@ -111,124 +140,309 @@ private <V> List<Table.KeyValue<String, V>> mockTableIterator(
       } catch (IOException e) {
         throw new RuntimeException(e);
       }
-    }).limit(numberOfEntries).collect(Collectors.toList());
+    }).limit(testCase.getNumberOfEntries()).collect(Collectors.toList());
   }
 
-  @ParameterizedTest
-  @MethodSource("getTableIteratorParameters")
-  @SuppressWarnings({"checkstyle:ParameterNumber"})
-  public void testGetDeletedKeyEntries(int numberOfVolumes, int numberOfBucketsPerVolume, int numberOfKeysPerBucket,
-                                       Integer volumeNumber, Integer bucketNumber,
-                                       Integer startVolumeNumber, Integer startBucketNumber, Integer startKeyNumber,
-                                       int numberOfEntries, Class<? extends Exception> expectedException)
-      throws IOException {
+  @ParameterizedTest(name = "{0}")
+  @MethodSource("getSuccessfulTableIteratorParameters")
+  void testGetDeletedKeyEntries(TestCase testCase) throws IOException {
     String volumeNamePrefix = "volume";
     String bucketNamePrefix = "bucket";
     String keyPrefix = "key";
     OzoneConfiguration configuration = new OzoneConfiguration();
-    OMMetadataManager metadataManager = Mockito.mock(OMMetadataManager.class);
+    OMMetadataManager metadataManager = mock(OMMetadataManager.class);
     KeyManagerImpl km = new KeyManagerImpl(null, null, metadataManager, configuration, null, null, null);
-    Table<String, RepeatedOmKeyInfo> mockedDeletedTable = Mockito.mock(Table.class);
+    Table<String, RepeatedOmKeyInfo> mockedDeletedTable = mock(Table.class);
     when(mockedDeletedTable.getName()).thenReturn(DELETED_TABLE);
     when(metadataManager.getDeletedTable()).thenReturn(mockedDeletedTable);
     when(metadataManager.getTableBucketPrefix(eq(DELETED_TABLE), anyString(), anyString()))
-        .thenAnswer(i -> "/" + i.getArguments()[1] + "/" + i.getArguments()[2] + "/");
+        .thenAnswer(i -> getBucketPrefix(i.getArguments()));
     CheckedFunction<Table.KeyValue<String, RepeatedOmKeyInfo>, Boolean, IOException> filter =
-        (kv) -> Long.parseLong(kv.getKey().split(keyPrefix)[1]) % 2 == 0;
+        (kv) -> getKeyIndex(kv.getKey(), keyPrefix) % 2 == 0;
     List<Table.KeyValue<String, List<OmKeyInfo>>> expectedEntries = mockTableIterator(
-        RepeatedOmKeyInfo.class, mockedDeletedTable, numberOfVolumes, numberOfBucketsPerVolume, numberOfKeysPerBucket,
-        volumeNamePrefix, bucketNamePrefix, keyPrefix, volumeNumber, bucketNumber, startVolumeNumber, startBucketNumber,
-        startKeyNumber, filter, numberOfEntries).stream()
+        RepeatedOmKeyInfo.class, mockedDeletedTable, testCase, volumeNamePrefix, bucketNamePrefix, keyPrefix,
+        filter).stream()
         .map(kv -> {
           String key = kv.getKey();
           RepeatedOmKeyInfo value = kv.getValue();
-          List<OmKeyInfo> omKeyInfos = Collections.singletonList(Mockito.mock(OmKeyInfo.class));
+          List<OmKeyInfo> omKeyInfos = Collections.singletonList(mock(OmKeyInfo.class));
           when(value.cloneOmKeyInfoList()).thenReturn(omKeyInfos);
           return Table.newKeyValue(key, omKeyInfos);
         }).collect(Collectors.toList());
-    String volumeName = volumeNumber == null ? null : (String.format("%s%010d", volumeNamePrefix, volumeNumber));
-    String bucketName = bucketNumber == null ? null : (String.format("%s%010d", bucketNamePrefix, bucketNumber));
-    String startKey = startVolumeNumber == null || startBucketNumber == null || startKeyNumber == null ? null
-        : (String.format("/%s%010d/%s%010d/%s%010d", volumeNamePrefix, startVolumeNumber, bucketNamePrefix,
-        startBucketNumber, keyPrefix, startKeyNumber));
-    if (expectedException != null) {
-      assertThrows(expectedException, () -> km.getDeletedKeyEntries(volumeName, bucketName, startKey, filter,
-          numberOfEntries));
-    } else {
-      assertEquals(expectedEntries,
-          km.getDeletedKeyEntries(volumeName, bucketName, startKey, filter, numberOfEntries));
-    }
+    String volumeName = getObjectName(volumeNamePrefix, testCase.getVolumeNumber());
+    String bucketName = getObjectName(bucketNamePrefix, testCase.getBucketNumber());
+    String startKey = getTableKey(volumeNamePrefix, testCase.getStartVolumeNumber(), bucketNamePrefix,
+        testCase.getStartBucketNumber(), keyPrefix, testCase.getStartKeyNumber());
+    assertEquals(expectedEntries,
+        km.getDeletedKeyEntries(volumeName, bucketName, startKey, filter, testCase.getNumberOfEntries()));
   }
 
-  @ParameterizedTest
-  @MethodSource("getTableIteratorParameters")
-  @SuppressWarnings({"checkstyle:ParameterNumber"})
-  public void testGetRenameKeyEntries(int numberOfVolumes, int numberOfBucketsPerVolume, int numberOfKeysPerBucket,
-                                      Integer volumeNumber, Integer bucketNumber,
-                                      Integer startVolumeNumber, Integer startBucketNumber, Integer startKeyNumber,
-                                      int numberOfEntries, Class<? extends Exception> expectedException)
-      throws IOException {
+  @ParameterizedTest(name = "{0}")
+  @MethodSource("getInvalidTableIteratorParameters")
+  void testGetDeletedKeyEntriesFails(TestCase testCase) throws IOException {
+    String volumeNamePrefix = "volume";
+    String bucketNamePrefix = "bucket";
+    String keyPrefix = "key";
+    OzoneConfiguration configuration = new OzoneConfiguration();
+    OMMetadataManager metadataManager = mock(OMMetadataManager.class);
+    KeyManagerImpl km = new KeyManagerImpl(null, null, metadataManager, configuration, null, null, null);
+    Table<String, RepeatedOmKeyInfo> mockedDeletedTable = mock(Table.class);
+    when(mockedDeletedTable.getName()).thenReturn(DELETED_TABLE);
+    when(metadataManager.getDeletedTable()).thenReturn(mockedDeletedTable);
+    when(metadataManager.getTableBucketPrefix(eq(DELETED_TABLE), anyString(), anyString()))
+        .thenAnswer(i -> getBucketPrefix(i.getArguments()));
+    CheckedFunction<Table.KeyValue<String, RepeatedOmKeyInfo>, Boolean, IOException> filter =
+        (kv) -> getKeyIndex(kv.getKey(), keyPrefix) % 2 == 0;
+    String volumeName = getObjectName(volumeNamePrefix, testCase.getVolumeNumber());
+    String bucketName = getObjectName(bucketNamePrefix, testCase.getBucketNumber());
+    String startKey = getTableKey(volumeNamePrefix, testCase.getStartVolumeNumber(), bucketNamePrefix,
+        testCase.getStartBucketNumber(), keyPrefix, testCase.getStartKeyNumber());
+
+    assertThrows(IOException.class,
+        () -> km.getDeletedKeyEntries(volumeName, bucketName, startKey, filter, testCase.getNumberOfEntries()));
+  }
+
+  @ParameterizedTest(name = "{0}")
+  @MethodSource("getSuccessfulTableIteratorParameters")
+  void testGetRenameKeyEntries(TestCase testCase) throws IOException {
     String volumeNamePrefix = "volume";
     String bucketNamePrefix = "bucket";
     String keyPrefix = "";
     OzoneConfiguration configuration = new OzoneConfiguration();
-    OMMetadataManager metadataManager = Mockito.mock(OMMetadataManager.class);
+    OMMetadataManager metadataManager = mock(OMMetadataManager.class);
     KeyManagerImpl km = new KeyManagerImpl(null, null, metadataManager, configuration, null, null, null);
-    Table<String, String> mockedRenameTable = Mockito.mock(Table.class);
+    Table<String, String> mockedRenameTable = mock(Table.class);
     when(mockedRenameTable.getName()).thenReturn(SNAPSHOT_RENAMED_TABLE);
     when(metadataManager.getSnapshotRenamedTable()).thenReturn(mockedRenameTable);
     when(metadataManager.getTableBucketPrefix(eq(SNAPSHOT_RENAMED_TABLE), anyString(), anyString()))
-        .thenAnswer(i -> "/" + i.getArguments()[1] + "/" + i.getArguments()[2] + "/");
+        .thenAnswer(i -> getBucketPrefix(i.getArguments()));
     CheckedFunction<Table.KeyValue<String, String>, Boolean, IOException> filter =
-        (kv) -> Long.parseLong(kv.getKey().split("/")[3]) % 2 == 0;
+        (kv) -> getRenameKeyIndex(kv.getKey()) % 2 == 0;
     List<Table.KeyValue<String, String>> expectedEntries = mockTableIterator(
-        String.class, mockedRenameTable, numberOfVolumes, numberOfBucketsPerVolume, numberOfKeysPerBucket,
-        volumeNamePrefix, bucketNamePrefix, keyPrefix, volumeNumber, bucketNumber, startVolumeNumber, startBucketNumber,
-        startKeyNumber, filter, numberOfEntries);
-    String volumeName = volumeNumber == null ? null : (String.format("%s%010d", volumeNamePrefix, volumeNumber));
-    String bucketName = bucketNumber == null ? null : (String.format("%s%010d", bucketNamePrefix, bucketNumber));
-    String startKey = startVolumeNumber == null || startBucketNumber == null || startKeyNumber == null ? null
-        : (String.format("/%s%010d/%s%010d/%s%010d", volumeNamePrefix, startVolumeNumber, bucketNamePrefix,
-        startBucketNumber, keyPrefix, startKeyNumber));
-    if (expectedException != null) {
-      assertThrows(expectedException, () -> km.getRenamesKeyEntries(volumeName, bucketName, startKey,
-          filter, numberOfEntries));
-    } else {
-      assertEquals(expectedEntries,
-          km.getRenamesKeyEntries(volumeName, bucketName, startKey, filter, numberOfEntries));
-    }
+        String.class, mockedRenameTable, testCase, volumeNamePrefix, bucketNamePrefix, keyPrefix, filter);
+    String volumeName = getObjectName(volumeNamePrefix, testCase.getVolumeNumber());
+    String bucketName = getObjectName(bucketNamePrefix, testCase.getBucketNumber());
+    String startKey = getTableKey(volumeNamePrefix, testCase.getStartVolumeNumber(), bucketNamePrefix,
+        testCase.getStartBucketNumber(), keyPrefix, testCase.getStartKeyNumber());
+    assertEquals(expectedEntries,
+        km.getRenamesKeyEntries(volumeName, bucketName, startKey, filter, testCase.getNumberOfEntries()));
+  }
+
+  @ParameterizedTest(name = "{0}")
+  @MethodSource("getInvalidTableIteratorParameters")
+  void testGetRenameKeyEntriesFails(TestCase testCase) throws IOException {
+    String volumeNamePrefix = "volume";
+    String bucketNamePrefix = "bucket";
+    String keyPrefix = "";
+    OzoneConfiguration configuration = new OzoneConfiguration();
+    OMMetadataManager metadataManager = mock(OMMetadataManager.class);
+    KeyManagerImpl km = new KeyManagerImpl(null, null, metadataManager, configuration, null, null, null);
+    Table<String, String> mockedRenameTable = mock(Table.class);
+    when(mockedRenameTable.getName()).thenReturn(SNAPSHOT_RENAMED_TABLE);
+    when(metadataManager.getSnapshotRenamedTable()).thenReturn(mockedRenameTable);
+    when(metadataManager.getTableBucketPrefix(eq(SNAPSHOT_RENAMED_TABLE), anyString(), anyString()))
+        .thenAnswer(i -> getBucketPrefix(i.getArguments()));
+    CheckedFunction<Table.KeyValue<String, String>, Boolean, IOException> filter =
+        (kv) -> getRenameKeyIndex(kv.getKey()) % 2 == 0;
+    String volumeName = getObjectName(volumeNamePrefix, testCase.getVolumeNumber());
+    String bucketName = getObjectName(bucketNamePrefix, testCase.getBucketNumber());
+    String startKey = getTableKey(volumeNamePrefix, testCase.getStartVolumeNumber(), bucketNamePrefix,
+        testCase.getStartBucketNumber(), keyPrefix, testCase.getStartKeyNumber());
+
+    assertThrows(IOException.class,
+        () -> km.getRenamesKeyEntries(volumeName, bucketName, startKey, filter, testCase.getNumberOfEntries()));
   }
 
-  @ParameterizedTest
-  @MethodSource("getTableIteratorParameters")
-  @SuppressWarnings({"checkstyle:ParameterNumber"})
-  public void testGetDeletedDirEntries(int numberOfVolumes, int numberOfBucketsPerVolume, int numberOfKeysPerBucket,
-                                       Integer volumeNumber, Integer bucketNumber,
-                                       Integer startVolumeNumber, Integer startBucketNumber, Integer startKeyNumber,
-                                       int numberOfEntries, Class<? extends Exception> expectedException)
-      throws IOException {
+  @ParameterizedTest(name = "{0}")
+  @MethodSource("getSuccessfulTableIteratorParameters")
+  void testGetDeletedDirEntries(TestCase testCase) throws IOException {
     String volumeNamePrefix = "";
     String bucketNamePrefix = "";
     String keyPrefix = "key";
-    startVolumeNumber = null;
     OzoneConfiguration configuration = new OzoneConfiguration();
-    OMMetadataManager metadataManager = Mockito.mock(OMMetadataManager.class);
+    OMMetadataManager metadataManager = mock(OMMetadataManager.class);
     KeyManagerImpl km = new KeyManagerImpl(null, null, metadataManager, configuration, null, null, null);
-    Table<String, OmKeyInfo> mockedDeletedDirTable = Mockito.mock(Table.class);
+    Table<String, OmKeyInfo> mockedDeletedDirTable = mock(Table.class);
     when(mockedDeletedDirTable.getName()).thenReturn(DELETED_DIR_TABLE);
     when(metadataManager.getDeletedDirTable()).thenReturn(mockedDeletedDirTable);
     when(metadataManager.getTableBucketPrefix(eq(DELETED_DIR_TABLE), anyString(), anyString()))
-        .thenAnswer(i -> "/" + i.getArguments()[1] + "/" + i.getArguments()[2] + "/");
+        .thenAnswer(i -> getBucketPrefix(i.getArguments()));
     List<Table.KeyValue<String, OmKeyInfo>> expectedEntries = mockTableIterator(
-        OmKeyInfo.class, mockedDeletedDirTable, numberOfVolumes, numberOfBucketsPerVolume, numberOfKeysPerBucket,
-        volumeNamePrefix, bucketNamePrefix, keyPrefix, volumeNumber, bucketNumber, startVolumeNumber, startBucketNumber,
-        startKeyNumber, (kv) -> true, numberOfEntries);
-    String volumeName = volumeNumber == null ? null : (String.format("%s%010d", volumeNamePrefix, volumeNumber));
-    String bucketName = bucketNumber == null ? null : (String.format("%s%010d", bucketNamePrefix, bucketNumber));
-    if (expectedException != null) {
-      assertThrows(expectedException, () -> km.getDeletedDirEntries(volumeName, bucketName, numberOfEntries));
-    } else {
-      assertEquals(expectedEntries, km.getDeletedDirEntries(volumeName, bucketName, numberOfEntries));
+        OmKeyInfo.class, mockedDeletedDirTable, testCase.withoutStartKey(), volumeNamePrefix, bucketNamePrefix,
+        keyPrefix, (kv) -> true);
+    String volumeName = getObjectName(volumeNamePrefix, testCase.getVolumeNumber());
+    String bucketName = getObjectName(bucketNamePrefix, testCase.getBucketNumber());
+    assertEquals(expectedEntries, km.getDeletedDirEntries(volumeName, bucketName, testCase.getNumberOfEntries()));
+  }
+
+  @ParameterizedTest(name = "{0}")
+  @MethodSource("getInvalidTableIteratorParameters")
+  void testGetDeletedDirEntriesFails(TestCase testCase) throws IOException {
+    String volumeNamePrefix = "";
+    String bucketNamePrefix = "";
+    OzoneConfiguration configuration = new OzoneConfiguration();
+    OMMetadataManager metadataManager = mock(OMMetadataManager.class);
+    KeyManagerImpl km = new KeyManagerImpl(null, null, metadataManager, configuration, null, null, null);
+    Table<String, OmKeyInfo> mockedDeletedDirTable = mock(Table.class);
+    when(mockedDeletedDirTable.getName()).thenReturn(DELETED_DIR_TABLE);
+    when(metadataManager.getDeletedDirTable()).thenReturn(mockedDeletedDirTable);
+    when(metadataManager.getTableBucketPrefix(eq(DELETED_DIR_TABLE), anyString(), anyString()))
+        .thenAnswer(i -> getBucketPrefix(i.getArguments()));
+    String volumeName = getObjectName(volumeNamePrefix, testCase.getVolumeNumber());
+    String bucketName = getObjectName(bucketNamePrefix, testCase.getBucketNumber());
+
+    assertThrows(IOException.class,
+        () -> km.getDeletedDirEntries(volumeName, bucketName, testCase.getNumberOfEntries()));
+  }
+
+  private static String getObjectName(String prefix, Integer number) {
+    return number == null ? null : String.format("%s%010d", prefix, number);
+  }
+
+  private static String getTableKey(String volumeNamePrefix, Integer volumeNumber, String bucketNamePrefix,
+      Integer bucketNumber, String keyPrefix, Integer keyNumber) {
+    if (volumeNumber == null || bucketNumber == null || keyNumber == null) {
+      return null;
+    }
+    return String.format("/%s%010d/%s%010d/%s%010d", volumeNamePrefix, volumeNumber, bucketNamePrefix, bucketNumber,
+        keyPrefix, keyNumber);
+  }
+
+  private static String getBucketPrefix(Object[] arguments) {
+    return "/" + arguments[1] + "/" + arguments[2] + "/";
+  }
+
+  private static long getKeyIndex(String key, String keyPrefix) {
+    return Long.parseLong(key.split(keyPrefix)[1]);
+  }
+
+  private static long getRenameKeyIndex(String key) {
+    return Long.parseLong(key.split("/")[3]);
+  }
+
+  private static final class TestCase {
+    private final String name;
+    private final int numberOfVolumes;
+    private final int numberOfBucketsPerVolume;
+    private final int numberOfKeysPerBucket;
+    private final Integer volumeNumber;
+    private final Integer bucketNumber;
+    private final Integer startVolumeNumber;
+    private final Integer startBucketNumber;
+    private final Integer startKeyNumber;
+    private final int numberOfEntries;
+
+    private TestCase(Builder builder) {
+      name = builder.name;
+      numberOfVolumes = builder.numberOfVolumes;
+      numberOfBucketsPerVolume = builder.numberOfBucketsPerVolume;
+      numberOfKeysPerBucket = builder.numberOfKeysPerBucket;
+      volumeNumber = builder.volumeNumber;
+      bucketNumber = builder.bucketNumber;
+      startVolumeNumber = builder.startVolumeNumber;
+      startBucketNumber = builder.startBucketNumber;
+      startKeyNumber = builder.startKeyNumber;
+      numberOfEntries = builder.numberOfEntries;
+    }
+
+    static Builder newBuilder(String name) {
+      return new Builder(name);
+    }
+
+    TestCase withoutStartKey() {
+      return newBuilder(name)
+          .tableSize(numberOfVolumes, numberOfBucketsPerVolume, numberOfKeysPerBucket)
+          .volumeBucket(volumeNumber, bucketNumber)
+          .start(null, startBucketNumber, startKeyNumber)
+          .entries(numberOfEntries)
+          .build();
+    }
+
+    int getNumberOfVolumes() {
+      return numberOfVolumes;
+    }
+
+    int getNumberOfBucketsPerVolume() {
+      return numberOfBucketsPerVolume;
+    }
+
+    int getNumberOfKeysPerBucket() {
+      return numberOfKeysPerBucket;
+    }
+
+    Integer getVolumeNumber() {
+      return volumeNumber;
+    }
+
+    Integer getBucketNumber() {
+      return bucketNumber;
+    }
+
+    Integer getStartVolumeNumber() {
+      return startVolumeNumber;
+    }
+
+    Integer getStartBucketNumber() {
+      return startBucketNumber;
+    }
+
+    Integer getStartKeyNumber() {
+      return startKeyNumber;
+    }
+
+    int getNumberOfEntries() {
+      return numberOfEntries;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+
+    private static final class Builder {
+      private final String name;
+      private int numberOfVolumes = 5;
+      private int numberOfBucketsPerVolume = 10;
+      private int numberOfKeysPerBucket = 100;
+      private Integer volumeNumber;
+      private Integer bucketNumber;
+      private Integer startVolumeNumber;
+      private Integer startBucketNumber;
+      private Integer startKeyNumber;
+      private int numberOfEntries;
+
+      private Builder(String testName) {
+        this.name = testName;
+      }
+
+      Builder tableSize(int volumes, int bucketsPerVolume, int keysPerBucket) {
+        numberOfVolumes = volumes;
+        numberOfBucketsPerVolume = bucketsPerVolume;
+        numberOfKeysPerBucket = keysPerBucket;
+        return this;
+      }
+
+      Builder volumeBucket(Integer volume, Integer bucket) {
+        volumeNumber = volume;
+        bucketNumber = bucket;
+        return this;
+      }
+
+      Builder start(Integer volume, Integer bucket, Integer key) {
+        startVolumeNumber = volume;
+        startBucketNumber = bucket;
+        startKeyNumber = key;
+        return this;
+      }
+
+      Builder entries(int entries) {
+        numberOfEntries = entries;
+        return this;
+      }
+
+      TestCase build() {
+        return new TestCase(this);
+      }
     }
   }
 }


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@ozone.apache.org
For additional commands, e-mail: commits-help@ozone.apache.org