[RocksJava] Quality improvements

Summary:
- Addressed some FindBugs issues.
- Remove obsolete dbFolder cleanup
- Comparator tests for CF
 - Added AbstractComparatorTest.
 - Fixed a bug in the JNI Part about Java comparators
- Minor test improvements

Test Plan:
make rocksdbjava
make jtest
mvn -f rocksjni.pom package

Reviewers: adamretter, yhchiang, ankgup87

Subscribers: dhruba

Differential Revision: https://reviews.facebook.net/D29571

java/org/rocksdb/test/BackupableDBTest.java

@@ -215,14 +215,26 @@ public class BackupableDBTest {
       bdb.createNewBackup(true);
       bdb.createNewBackup(true);
       bdb.createNewBackup(true);
-      verifyNumberOfValidBackups(bdb, 4);
+      List<BackupInfo> infos = verifyNumberOfValidBackups(bdb, 4);
+      assertThat(infos.get(1).size()).
+          isEqualTo(infos.get(2).size());
+      assertThat(infos.get(1).numberFiles()).
+          isEqualTo(infos.get(2).numberFiles());
+      long maxTimeBeforePurge = Long.MIN_VALUE;
+      for (BackupInfo backupInfo : infos) {
+        if (maxTimeBeforePurge < backupInfo.timestamp()) {
+          maxTimeBeforePurge = backupInfo.timestamp();
+        }
+      }
       // init RestoreBackupableDB
       rdb = new RestoreBackupableDB(bopt);
       // the same number of backups must
       // exist using RestoreBackupableDB.
       verifyNumberOfValidBackups(rdb, 4);
       rdb.purgeOldBackups(1);
-      verifyNumberOfValidBackups(rdb, 1);
+      infos = verifyNumberOfValidBackups(rdb, 1);
+      assertThat(infos.get(0).timestamp()).
+          isEqualTo(maxTimeBeforePurge);
     } finally {
       if (bdb != null) {
         bdb.close();

java/org/rocksdb/test/BlockBasedTableConfigTest.java

@@ -84,6 +84,9 @@ public class BlockBasedTableConfigTest {
   @Test
   public void checksumType() {
     BlockBasedTableConfig blockBasedTableConfig = new BlockBasedTableConfig();
+    assertThat(ChecksumType.values().length).isEqualTo(3);
+    assertThat(ChecksumType.valueOf("kxxHash")).
+        isEqualTo(ChecksumType.kxxHash);
     blockBasedTableConfig.setChecksumType(ChecksumType.kNoChecksum);
     blockBasedTableConfig.setChecksumType(ChecksumType.kxxHash);
     assertThat(blockBasedTableConfig.checksumType().equals(

java/org/rocksdb/test/ComparatorTest.java

@@ -221,5 +221,8 @@ public class ComparatorTest {
     assertThat(
         BuiltinComparator.REVERSE_BYTEWISE_COMPARATOR.ordinal())
         .isEqualTo(1);
+    assertThat(BuiltinComparator.values().length).isEqualTo(2);
+    assertThat(BuiltinComparator.valueOf("BYTEWISE_COMPARATOR")).
+        isEqualTo(BuiltinComparator.BYTEWISE_COMPARATOR);
   }
 }

java/org/rocksdb/test/InfoLogLevelTest.java

@@ -96,6 +96,17 @@ public class InfoLogLevelTest {
     }
   }
 
+  @Test(expected = IllegalArgumentException.class)
+  public void failIfIllegalByteValueProvided() {
+    InfoLogLevel.getInfoLogLevel((byte)-1);
+  }
+
+  @Test
+  public void valueOf() {
+    assertThat(InfoLogLevel.valueOf("DEBUG_LEVEL")).
+        isEqualTo(InfoLogLevel.DEBUG_LEVEL);
+  }
+
   /**
    * Read LOG file contents into String.
    *

java/org/rocksdb/test/PlainTableConfigTest.java

@@ -63,6 +63,10 @@ public class PlainTableConfigTest {
   public void encodingType() {
     PlainTableConfig plainTableConfig = new PlainTableConfig();
     plainTableConfig.setEncodingType(EncodingType.kPrefix);
+    assertThat(EncodingType.valueOf("kPrefix")).isEqualTo(
+        EncodingType.kPrefix);
+    assertThat(EncodingType.values().length).
+        isEqualTo(2);
     assertThat(plainTableConfig.encodingType()).isEqualTo(
         EncodingType.kPrefix);
   }

java/org/rocksdb/test/WriteBatchHandlerTest.java

@@ -5,7 +5,6 @@
 
 package org.rocksdb.test;
 
-import org.rocksdb.RocksDB;
 import org.rocksdb.RocksDBException;
 import org.rocksdb.WriteBatch;
 
@@ -13,9 +12,9 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+
 import org.junit.ClassRule;
 import org.junit.Test;
-import org.rocksdb.WriteOptions;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -27,7 +26,9 @@ public class WriteBatchHandlerTest {
 
   @Test
   public void writeBatchHandler() throws IOException, RocksDBException {
-
+    WriteBatch batch = null;
+    CapturingWriteBatchHandler handler = null;
+    try {
       // setup test data
       final List<Tuple<Action, Tuple<byte[], byte[]>>> testEvents = new ArrayList<>();
       testEvents.add(new Tuple<>(Action.DELETE,
@@ -46,10 +47,10 @@ public class WriteBatchHandlerTest {
           new Tuple<byte[], byte[]>("k3".getBytes(), null)));
 
       // load test data to the write batch
-        final WriteBatch batch = new WriteBatch();
-        for(final Tuple<Action, Tuple<byte[], byte[]>> testEvent : testEvents) {
+      batch = new WriteBatch();
+      for (final Tuple<Action, Tuple<byte[], byte[]>> testEvent : testEvents) {
         final Tuple<byte[], byte[]> data = testEvent.value;
-            switch(testEvent.key) {
+        switch (testEvent.key) {
 
           case PUT:
             batch.put(data.key, data.value);
@@ -70,38 +71,41 @@ public class WriteBatchHandlerTest {
       }
 
       // attempt to read test data back from the WriteBatch by iterating with a handler
-        final CapturingWriteBatchHandler handler = new CapturingWriteBatchHandler();
+      handler = new CapturingWriteBatchHandler();
       batch.iterate(handler);
 
       // compare the results to the test data
       final List<Tuple<Action, Tuple<byte[], byte[]>>> actualEvents = handler.getEvents();
       assertThat(testEvents.size()).isSameAs(actualEvents.size());
 
-        for(int i = 0; i < testEvents.size(); i++) {
+      for (int i = 0; i < testEvents.size(); i++) {
         assertThat(equals(testEvents.get(i), actualEvents.get(i))).isTrue();
       }
-
-        System.out.println("Passed WriteBatchHandler Test");
+    } finally {
+      if (handler != null) {
+        handler.dispose();
+      }
+      if (batch != null) {
+        batch.dispose();
+      }
+    }
   }
 
   private static boolean equals(final Tuple<Action, Tuple<byte[], byte[]>> expected,
                                 final Tuple<Action, Tuple<byte[], byte[]>> actual) {
-        if(!expected.key.equals(actual.key)) {
+    if (!expected.key.equals(actual.key)) {
       return false;
     }
 
     final Tuple<byte[], byte[]> expectedData = expected.value;
     final Tuple<byte[], byte[]> actualData = actual.value;
 
-        if(equals(expectedData.key, actualData.key)) {
-            return equals(expectedData.value, actualData.value);
-        } else {
-            return false;
-        }
+    return equals(expectedData.key, actualData.key)
+        && equals(expectedData.value, actualData.value);
   }
 
   private static boolean equals(byte[] expected, byte[] actual) {
-        if(expected != null) {
+    if (expected != null) {
       return Arrays.equals(expected, actual);
     } else {
       return actual == null;