hbase-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From j...@apache.org
Subject [hbase] branch branch-2.1 updated: HBASE-23645 Fixed remaining Checkstyle violations in hbase-common tests
Date Tue, 07 Jan 2020 08:43:07 GMT
This is an automated email from the ASF dual-hosted git repository.

janh pushed a commit to branch branch-2.1
in repository https://gitbox.apache.org/repos/asf/hbase.git


The following commit(s) were added to refs/heads/branch-2.1 by this push:
     new ecd7e0f  HBASE-23645 Fixed remaining Checkstyle violations in hbase-common tests
ecd7e0f is described below

commit ecd7e0fc2cc5beb9a8f9dcfc879e009d3194cda2
Author: Jan Hentschel <janh@apache.org>
AuthorDate: Tue Jan 7 08:54:04 2020 +0100

    HBASE-23645 Fixed remaining Checkstyle violations in hbase-common tests
    
    Signed-off-by: Viraj Jasani <vjasani@apache.org>
---
 .../resources/hbase/checkstyle-suppressions.xml    |   6 +-
 .../java/org/apache/hadoop/hbase/TestKeyValue.java | 217 ++++++++++-----------
 .../java/org/apache/hadoop/hbase/TestTimeout.java  |  43 ++--
 .../test/java/org/apache/hadoop/hbase/Waiter.java  |  25 +--
 .../hadoop/hbase/types/TestCopyOnWriteMaps.java    | 106 +++++-----
 5 files changed, 187 insertions(+), 210 deletions(-)

diff --git a/hbase-checkstyle/src/main/resources/hbase/checkstyle-suppressions.xml b/hbase-checkstyle/src/main/resources/hbase/checkstyle-suppressions.xml
index 4e44081..a5ddb1a 100644
--- a/hbase-checkstyle/src/main/resources/hbase/checkstyle-suppressions.xml
+++ b/hbase-checkstyle/src/main/resources/hbase/checkstyle-suppressions.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <!DOCTYPE suppressions PUBLIC
-    "-//Checkstyle//DTD SuppressionFilter Configuration 1.2//EN"
-    "https://checkstyle.org/dtds/suppressions_1_2.dtd">
+        "-//Checkstyle//DTD SuppressionFilter Configuration 1.2//EN"
+        "https://checkstyle.org/dtds/suppressions_1_2.dtd">
 <!--
 /**
  * Licensed to the Apache Software Foundation (ASF) under one
@@ -42,4 +42,6 @@
   <suppress checks="IllegalImport" message="org\.apache\.htrace\.core"/>
   <suppress checks="ImportOrder" message="Extra separation in import group before"/>
   <suppress checks="MethodLength" files="org.apache.hadoop.hbase.thrift.DemoClient.java"/>
+  <suppress checks="InnerAssignment" files="org.apache.hadoop.hbase.Waiter"/>
+  <suppress checks="EmptyBlock" files="org.apache.hadoop.hbase.TestTimeout"/>
 </suppressions>
diff --git a/hbase-common/src/test/java/org/apache/hadoop/hbase/TestKeyValue.java b/hbase-common/src/test/java/org/apache/hadoop/hbase/TestKeyValue.java
index b867c16..305c524 100644
--- a/hbase-common/src/test/java/org/apache/hadoop/hbase/TestKeyValue.java
+++ b/hbase-common/src/test/java/org/apache/hadoop/hbase/TestKeyValue.java
@@ -30,7 +30,6 @@ import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
-import java.io.IOException;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
@@ -40,14 +39,12 @@ import java.util.TreeSet;
 import org.apache.hadoop.hbase.testclassification.SmallTests;
 import org.apache.hadoop.hbase.util.ByteBufferUtils;
 import org.apache.hadoop.hbase.util.Bytes;
-import org.junit.Assert;
 import org.junit.ClassRule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-
 @Category(SmallTests.class)
 public class TestKeyValue {
   @ClassRule
@@ -56,12 +53,12 @@ public class TestKeyValue {
   private static final Logger LOG = LoggerFactory.getLogger(TestKeyValue.class);
 
   @Test
-  public void testColumnCompare() throws Exception {
-    final byte [] a = Bytes.toBytes("aaa");
-    byte [] family1 = Bytes.toBytes("abc");
-    byte [] qualifier1 = Bytes.toBytes("def");
-    byte [] family2 = Bytes.toBytes("abcd");
-    byte [] qualifier2 = Bytes.toBytes("ef");
+  public void testColumnCompare() {
+    final byte[] a = Bytes.toBytes("aaa");
+    byte[] family1 = Bytes.toBytes("abc");
+    byte[] qualifier1 = Bytes.toBytes("def");
+    byte[] family2 = Bytes.toBytes("abcd");
+    byte[] qualifier2 = Bytes.toBytes("ef");
 
     KeyValue aaa = new KeyValue(a, family1, qualifier1, 0L, KeyValue.Type.Put, a);
     assertFalse(CellUtil.matchingColumn(aaa, family2, qualifier2));
@@ -69,30 +66,29 @@ public class TestKeyValue {
     aaa = new KeyValue(a, family2, qualifier2, 0L, KeyValue.Type.Put, a);
     assertFalse(CellUtil.matchingColumn(aaa, family1, qualifier1));
     assertTrue(CellUtil.matchingColumn(aaa, family2,qualifier2));
-    byte [] nullQualifier = new byte[0];
+    byte[] nullQualifier = new byte[0];
     aaa = new KeyValue(a, family1, nullQualifier, 0L, KeyValue.Type.Put, a);
     assertTrue(CellUtil.matchingColumn(aaa, family1,null));
     assertFalse(CellUtil.matchingColumn(aaa, family2,qualifier2));
   }
 
   /**
-   * Test a corner case when the family qualifier is a prefix of the
-   *  column qualifier.
+   * Test a corner case when the family qualifier is a prefix of the column qualifier.
    */
   @Test
