apply spotless

Author: Daniel Roudnitsky

hbase-client/src/main/java/org/apache/hadoop/hbase/DoNotRetryRuntimeException.java

@@ -1,15 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.apache.hadoop.hbase;
 
 import org.apache.yetus.audience.InterfaceAudience;
 
 /**
- * When a fatal issue is encountered during an RPC which is not retriable, and the issue
- * is encountered deep in a call stack where throwing a checked DoNotRetryIOException is not
- * possible (e.g filter/comparator application), this unchecked exception can be thrown
- * and will be wrapped in a checked DoNotRetryIOException at the RPC boundary before returning
- * to the client to prevent client retries and to propagate the exception message cleanly.
- * You should use this exception only when absolutely necessary. Wherever possible, use a checked
- * DoNotRetryIOException
+ * When a fatal issue is encountered during an RPC which is not retriable, and the issue is
+ * encountered deep in a call stack where throwing a checked DoNotRetryIOException is not possible
+ * (e.g filter/comparator application), this unchecked exception can be thrown and will be wrapped
+ * in a checked DoNotRetryIOException at the RPC boundary before returning to the client to prevent
+ * client retries and to propagate the exception message cleanly. You should use this exception only
+ * when absolutely necessary. Wherever possible, use a checked DoNotRetryIOException
  */
 @InterfaceAudience.Private
 public class DoNotRetryRuntimeException extends RuntimeException {

hbase-client/src/main/java/org/apache/hadoop/hbase/filter/BinaryComponentComparator.java

@@ -29,9 +29,9 @@
 
 /**
  * A binary comparator which lexicographically compares against the specified byte array similar to
- * {@link BinaryComparator} but starts the comparison from the specified offset. Will throw
- * a runtime exception if a comparison is attempted with a byte array that
- * is too short for the specified offest. See HBASE-22969 for examples on how to use this comparator
+ * {@link BinaryComparator} but starts the comparison from the specified offset. Will throw a
+ * runtime exception if a comparison is attempted with a byte array that is too short for the
+ * specified offest. See HBASE-22969 for examples on how to use this comparator
  */
 @InterfaceAudience.Public
 @SuppressWarnings("ComparableType")
@@ -50,10 +50,9 @@ public OffsetOutOfBoundsException(String message) {
 
   /**
    * @param value  the byte array to compare against
-   * @param offset the starting position (0-based) from which to start comparisons
-   *               Must be less than the length of input arrays being passed
-   *               for comparison, otherwise an {@link OffsetOutOfBoundsException} will be thrown
-   *               on comparison.
+   * @param offset the starting position (0-based) from which to start comparisons Must be less than
+   *               the length of input arrays being passed for comparison, otherwise an
+   *               {@link OffsetOutOfBoundsException} will be thrown on comparison.
    */
   public BinaryComponentComparator(byte[] value, int offset) {
     super(value);
@@ -62,7 +61,7 @@ public BinaryComponentComparator(byte[] value, int offset) {
 
   /**
    * @throws OffsetOutOfBoundsException if input byte array is too small for the offset provided to
-   * comparator when it was constructed
+   *                                    comparator when it was constructed
    */
   @Override
   public int compareTo(byte[] value) {
@@ -71,13 +70,14 @@ public int compareTo(byte[] value) {
 
   /**
    * @throws OffsetOutOfBoundsException if input byte array is too small for the offset provided to
-   * comparator when it was constructed
+   *                                    comparator when it was constructed
    */
   @Override
   public int compareTo(byte[] value, int offset, int length) {
     if (offset + this.offset >= value.length) {
-      String message = String.format("A byte array was encountered with a length %d that is too"
-        + " short/incompatible with the offset value %d provided to BinaryComponentComparator",
+      String message = String.format(
+        "A byte array was encountered with a length %d that is too"
+          + " short/incompatible with the offset value %d provided to BinaryComponentComparator",
         value.length, offset + this.offset);
       throw new OffsetOutOfBoundsException(message);
     }

hbase-server/src/test/java/org/apache/hadoop/hbase/filter/TestFiltersWithBinaryComponentComparator.java

@@ -21,7 +21,6 @@
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
-import org.apache.hbase.thirdparty.com.google.common.base.Throwables;;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -52,6 +51,8 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import org.apache.hbase.thirdparty.com.google.common.base.Throwables;
+
 @Category(MediumTests.class)
 public class TestFiltersWithBinaryComponentComparator {
 
@@ -153,7 +154,8 @@ public void testRowAndValueFilterWithBinaryComponentComparator() throws IOExcept
     ht.close();
   }
 
-  @Rule public ExpectedException thrown = ExpectedException.none();
+  @Rule
+  public ExpectedException thrown = ExpectedException.none();
 
   @Test
   public void testThrowsExceptionOnOffsetOutOfBounds() {
@@ -162,7 +164,8 @@ public void testThrowsExceptionOnOffsetOutOfBounds() {
     byte[] componentValue = new byte[] { (byte) 'A' };
     int offsetValue = 10;
     byte[] valueTooShortForOffset = new byte[offsetValue];
-    BinaryComponentComparator comparator = new BinaryComponentComparator(componentValue, offsetValue);
+    BinaryComponentComparator comparator =
+      new BinaryComponentComparator(componentValue, offsetValue);
     comparator.compareTo(valueTooShortForOffset);
   }
 
@@ -172,13 +175,14 @@ public void testThrowsExceptionOnOffsetOutOfBounds() {
    */
   @Test
   public void testOutOfBoundsExceptionIsNotRetryable() throws IOException {
-    Table table = TEST_UTIL.createTable(TableName.valueOf(name.getMethodName()), family, Integer.MAX_VALUE);
+    Table table =
+      TEST_UTIL.createTable(TableName.valueOf(name.getMethodName()), family, Integer.MAX_VALUE);
 
     // ColumnValueFilter with BinaryComponentComparator with offset 10
     int offsetValue = 10;
     BinaryComponentComparator comparator = new BinaryComponentComparator(new byte[1], offsetValue);
-    ColumnValueFilter columnValueFilter = new ColumnValueFilter(
-      family, qf, CompareOperator.EQUAL, comparator);
+    ColumnValueFilter columnValueFilter =
+      new ColumnValueFilter(family, qf, CompareOperator.EQUAL, comparator);
     Scan scan = new Scan().setFilter(columnValueFilter);
 
     // Insert a row with column value length >= comparator offset
@@ -190,12 +194,12 @@ public void testOutOfBoundsExceptionIsNotRetryable() throws IOException {
 
     // Scan should throw DoNotRetryIOException due to incompatible value length
     try (ResultScanner scanner = table.getScanner(scan)) {
-      scanner.iterator().forEachRemaining(result -> {});
+      scanner.iterator().forEachRemaining(result -> {
+      });
       fail("Scan completed successfully but should have failed");
-    }
-    catch (Exception e) {
-      boolean expectedExceptionFound = Throwables.getCausalChain(e).stream()
-        .anyMatch(DoNotRetryIOException.class::isInstance);
+    } catch (Exception e) {
+      boolean expectedExceptionFound =
+        Throwables.getCausalChain(e).stream().anyMatch(DoNotRetryIOException.class::isInstance);
       if (!expectedExceptionFound) {
         fail("Expected DoNotRetryIOException as the cause, but got: " + e.getCause());
       }