diff --git a/hbase-checkstyle/src/main/resources/hbase/checkstyle-suppressions.xml b/hbase-checkstyle/src/main/resources/hbase/checkstyle-suppressions.xml index ec6a90ebf64..a229588cdb3 100644 --- a/hbase-checkstyle/src/main/resources/hbase/checkstyle-suppressions.xml +++ b/hbase-checkstyle/src/main/resources/hbase/checkstyle-suppressions.xml @@ -36,6 +36,8 @@ + + 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 729de124b92..e7a2165bce8 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 @@ -25,7 +25,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; @@ -49,12 +48,12 @@ import org.junit.experimental.categories.Category; public class TestKeyValue extends TestCase { private static final Log LOG = LogFactory.getLog(TestKeyValue.class); - 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)); @@ -62,28 +61,27 @@ public class TestKeyValue extends TestCase { 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. */ - 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)); } - public void testBasics() throws Exception { + public void testBasics() { LOG.info("LOWKEY: " + KeyValue.LOWESTKEY.toString()); check(Bytes.toBytes(getName()), Bytes.toBytes(getName()), Bytes.toBytes(getName()), 1, @@ -108,11 +106,11 @@ public class TestKeyValue extends TestCase { LOG.info(kv.toString()); } - 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(KeyValue.COMPARATOR.compare(aaa, bbb) < 0); @@ -135,7 +133,7 @@ public class TestKeyValue extends TestCase { assertTrue(KeyValue.COMPARATOR.compare(aaa, aaa) == 0); } - public void testMoreComparisons() throws Exception { + public void testMoreComparisons() { long now = System.currentTimeMillis(); // Meta compares @@ -176,9 +174,8 @@ public class TestKeyValue extends TestCase { /** * Tests cases where rows keys have characters below the ','. * See HBASE-832 - * @throws IOException */ - 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"), @@ -192,7 +189,6 @@ public class TestKeyValue extends TestCase { rowB = new KeyValue(Bytes.toBytes("testtable,$www.hbase.org/,99999"), Bytes.toBytes("fam"), Bytes.toBytes(""), Long.MAX_VALUE, (byte[])null); assertTrue(KeyValue.META_COMPARATOR.compare(rowA, rowB) < 0); - } private void metacomparisons(final KeyValue.MetaComparator c) { @@ -228,12 +224,12 @@ public class TestKeyValue extends TestCase { Bytes.toBytes(TableName.META_TABLE_NAME.getNameAsString()+",,1"), now)) > 0); } - public void testBinaryKeys() throws Exception { - Set set = new TreeSet(KeyValue.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), + public void testBinaryKeys() { + Set set = new TreeSet<>(KeyValue.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), 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), @@ -246,8 +242,8 @@ public class TestKeyValue extends TestCase { boolean assertion = false; int count = 0; try { - for (KeyValue k: set) { - assertTrue(count++ == k.getTimestamp()); + for (KeyValue k : set) { + assertEquals(count++, k.getTimestamp()); } } catch (junit.framework.AssertionFailedError e) { // Expected @@ -255,11 +251,11 @@ public class TestKeyValue extends TestCase { } assertTrue(assertion); // Make set with good comparator - set = new TreeSet(new KeyValue.MetaComparator()); + set = new TreeSet<>(new KeyValue.MetaComparator()); Collections.addAll(set, keys); count = 0; - for (KeyValue k: set) { - assertTrue(count++ == k.getTimestamp()); + for (KeyValue k : set) { + assertEquals(count++, k.getTimestamp()); } } @@ -268,11 +264,8 @@ public class TestKeyValue extends TestCase { private final byte[] family = Bytes.toBytes("family"); private final byte[] qualA = Bytes.toBytes("qfA"); - private final byte[] qualB = Bytes.toBytes("qfB"); - private void assertKVLess(KeyValue.KVComparator c, - KeyValue less, - KeyValue greater) { + private void assertKVLess(KeyValue.KVComparator c, KeyValue less, KeyValue greater) { int cmp = c.compare(less,greater); assertTrue(cmp < 0); cmp = c.compare(greater,less); @@ -317,7 +310,7 @@ public class TestKeyValue extends TestCase { assertKVLessWithoutRow(c, 0, kv0_1, kv1_0); // Test comparison by skipping the same prefix bytes. - /*** + /* * KeyValue Format and commonLength: * |_keyLen_|_valLen_|_rowLen_|_rowKey_|_famiLen_|_fami_|_Quali_|.... * ------------------|-------commonLength--------|-------------- @@ -380,12 +373,12 @@ public class TestKeyValue extends TestCase { assertKVLess(c, firstOnRowABufferFamQual, lastOnRowA); } - 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); @@ -443,7 +436,8 @@ public class TestKeyValue extends TestCase { byte[] metaValue1 = Bytes.toBytes("metaValue1"); byte[] metaValue2 = Bytes.toBytes("metaValue2"); KeyValue kv = new KeyValue(row, cf, q, HConstants.LATEST_TIMESTAMP, value, new Tag[] { - new Tag((byte) 1, metaValue1), new Tag((byte) 2, metaValue2) }); + new Tag((byte) 1, metaValue1), new Tag((byte) 2, metaValue2) + }); assertTrue(kv.getTagsLength() > 0); assertTrue(Bytes.equals(kv.getRowArray(), kv.getRowOffset(), kv.getRowLength(), row, 0, row.length)); @@ -544,7 +538,7 @@ public class TestKeyValue extends TestCase { assertTrue(c.compare(a, b) < 0); } - 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"), @@ -559,7 +553,6 @@ public class TestKeyValue extends TestCase { assertNotEquals(kvA1, kvB); assertEquals(kvA1.hashCode(), kvA2.hashCode()); assertNotEquals(kvA1.hashCode(), kvB.hashCode()); - } public void testKeyValueSerialization() throws Exception { @@ -570,8 +563,9 @@ public class TestKeyValue extends TestCase { Bytes.toBytes("2")), new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"), Bytes.toBytes("qualA"), System.currentTimeMillis(), Bytes.toBytes("2"), - new Tag[] { new Tag((byte) 120, "tagA"), - new Tag((byte) 121, Bytes.toBytes("tagB")) }), + new Tag[] { + new Tag((byte) 120, "tagA"), + new Tag((byte) 121, Bytes.toBytes("tagB")) }), new KeyValue(Bytes.toBytes("key"), Bytes.toBytes("cf"), Bytes.toBytes("qualA"), System.currentTimeMillis(), Bytes.toBytes("2"), new Tag[] { new Tag((byte) 0, "tagA") }), @@ -595,11 +589,11 @@ public class TestKeyValue extends TestCase { @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; } @@ -638,22 +632,22 @@ public class TestKeyValue extends TestCase { @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", @@ -668,32 +662,34 @@ public class TestKeyValue extends TestCase { "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 + + "\\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 + + "\\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 + + "\\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"), // case.16 + + "\\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 + + "\\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 + + "\\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 + + "\\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 + + "\\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, }; + null, + }; assertEquals(inputs.length, outputs.length); assertEquals(withTagsInputs.length, withTagsOutputs.length); 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 d6ee6739e03..fcc77ae1da2 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 @@ -1,4 +1,4 @@ -/* +/** * 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 @@ -18,31 +18,33 @@ package org.apache.hadoop.hbase; import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.Rule; + import org.junit.Ignore; +import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; import org.junit.rules.TestRule; -import org.junit.rules.Timeout; @Category({SmallTests.class}) public class TestTimeout { - @Rule public final TestRule timeout = CategoryBasedTimeout.builder() + @Rule + public final TestRule timeout = CategoryBasedTimeout.builder() .withTimeout(this.getClass()) .withLookingForStuckThread(true) .build(); - @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() { - 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() { + 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 0972cbd54f7..5b69289d46f 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 java.text.MessageFormat; @@ -25,8 +24,8 @@ import junit.framework.Assert; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.classification.InterfaceAudience; /** * A class that provides a standard waitFor pattern @@ -34,7 +33,6 @@ import org.apache.hadoop.conf.Configuration; */ @InterfaceAudience.Private public final class Waiter { - private static final Log LOG = LogFactory.getLog(Waiter.class); /** @@ -83,18 +81,16 @@ public final class Waiter { /** * A predicate 'closure' used by the {@link Waiter#waitFor(Configuration, long, Predicate)} and * {@link Waiter#waitFor(Configuration, long, Predicate)} and - * {@link Waiter#waitFor(Configuration, long, long, boolean, Predicate) methods. + * {@link Waiter#waitFor(Configuration, long, long, boolean, Predicate)} methods. */ @InterfaceAudience.Private public interface Predicate { - /** * 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 extends Predicate { - /** * 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 -1 when times out */ public static long waitFor(Configuration conf, long timeout, - Predicate predicate) throws E { + Predicate predicate) { return waitFor(conf, timeout, 100, true, predicate); } @@ -157,7 +151,7 @@ public final class Waiter { * wait is interrupted otherwise -1 when times out */ public static long waitFor(Configuration conf, long timeout, long interval, - Predicate predicate) throws E { + Predicate predicate) { return waitFor(conf, timeout, interval, true, predicate); } @@ -176,14 +170,14 @@ public final class Waiter { * wait is interrupted otherwise -1 when times out */ public static long waitFor(Configuration conf, long timeout, long interval, - boolean failIfTimeout, Predicate predicate) throws E { + boolean failIfTimeout, Predicate 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 a3c892a947e..f341a25e7a4 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 @@ -15,24 +15,26 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.apache.hadoop.hbase.types; -import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.Before; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; import java.util.Map; import java.util.concurrent.ConcurrentNavigableMap; import java.util.concurrent.ConcurrentSkipListMap; import java.util.concurrent.ThreadLocalRandom; -import static org.junit.Assert.*; +import org.apache.hadoop.hbase.testclassification.SmallTests; +import org.junit.Before; +import org.junit.Test; +import org.junit.experimental.categories.Category; @Category(SmallTests.class) public class TestCopyOnWriteMaps { - private static final int MAX_RAND = 10 * 1000 * 1000; private ConcurrentNavigableMap m; private ConcurrentSkipListMap csm; @@ -42,7 +44,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); @@ -53,12 +55,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); @@ -68,7 +70,7 @@ public class TestCopyOnWriteMaps { } @Test - public void testFindOnEmpty() throws Exception { + public void testFindOnEmpty() { m.clear(); assertTrue(m.isEmpty()); assertNull(m.get(100L)); @@ -76,81 +78,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 e:csm.entrySet()) { + public void testRemove() { + for (Map.Entry 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 e:csm.entrySet()) { + public void testReplace() { + for (Map.Entry 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 e: csm.entrySet()) { + public void testReplace1() { + for (Map.Entry 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)); @@ -159,18 +157,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 fromCsm = csm.tailMap(50L); Map 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); @@ -256,7 +252,7 @@ public class TestCopyOnWriteMaps { long n = 100L; CopyOnWriteArrayMap tm99 = (CopyOnWriteArrayMap) m.tailMap(99L, false); - for (Map.Entry e:tm99.entrySet()) { + for (Map.Entry e : tm99.entrySet()) { assertEquals(new Long(n), e.getKey()); assertEquals(new Long(n), e.getValue()); n++; @@ -264,7 +260,7 @@ public class TestCopyOnWriteMaps { } @Test - public void testTailMapInclusive() throws Exception { + public void testTailMapInclusive() { m.clear(); m.put(100L, 100L); m.put(101L, 101L); @@ -275,14 +271,14 @@ public class TestCopyOnWriteMaps { long n = 102; CopyOnWriteArrayMap tm102 = (CopyOnWriteArrayMap) m.tailMap(102L, true); - for (Map.Entry e:tm102.entrySet()) { + for (Map.Entry e : tm102.entrySet()) { assertEquals(new Long(n), e.getKey()); assertEquals(new Long(n), e.getValue()); n++; } n = 99; CopyOnWriteArrayMap tm98 = (CopyOnWriteArrayMap) m.tailMap(98L, true); - for (Map.Entry e:tm98.entrySet()) { + for (Map.Entry e : tm98.entrySet()) { assertEquals(new Long(n), e.getKey()); assertEquals(new Long(n), e.getValue()); n++; @@ -290,7 +286,7 @@ public class TestCopyOnWriteMaps { } @Test - public void testPut() throws Exception { + public void testPut() { m.clear(); m.put(100L, 100L); m.put(101L, 101L); @@ -300,12 +296,12 @@ public class TestCopyOnWriteMaps { m.put(102L, 102L); long n = 99; - for (Map.Entry e:m.entrySet()) { + for (Map.Entry e : m.entrySet()) { assertEquals(new Long(n), e.getKey()); assertEquals(new Long(n), e.getValue()); n++; } assertEquals(5, m.size()); - assertEquals(false, m.isEmpty()); + assertFalse(m.isEmpty()); } -} \ No newline at end of file +}