You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hbase.apache.org by ja...@apache.org on 2020/01/07 08:30:49 UTC
[hbase] branch branch-2.2 updated: HBASE-23645 Fixed remaining
Checkstyle violations in hbase-common tests
This is an automated email from the ASF dual-hosted git repository.
janh pushed a commit to branch branch-2.2
in repository https://gitbox.apache.org/repos/asf/hbase.git
The following commit(s) were added to refs/heads/branch-2.2 by this push:
new 6d22b7c HBASE-23645 Fixed remaining Checkstyle violations in hbase-common tests
6d22b7c is described below
commit 6d22b7c255da7bb5d2ad1699e4d7974677b0a8e3
Author: Jan Hentschel <ja...@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 <vj...@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++;