-  public void testColumnCompare_prefix() throws Exception {
-    final byte [] a = Bytes.toBytes("aaa");
-    byte [] family1 = Bytes.toBytes("abc");
-    byte [] qualifier1 = Bytes.toBytes("def");
-    byte [] family2 = Bytes.toBytes("ab");
-    byte [] qualifier2 = Bytes.toBytes("def");
+  public void testColumnCompare_prefix() {
+    final byte[] a = Bytes.toBytes("aaa");
+    byte[] family1 = Bytes.toBytes("abc");
+    byte[] qualifier1 = Bytes.toBytes("def");
+    byte[] family2 = Bytes.toBytes("ab");
+    byte[] qualifier2 = Bytes.toBytes("def");
 
     KeyValue aaa = new KeyValue(a, family1, qualifier1, 0L, KeyValue.Type.Put, a);
     assertFalse(CellUtil.matchingColumn(aaa, family2, qualifier2));
   }
 
   @Test
-  public void testBasics() throws Exception {
+  public void testBasics() {
     LOG.info("LOWKEY: " + KeyValue.LOWESTKEY.toString());
     String name = "testBasics";
     check(Bytes.toBytes(name),
@@ -119,11 +115,11 @@ public class TestKeyValue {
   }
 
   @Test
-  public void testPlainCompare() throws Exception {
-    final byte [] a = Bytes.toBytes("aaa");
-    final byte [] b = Bytes.toBytes("bbb");
-    final byte [] fam = Bytes.toBytes("col");
-    final byte [] qf = Bytes.toBytes("umn");
+  public void testPlainCompare() {
+    final byte[] a = Bytes.toBytes("aaa");
+    final byte[] b = Bytes.toBytes("bbb");
+    final byte[] fam = Bytes.toBytes("col");
+    final byte[] qf = Bytes.toBytes("umn");
     KeyValue aaa = new KeyValue(a, fam, qf, a);
     KeyValue bbb = new KeyValue(b, fam, qf, b);
     assertTrue(CellComparatorImpl.COMPARATOR.compare(aaa, bbb) < 0);
@@ -147,7 +143,7 @@ public class TestKeyValue {
   }
 
   @Test
-  public void testMoreComparisons() throws Exception {
+  public void testMoreComparisons() {
     long now = System.currentTimeMillis();
 
     // Meta compares
@@ -189,10 +185,9 @@ public class TestKeyValue {
   /**
    * Tests cases where rows keys have characters below the ','.
    * See HBASE-832
-   * @throws IOException
    */
   @Test
-  public void testKeyValueBorderCases() throws IOException {
+  public void testKeyValueBorderCases() {
     // % sorts before , so if we don't do special comparator, rowB would
     // come before rowA.
     KeyValue rowA = new KeyValue(Bytes.toBytes("testtable,www.hbase.org/,1234"),
@@ -206,7 +201,6 @@ public class TestKeyValue {
     rowB = new KeyValue(Bytes.toBytes("testtable,$www.hbase.org/,99999"),
         Bytes.toBytes("fam"), Bytes.toBytes(""), Long.MAX_VALUE, (byte[])null);
     assertTrue(CellComparatorImpl.META_COMPARATOR.compare(rowA, rowB) < 0);
-
   }
 
   private void metacomparisons(final CellComparatorImpl c) {
@@ -243,12 +237,12 @@ public class TestKeyValue {
   }
 
   @Test
-  public void testBinaryKeys() throws Exception {
+  public void testBinaryKeys() {
     Set<KeyValue> set = new TreeSet<>(CellComparatorImpl.COMPARATOR);
-    final byte [] fam = Bytes.toBytes("col");
-    final byte [] qf = Bytes.toBytes("umn");
-    final byte [] nb = new byte[0];
-    KeyValue [] keys = {new KeyValue(Bytes.toBytes("aaaaa,\u0000\u0000,2"), fam, qf, 2, nb),
+    final byte[] fam = Bytes.toBytes("col");
+    final byte[] qf = Bytes.toBytes("umn");
+    final byte[] nb = new byte[0];
+    KeyValue[] keys = {new KeyValue(Bytes.toBytes("aaaaa,\u0000\u0000,2"), fam, qf, 2, nb),
       new KeyValue(Bytes.toBytes("aaaaa,\u0001,3"), fam, qf, 3, nb),
       new KeyValue(Bytes.toBytes("aaaaa,,1"), fam, qf, 1, nb),
       new KeyValue(Bytes.toBytes("aaaaa,\u1000,5"), fam, qf, 5, nb),
@@ -261,8 +255,8 @@ public class TestKeyValue {
     boolean assertion = false;
     int count = 0;
     try {
-      for (KeyValue k: set) {
-        assertTrue(count++ == k.getTimestamp());
+      for (KeyValue k : set) {
+        assertEquals(count++, k.getTimestamp());
       }
     } catch (java.lang.AssertionError e) {
       // Expected
@@ -273,8 +267,8 @@ public class TestKeyValue {
     set = new TreeSet<>(CellComparatorImpl.META_COMPARATOR);
     Collections.addAll(set, keys);
     count = 0;
-    for (KeyValue k: set) {
-      assertTrue(count++ == k.getTimestamp());
+    for (KeyValue k : set) {
+      assertEquals(count++, k.getTimestamp());
     }
   }
 
@@ -283,7 +277,6 @@ public class TestKeyValue {
     // Test multiple KeyValues in a single blob.
 
     // TODO actually write this test!
-
   }
 
   private final byte[] rowA = Bytes.toBytes("rowA");
@@ -291,19 +284,15 @@ public class TestKeyValue {
 
   private final byte[] family = Bytes.toBytes("family");
   private final byte[] qualA = Bytes.toBytes("qfA");
-  private final byte[] qualB = Bytes.toBytes("qfB");
 
-  private void assertKVLess(CellComparator c,
-                            KeyValue less,
-                            KeyValue greater) {
+  private void assertKVLess(CellComparator c, KeyValue less, KeyValue greater) {
     int cmp = c.compare(less,greater);
     assertTrue(cmp < 0);
     cmp = c.compare(greater,less);
     assertTrue(cmp > 0);
   }
 
-  private void assertKVLessWithoutRow(CellComparator c, int common, KeyValue less,
-      KeyValue greater) {
+  private void assertKVLessWithoutRow(CellComparator c, KeyValue less, KeyValue greater)
{
     int cmp = c.compare(less, greater);
     assertTrue(cmp < 0);
     cmp = c.compare(greater, less);
@@ -336,12 +325,12 @@ public class TestKeyValue {
     KeyValue kv1_0 = new KeyValue(row, fami1, qual0, ts, KeyValue.Type.Put);
 
     // 'fami:qf1' < 'fami:qf2'
-    assertKVLessWithoutRow(c, 0, kv0_1, kv0_2);
+    assertKVLessWithoutRow(c, kv0_1, kv0_2);
     // 'fami:qf1' < 'fami1:'
-    assertKVLessWithoutRow(c, 0, kv0_1, kv1_0);
+    assertKVLessWithoutRow(c, kv0_1, kv1_0);
 
     // Test comparison by skipping the same prefix bytes.
-    /***
+    /*
      * KeyValue Format and commonLength:
      * |_keyLen_|_valLen_|_rowLen_|_rowKey_|_famiLen_|_fami_|_Quali_|....
      * ------------------|-------commonLength--------|--------------
@@ -349,13 +338,13 @@ public class TestKeyValue {
     int commonLength = KeyValue.ROW_LENGTH_SIZE + KeyValue.FAMILY_LENGTH_SIZE
         + row.length;
     // 'fa:' < 'fami:'. They have commonPrefix + 2 same prefix bytes.
-    assertKVLessWithoutRow(c, commonLength + 2, kv_0, kv0_0);
+    assertKVLessWithoutRow(c, kv_0, kv0_0);
     // 'fami:' < 'fami:qf1'. They have commonPrefix + 4 same prefix bytes.
-    assertKVLessWithoutRow(c, commonLength + 4, kv0_0, kv0_1);
+    assertKVLessWithoutRow(c, kv0_0, kv0_1);
     // 'fami:qf1' < 'fami1:'. They have commonPrefix + 4 same prefix bytes.
-    assertKVLessWithoutRow(c, commonLength + 4, kv0_1, kv1_0);
+    assertKVLessWithoutRow(c, kv0_1, kv1_0);
     // 'fami:qf1' < 'fami:qf2'. They have commonPrefix + 6 same prefix bytes.
-    assertKVLessWithoutRow(c, commonLength + 6, kv0_1, kv0_2);
+    assertKVLessWithoutRow(c, kv0_1, kv0_2);
   }
 
   @Test
@@ -406,12 +395,12 @@ public class TestKeyValue {
   }
 
   @Test
-  public void testCreateKeyOnly() throws Exception {
+  public void testCreateKeyOnly() {
     long ts = 1;
-    byte [] value = Bytes.toBytes("a real value");
-    byte [] evalue = new byte[0]; // empty value
+    byte[] value = Bytes.toBytes("a real value");
+    byte[] evalue = new byte[0]; // empty value
 
-    for (byte[] val : new byte[][]{value, evalue}) {
+    for (byte[] val : new byte[][] { value, evalue }) {
       for (boolean useLen : new boolean[]{false,true}) {
         KeyValue kv1 = new KeyValue(rowA, family, qualA, ts, val);
         KeyValue kv1ko = kv1.createKeyOnly(useLen);
@@ -472,7 +461,8 @@ public class TestKeyValue {
     byte[] metaValue1 = Bytes.toBytes("metaValue1");
     byte[] metaValue2 = Bytes.toBytes("metaValue2");
     KeyValue kv = new KeyValue(row, cf, q, HConstants.LATEST_TIMESTAMP, value, new Tag[]
{
-        new ArrayBackedTag((byte) 1, metaValue1), new ArrayBackedTag((byte) 2, metaValue2)
});
+      new ArrayBackedTag((byte) 1, metaValue1), new ArrayBackedTag((byte) 2, metaValue2)
+    });
     assertTrue(kv.getTagsLength() > 0);
     assertTrue(Bytes.equals(kv.getRowArray(), kv.getRowOffset(), kv.getRowLength(), row,
0,
       row.length));
@@ -500,7 +490,7 @@ public class TestKeyValue {
     assertTrue(meta1Ok);
     assertTrue(meta2Ok);
     Iterator<Tag> tagItr = PrivateCellUtil.tagsIterator(kv);
-    //Iterator<Tag> tagItr = kv.tagsIterator();
+
     assertTrue(tagItr.hasNext());
     Tag next = tagItr.next();
     assertEquals(10, next.getValueLength());
@@ -574,7 +564,7 @@ public class TestKeyValue {
   }
 
   @Test
-  public void testEqualsAndHashCode() throws Exception {
+  public void testEqualsAndHashCode() {
     KeyValue kvA1 = new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"),
         Bytes.toBytes("qualA"), Bytes.toBytes("1"));
     KeyValue kvA2 = new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"),
@@ -589,24 +579,24 @@ public class TestKeyValue {
     assertNotEquals(kvA1, kvB);
     assertEquals(kvA1.hashCode(), kvA2.hashCode());
     assertNotEquals(kvA1.hashCode(), kvB.hashCode());
-
   }
 
   @Test
   public void testKeyValueSerialization() throws Exception {
     KeyValue[] keyValues = new KeyValue[] {
-        new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"), Bytes.toBytes("qualA"),
+      new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"), Bytes.toBytes("qualA"),
             Bytes.toBytes("1")),
-        new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"), Bytes.toBytes("qualA"),
+      new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"), Bytes.toBytes("qualA"),
             Bytes.toBytes("2")),
-        new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"), Bytes.toBytes("qualA"),
+      new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"), Bytes.toBytes("qualA"),
             System.currentTimeMillis(), Bytes.toBytes("2"),
-            new Tag[] { new ArrayBackedTag((byte) 120, "tagA"),
-                new ArrayBackedTag((byte) 121, Bytes.toBytes("tagB")) }),
-        new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"), Bytes.toBytes("qualA"),
+            new Tag[] {
+              new ArrayBackedTag((byte) 120, "tagA"),
+              new ArrayBackedTag((byte) 121, Bytes.toBytes("tagB")) }),
+      new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"), Bytes.toBytes("qualA"),
             System.currentTimeMillis(), Bytes.toBytes("2"),
             new Tag[] { new ArrayBackedTag((byte) 0, "tagA") }),
-        new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"), Bytes.toBytes(""),
+      new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"), Bytes.toBytes(""),
             Bytes.toBytes("1")) };
     ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
     for (KeyValue kv : keyValues) {
@@ -627,11 +617,11 @@ public class TestKeyValue {
 
   @Test
   public void testNullByteArrayKeyValueFailure() {
-    //can't add to testCheckKeyValueBytesFailureCase because it
-    //goes through the InputStream KeyValue API which can't produce a null buffer
+    // can't add to testCheckKeyValueBytesFailureCase because it
+    // goes through the InputStream KeyValue API which can't produce a null buffer
     try {
-      KeyValue kv = new KeyValue(null, 0, 0);
-    } catch (IllegalArgumentException iae){
+      new KeyValue(null, 0, 0);
+    } catch (IllegalArgumentException iae) {
       assertEquals("Invalid to have null byte array in KeyValue.", iae.getMessage());
       return;
     }
@@ -670,22 +660,22 @@ public class TestKeyValue {
   @Test
   public void testCheckKeyValueBytesFailureCase() throws Exception {
     byte[][] inputs = new byte[][] { HConstants.EMPTY_BYTE_ARRAY, // case.0
-        Bytes.toBytesBinary("a"), // case.1
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x01"), // case.2
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x01\\x00"), // case.3
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01"), // case.4
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01\\x00"), // case.5
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01\\x00\\x01"), // case.6
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01\\x00\\x03ROW"), //
case.7
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01"),
// case.8
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\xFF"
-            + "\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\x03"), // case.9
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
-            + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x03"), // case.10
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
-            + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04"), // case.11
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
-            + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04VALUE"), // case.12
+      Bytes.toBytesBinary("a"), // case.1
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x01"), // case.2
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x01\\x00"), // case.3
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01"), // case.4
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01\\x00"), // case.5
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01\\x00\\x01"), // case.6
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01\\x00\\x03ROW"), // case.7
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01"),
// case.8
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\xFF"
+          + "\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\x03"), // case.9
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
+          + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x03"), // case.10
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
+          + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04"), // case.11
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
+          + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04VALUE"), // case.12
     };
     String[] outputs = new String[] { "Overflow when reading key length at position=0",
       "Overflow when reading key length at position=0",
@@ -699,34 +689,35 @@ public class TestKeyValue {
       "Invalid type in KeyValue, type=3", "Overflow when reading value part at position=25",
       "Invalid tags length in KeyValue at position=26"};
     byte[][] withTagsInputs = new byte[][] {
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
-            + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x01"), // case.13
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
-            + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x01"), // case.14
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
-            + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x04\\x00\\x03\\x00A"), //
case.15
-        // case.16
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
-            + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x0A\\x00\\x04\\x00TAG\\x00\\x04"
-            + "\\xFFT"),
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
-            + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x0C\\x00\\x04\\x00TAG\\x00\\x05"
-            + "\\xF0COME\\x00"), // case.17
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
-            + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x0C\\x00\\x04\\x00TAG\\x00\\x05"
-            + "\\xF0COME"), // case.18
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
-            + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x00"), // case.19
-        Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
-            + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x1B\\x00\\x05\\x01TAG1\\x00\\x05"
-            + "\\x02TAG2\\x00\\x05\\x03TAG3\\x00\\x05\\x04TAG4"), // case.20
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
+          + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x01"), // case.13
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
+          + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x01"), // case.14
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
+          + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x04\\x00\\x03\\x00A"), // case.15
+      // case.16
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
+          + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x0A\\x00\\x04\\x00TAG\\x00\\x04"
+          + "\\xFFT"),
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
+          + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x0C\\x00\\x04\\x00TAG\\x00\\x05"
+          + "\\xF0COME\\x00"), // case.17
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
+          + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x0C\\x00\\x04\\x00TAG\\x00\\x05"
+          + "\\xF0COME"), // case.18
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
+          + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x00"), // case.19
+      Bytes.toBytesBinary("\\x00\\x00\\x00\\x11\\x00\\x00\\x00\\x01\\x00\\x03ROW\\x01FQ\\x00"
+          + "\\x00\\x00\\x00\\x00\\x00\\x00\\x01\\x04V\\x00\\x1B\\x00\\x05\\x01TAG1\\x00\\x05"
+          + "\\x02TAG2\\x00\\x05\\x03TAG3\\x00\\x05\\x04TAG4"), // case.20
     };
     String[] withTagsOutputs = new String[] { "Overflow when reading tags length at position=26",
-        "Invalid tags length in KeyValue at position=26",
-        "Invalid tag length at position=28, tagLength=3",
-        "Invalid tag length at position=34, tagLength=4",
-        "Some redundant bytes in KeyValue's buffer, startOffset=41, endOffset=42", null,
null,
-        null, };
+      "Invalid tags length in KeyValue at position=26",
+      "Invalid tag length at position=28, tagLength=3",
+      "Invalid tag length at position=34, tagLength=4",
+      "Some redundant bytes in KeyValue's buffer, startOffset=41, endOffset=42", null, null,
+      null,
+    };
     assertEquals(inputs.length, outputs.length);
     assertEquals(withTagsInputs.length, withTagsOutputs.length);
 
@@ -749,7 +740,7 @@ public class TestKeyValue {
         KeyValueUtil.createKeyValueFromInputStream(
           new DataInputStream(new ByteArrayInputStream(baos.toByteArray())), c.withTags);
         if (c.expectedMessage != null) {
-          Assert.fail("Should fail when parse kv from an invalid bytes, case#" + i + ". "
+ c);
+          fail("Should fail when parse kv from an invalid bytes, case#" + i + ". " + c);
         }
       } catch (IllegalArgumentException e) {
         assertEquals("Case#" + i + " failed," + c, c.getExpectedMessage(), e.getMessage());
diff --git a/hbase-common/src/test/java/org/apache/hadoop/hbase/TestTimeout.java b/hbase-common/src/test/java/org/apache/hadoop/hbase/TestTimeout.java
index 59420eb..96aa5e5 100644
--- a/hbase-common/src/test/java/org/apache/hadoop/hbase/TestTimeout.java
+++ b/hbase-common/src/test/java/org/apache/hadoop/hbase/TestTimeout.java
@@ -23,33 +23,34 @@ import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
-@Category({SmallTests.class})
+@Category(SmallTests.class)
 public class TestTimeout {
 
   @ClassRule
   public static final HBaseClassTestRule CLASS_RULE =
       HBaseClassTestRule.forClass(TestTimeout.class);
 
-    @Test
-    public void run1() throws InterruptedException {
-      Thread.sleep(100);
-    }
+  @Test
+  public void run1() throws InterruptedException {
+    Thread.sleep(100);
+  }
 
-    /**
-     * Enable to check if timeout works.
-     * Can't enable as it waits 30seconds and expected doesn't do Exception catching
-     */
-    @Ignore @Test
-    public void infiniteLoop() {
-      // Launch a background non-daemon thread.
-      Thread t = new Thread("HangingThread") {
-        public void run() {
-          synchronized(this) {
-            while(true) {}
-          }
+  /**
+   * Enable to check if timeout works.
+   * Can't enable as it waits 30seconds and expected doesn't do Exception catching
+   */
+  @Ignore
+  @Test
+  public void infiniteLoop() {
+    // Launch a background non-daemon thread.
+    Thread t = new Thread("HangingThread") {
+      public void run() {
+        synchronized(this) {
+          while (true) {}
         }
-      };
-      t.start();
-      while (true) {}
-   }
+      }
+    };
+    t.start();
+    while (true) {}
+  }
 }
diff --git a/hbase-common/src/test/java/org/apache/hadoop/hbase/Waiter.java b/hbase-common/src/test/java/org/apache/hadoop/hbase/Waiter.java
index 15ecefe..5302093 100644
--- a/hbase-common/src/test/java/org/apache/hadoop/hbase/Waiter.java
+++ b/hbase-common/src/test/java/org/apache/hadoop/hbase/Waiter.java
@@ -16,7 +16,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.apache.hadoop.hbase;
 
 import static org.junit.Assert.fail;
@@ -34,7 +33,6 @@ import org.slf4j.LoggerFactory;
  */
 @InterfaceAudience.Private
 public final class Waiter {
-
   private static final Logger LOG = LoggerFactory.getLogger(Waiter.class);
 
   /**
@@ -87,14 +85,12 @@ public final class Waiter {
    */
   @InterfaceAudience.Private
   public interface Predicate<E extends Exception> {
-
     /**
      * Perform a predicate evaluation.
      * @return the boolean result of the evaluation.
-     * @throws Exception thrown if the predicate evaluation could not evaluate.
+     * @throws E thrown if the predicate evaluation could not evaluate.
      */
     boolean evaluate() throws E;
-
   }
 
   /**
@@ -102,14 +98,12 @@ public final class Waiter {
    */
   @InterfaceAudience.Private
   public interface ExplainingPredicate<E extends Exception> extends Predicate<E>
{
-
     /**
      * Perform a predicate evaluation.
      *
      * @return explanation of failed state
      */
     String explainFailure() throws E;
-
   }
 
   /**
@@ -139,7 +133,7 @@ public final class Waiter {
    *         wait is interrupted otherwise <code>-1</code> when times out
    */
   public static <E extends Exception> long waitFor(Configuration conf, long timeout,
-      Predicate<E> predicate) throws E {
+      Predicate<E> predicate) {
     return waitFor(conf, timeout, 100, true, predicate);
   }
 
@@ -157,7 +151,7 @@ public final class Waiter {
    *         wait is interrupted otherwise <code>-1</code> when times out
    */
   public static <E extends Exception> long waitFor(Configuration conf, long timeout,
long interval,
-      Predicate<E> predicate) throws E {
+      Predicate<E> predicate) {
     return waitFor(conf, timeout, interval, true, predicate);
   }
 
@@ -176,14 +170,14 @@ public final class Waiter {
    *         wait is interrupted otherwise <code>-1</code> when times out
    */
   public static <E extends Exception> long waitFor(Configuration conf, long timeout,
long interval,
-      boolean failIfTimeout, Predicate<E> predicate) throws E {
+      boolean failIfTimeout, Predicate<E> predicate) {
     long started = System.currentTimeMillis();
     long adjustedTimeout = (long) (getWaitForRatio(conf) * timeout);
     long mustEnd = started + adjustedTimeout;
-    long remainderWait = 0;
-    long sleepInterval = 0;
-    Boolean eval = false;
-    Boolean interrupted = false;
+    long remainderWait;
+    long sleepInterval;
+    boolean eval;
+    boolean interrupted = false;
 
     try {
       LOG.info(MessageFormat.format("Waiting up to [{0}] milli-secs(wait.for.ratio=[{1}])",
@@ -192,7 +186,7 @@ public final class Waiter {
               && (remainderWait = mustEnd - System.currentTimeMillis()) > 0) {
         try {
           // handle tail case when remainder wait is less than one interval
-          sleepInterval = (remainderWait > interval) ? interval : remainderWait;
+          sleepInterval = Math.min(remainderWait, interval);
           Thread.sleep(sleepInterval);
         } catch (InterruptedException e) {
           eval = predicate.evaluate();
@@ -232,5 +226,4 @@ public final class Waiter {
       return "";
     }
   }
-
 }
diff --git a/hbase-common/src/test/java/org/apache/hadoop/hbase/types/TestCopyOnWriteMaps.java
b/hbase-common/src/test/java/org/apache/hadoop/hbase/types/TestCopyOnWriteMaps.java
index e3c8980..690447f 100644
--- a/hbase-common/src/test/java/org/apache/hadoop/hbase/types/TestCopyOnWriteMaps.java
+++ b/hbase-common/src/test/java/org/apache/hadoop/hbase/types/TestCopyOnWriteMaps.java
@@ -35,9 +35,8 @@ import org.junit.ClassRule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
-@Category({MiscTests.class, SmallTests.class})
+@Category({ MiscTests.class, SmallTests.class })
 public class TestCopyOnWriteMaps {
-
   @ClassRule
   public static final HBaseClassTestRule CLASS_RULE =
       HBaseClassTestRule.forClass(TestCopyOnWriteMaps.class);
@@ -51,7 +50,7 @@ public class TestCopyOnWriteMaps {
     m = new CopyOnWriteArrayMap<>();
     csm = new ConcurrentSkipListMap<>();
 
-    for (  long i = 0 ; i < 10000; i++ ) {
+    for (long i = 0 ; i < 10000; i++) {
       long o = ThreadLocalRandom.current().nextLong(MAX_RAND);
       m.put(i, o);
       csm.put(i,o);
@@ -62,12 +61,12 @@ public class TestCopyOnWriteMaps {
   }
 
   @Test
-  public void testSize() throws Exception {
+  public void testSize() {
     assertEquals("Size should always be equal", m.size(), csm.size());
   }
 
   @Test
-  public void testIsEmpty() throws Exception {
+  public void testIsEmpty() {
     m.clear();
     assertTrue(m.isEmpty());
     m.put(100L, 100L);
@@ -77,7 +76,7 @@ public class TestCopyOnWriteMaps {
   }
 
   @Test
-  public void testFindOnEmpty() throws Exception {
+  public void testFindOnEmpty() {
     m.clear();
     assertTrue(m.isEmpty());
     assertNull(m.get(100L));
@@ -85,81 +84,77 @@ public class TestCopyOnWriteMaps {
     assertEquals(0, m.tailMap(100L).entrySet().size());
   }
 
-
   @Test
-  public void testLowerKey() throws Exception {
-
+  public void testLowerKey() {
     assertEquals(csm.lowerKey(400L), m.lowerKey(400L));
     assertEquals(csm.lowerKey(-1L), m.lowerKey(-1L));
 
-    for ( int i =0 ; i < 100; i ++) {
+    for (int i = 0 ; i < 100; i++) {
       Long key = ThreadLocalRandom.current().nextLong();
       assertEquals(csm.lowerKey(key), m.lowerKey(key));
     }
   }
 
   @Test
-  public void testFloorEntry() throws Exception {
-    for ( int i =0 ; i < 100; i ++) {
+  public void testFloorEntry() {
+    for (int i = 0 ; i < 100; i++) {
       Long key = ThreadLocalRandom.current().nextLong();
       assertEquals(csm.floorEntry(key), m.floorEntry(key));
     }
   }
 
   @Test
-  public void testFloorKey() throws Exception {
-    for ( int i =0 ; i < 100; i ++) {
+  public void testFloorKey() {
+    for (int i = 0 ; i < 100; i++) {
       Long key = ThreadLocalRandom.current().nextLong();
       assertEquals(csm.floorKey(key), m.floorKey(key));
     }
   }
 
   @Test
-  public void testCeilingKey() throws Exception {
-
+  public void testCeilingKey() {
     assertEquals(csm.ceilingKey(4000L), m.ceilingKey(4000L));
     assertEquals(csm.ceilingKey(400L), m.ceilingKey(400L));
     assertEquals(csm.ceilingKey(-1L), m.ceilingKey(-1L));
 
-    for ( int i =0 ; i < 100; i ++) {
+    for (int i = 0 ; i < 100; i++) {
       Long key = ThreadLocalRandom.current().nextLong();
       assertEquals(csm.ceilingKey(key), m.ceilingKey(key));
     }
   }
 
   @Test
-  public void testHigherKey() throws Exception {
-
+  public void testHigherKey() {
     assertEquals(csm.higherKey(4000L), m.higherKey(4000L));
     assertEquals(csm.higherKey(400L), m.higherKey(400L));
     assertEquals(csm.higherKey(-1L), m.higherKey(-1L));
 
-    for ( int i =0 ; i < 100; i ++) {
+    for (int i = 0 ; i < 100; i++) {
       Long key = ThreadLocalRandom.current().nextLong();
       assertEquals(csm.higherKey(key), m.higherKey(key));
     }
   }
 
   @Test
-  public void testRemove() throws Exception {
-    for (Map.Entry<Long, Long> e:csm.entrySet()) {
+  public void testRemove() {
+    for (Map.Entry<Long, Long> e : csm.entrySet()) {
       assertEquals(csm.remove(e.getKey()), m.remove(e.getKey()));
-      assertEquals(null, m.remove(e.getKey()));
+      assertNull(m.remove(e.getKey()));
     }
   }
 
   @Test
-  public void testReplace() throws Exception {
-    for (Map.Entry<Long, Long> e:csm.entrySet()) {
+  public void testReplace() {
+    for (Map.Entry<Long, Long> e : csm.entrySet()) {
       Long newValue = ThreadLocalRandom.current().nextLong();
       assertEquals(csm.replace(e.getKey(), newValue), m.replace(e.getKey(), newValue));
     }
-    assertEquals(null, m.replace(MAX_RAND + 100L, ThreadLocalRandom.current().nextLong()));
+    assertNull(m.replace(MAX_RAND + 100L, ThreadLocalRandom.current().nextLong()));
   }
 
   @Test
-  public void testReplace1() throws Exception {
-    for (Map.Entry<Long, Long> e: csm.entrySet()) {
+  public void testReplace1() {
+    for (Map.Entry<Long, Long> e : csm.entrySet()) {
       Long newValue = ThreadLocalRandom.current().nextLong();
       assertEquals(csm.replace(e.getKey(), e.getValue() + 1, newValue),
           m.replace(e.getKey(), e.getValue() + 1, newValue));
@@ -168,21 +163,17 @@ public class TestCopyOnWriteMaps {
       assertEquals(newValue, m.get(e.getKey()));
       assertEquals(csm.get(e.getKey()), m.get(e.getKey()));
     }
-    assertEquals(null, m.replace(MAX_RAND + 100L, ThreadLocalRandom.current().nextLong()));
+    assertNull(m.replace(MAX_RAND + 100L, ThreadLocalRandom.current().nextLong()));
   }
 
   @Test
   public void testMultiAdd() throws InterruptedException {
-
     Thread[] threads = new Thread[10];
-    for ( int i =0 ; i<threads.length; i++) {
-      threads[i] = new Thread(new Runnable() {
-        @Override
-        public void run() {
-          for ( int j = 0; j < 5000; j++) {
-            m.put(ThreadLocalRandom.current().nextLong(),
-                ThreadLocalRandom.current().nextLong());
-          }
+    for (int i = 0 ; i < threads.length; i++) {
+      threads[i] = new Thread(() -> {
+        for (int j = 0; j < 5000; j++) {
+          m.put(ThreadLocalRandom.current().nextLong(),
+              ThreadLocalRandom.current().nextLong());
         }
       });
     }
@@ -197,33 +188,32 @@ public class TestCopyOnWriteMaps {
   }
 
   @Test
-  public void testFirstKey() throws Exception {
+  public void testFirstKey() {
     assertEquals(csm.firstKey(), m.firstKey());
   }
 
   @Test
-  public void testLastKey() throws Exception {
+  public void testLastKey() {
     assertEquals(csm.lastKey(), m.lastKey());
   }
 
   @Test
-  public void testFirstEntry() throws Exception {
+  public void testFirstEntry() {
     assertEquals(csm.firstEntry().getKey(), m.firstEntry().getKey());
     assertEquals(csm.firstEntry().getValue(), m.firstEntry().getValue());
     assertEquals(csm.firstEntry(), m.firstEntry());
   }
 
   @Test
-  public void testLastEntry() throws Exception {
+  public void testLastEntry() {
     assertEquals(csm.lastEntry().getKey(), m.lastEntry().getKey());
     assertEquals(csm.lastEntry().getValue(), m.lastEntry().getValue());
     assertEquals(csm.lastEntry(), m.lastEntry());
   }
 
   @Test
-  public void testKeys() throws Exception {
-    for (Long key:csm.keySet()) {
-      //assertTrue(m.containsKey(key));
+  public void testKeys() {
+    for (Long key : csm.keySet()) {
       assertNotNull(m.get(key));
       assertNotNull(m.remove(key));
       assertNull(m.get(key));
@@ -231,30 +221,30 @@ public class TestCopyOnWriteMaps {
   }
 
   @Test
-  public void testValues() throws Exception {
-    for (Long value:m.values()) {
-      assertTrue(csm.values().contains(value));
+  public void testValues() {
+    for (Long value : m.values()) {
+      assertTrue(csm.containsValue(value));
       assertTrue(m.containsValue(value));
     }
   }
 
   @Test
-  public void testTailMap() throws Exception {
+  public void testTailMap() {
     Map<Long, Long> fromCsm = csm.tailMap(50L);
     Map<Long, Long> fromM = m.tailMap(50L);
     assertEquals(fromCsm, fromM);
-    for (Long value:m.keySet()) {
+    for (Long value : m.keySet()) {
       assertEquals(csm.tailMap(value), m.tailMap(value));
     }
 
-    for (  long i = 0 ; i < 100; i++ ) {
+    for (long i = 0; i < 100; i++) {
       long o = ThreadLocalRandom.current().nextLong(MAX_RAND);
       assertEquals(csm.tailMap(o), m.tailMap(o));
     }
   }
 
   @Test
-  public void testTailMapExclusive() throws Exception {
+  public void testTailMapExclusive() {
     m.clear();
     m.put(100L, 100L);
     m.put(101L, 101L);
@@ -265,7 +255,7 @@ public class TestCopyOnWriteMaps {
 
     long n = 100L;
     CopyOnWriteArrayMap<Long,Long> tm99 = (CopyOnWriteArrayMap<Long, Long>) m.tailMap(99L,
false);
-    for (Map.Entry<Long,Long> e:tm99.entrySet()) {
+    for (Map.Entry<Long,Long> e : tm99.entrySet()) {
       assertEquals(Long.valueOf(n), e.getKey());
       assertEquals(Long.valueOf(n), e.getValue());
       n++;
@@ -273,7 +263,7 @@ public class TestCopyOnWriteMaps {
   }
 
   @Test
-  public void testTailMapInclusive() throws Exception {
+  public void testTailMapInclusive() {
     m.clear();
     m.put(100L, 100L);
     m.put(101L, 101L);
@@ -284,14 +274,14 @@ public class TestCopyOnWriteMaps {
 
     long n = 102;
     CopyOnWriteArrayMap<Long,Long> tm102 = (CopyOnWriteArrayMap<Long, Long>)
m.tailMap(102L, true);
-    for (Map.Entry<Long,Long> e:tm102.entrySet()) {
+    for (Map.Entry<Long,Long> e : tm102.entrySet()) {
       assertEquals(Long.valueOf(n), e.getKey());
       assertEquals(Long.valueOf(n), e.getValue());
       n++;
     }
     n = 99;
     CopyOnWriteArrayMap<Long,Long> tm98 = (CopyOnWriteArrayMap<Long, Long>) m.tailMap(98L,
true);
-    for (Map.Entry<Long,Long> e:tm98.entrySet()) {
+    for (Map.Entry<Long,Long> e : tm98.entrySet()) {
       assertEquals(Long.valueOf(n), e.getKey());
       assertEquals(Long.valueOf(n), e.getValue());
       n++;
@@ -299,7 +289,7 @@ public class TestCopyOnWriteMaps {
   }
 
   @Test
-  public void testPut() throws Exception {
+  public void testPut() {
     m.clear();
     m.put(100L, 100L);
     m.put(101L, 101L);
@@ -309,7 +299,7 @@ public class TestCopyOnWriteMaps {
     m.put(102L, 102L);
     long n = 99;
 
-    for (Map.Entry<Long, Long> e:m.entrySet()) {
+    for (Map.Entry<Long, Long> e : m.entrySet()) {
       assertEquals(Long.valueOf(n), e.getKey());
       assertEquals(Long.valueOf(n), e.getValue());
       n++;


Mime
View raw message