TestFromClientSide (Apache HBase 2.0.6 Test API)

java.lang.Object
- org.apache.hadoop.hbase.client.TestFromClientSide

Direct Known Subclasses:

TestFromClientSideWithCoprocessor
```
public class TestFromClientSide
extends Object
```
Run tests that use the HBase clients; Table. Sets up the HBase mini cluster once at start and runs through all client tests. Each creates a table named for the method and does its stuff against that.

Field Summary

Fields
Modifier and Type	Field and Description
`static HBaseClassTestRule`	`CLASS_RULE`
`private static byte[]`	`FAMILY`
`private static byte[]`	`INVALID_FAMILY`
`private static org.slf4j.Logger`	`LOG`
`org.junit.rules.TestName`	`name`
`private static byte[]`	`QUALIFIER`
`private static byte[]`	`ROW`
`protected static int`	`SLAVES`
`protected static HBaseTestingUtility`	`TEST_UTIL`
`private static byte[]`	`VALUE`

Constructor Summary

Constructors
Constructor and Description

TestFromClientSide()

Constructors
Constructor and Description
`TestFromClientSide()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private void`	`assertDoubleResult(org.apache.hadoop.hbase.client.Result result, byte[] row, byte[] familyA, byte[] qualifierA, byte[] valueA, byte[] familyB, byte[] qualifierB, byte[] valueB)` Validate that result contains two specified keys, exactly.
`private void`	`assertEmptyResult(org.apache.hadoop.hbase.client.Result result)`
`(package private) static void`	`assertIncrementKey(org.apache.hadoop.hbase.Cell key, byte[] row, byte[] family, byte[] qualifier, long value)`
`private void`	`assertKey(org.apache.hadoop.hbase.Cell key, byte[] row, byte[] family, byte[] qualifier, byte[] value)`
`private void`	`assertNResult(org.apache.hadoop.hbase.client.Result result, byte[] row, byte[][] families, byte[][] qualifiers, byte[][] values, int[][] idxs)`
`private void`	`assertNResult(org.apache.hadoop.hbase.client.Result result, byte[] row, byte[] family, byte[] qualifier, long[] stamps, byte[][] values, int start, int end)`
`private void`	`assertNullResult(org.apache.hadoop.hbase.client.Result result)`
`private void`	`assertNumKeys(org.apache.hadoop.hbase.client.Result result, int n)`
`private void`	`assertRowCount(org.apache.hadoop.hbase.client.Table t, int expected)`
`private void`	`assertSingleResult(org.apache.hadoop.hbase.client.Result result, byte[] row, byte[] family, byte[] qualifier, byte[] value)`
`private void`	`assertSingleResult(org.apache.hadoop.hbase.client.Result result, byte[] row, byte[] family, byte[] qualifier, long value)`
`private void`	`assertSingleResult(org.apache.hadoop.hbase.client.Result result, byte[] row, byte[] family, byte[] qualifier, long ts, byte[] value)`
`private org.apache.hadoop.hbase.client.ResultScanner`	`buildScanner(String keyPrefix, String value, org.apache.hadoop.hbase.client.Table ht)`
`private org.apache.hadoop.hbase.client.Scan`	`createScanWithRowFilter(byte[] key)`
`private org.apache.hadoop.hbase.client.Scan`	`createScanWithRowFilter(byte[] key, byte[] startRow, org.apache.hadoop.hbase.CompareOperator op)`
`private void`	`deleteColumns(org.apache.hadoop.hbase.client.Table ht, String value, String keyPrefix)`
`private List<org.apache.hadoop.hbase.client.Result>`	`doAppend(boolean walUsed)`
`(package private) static boolean`	`equals(byte[] left, byte[] right)`
`private void`	`getAllVersionsAndVerify(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] qualifier, long[] stamps, byte[][] values, int start, int end)`
`private int`	`getNumberOfRows(String keyPrefix, String value, org.apache.hadoop.hbase.client.Table ht)`
`private List<org.apache.hadoop.hbase.HRegionLocation>`	`getRegionsInRange(org.apache.hadoop.hbase.TableName tableName, byte[] startKey, byte[] endKey)`
`private org.apache.hadoop.hbase.client.Result`	`getReverseScanResult(org.apache.hadoop.hbase.client.Table table, byte[] row, byte[] fam)`
`private org.apache.hadoop.hbase.client.metrics.ScanMetrics`	`getScanMetrics(org.apache.hadoop.hbase.client.Scan scan)`
`private org.apache.hadoop.hbase.client.Result`	`getSingleScanResult(org.apache.hadoop.hbase.client.Table ht, org.apache.hadoop.hbase.client.Scan scan)`
`private void`	`getTestNull(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] value)`
`private void`	`getTestNull(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, long value)`
`private void`	`getVerifySingleColumn(org.apache.hadoop.hbase.client.Table ht, byte[][] ROWS, int ROWIDX, byte[][] FAMILIES, int FAMILYIDX, byte[][] QUALIFIERS, int QUALIFIERIDX, byte[][] VALUES, int VALUEIDX)` Verify a single column using gets.
`private void`	`getVerifySingleEmpty(org.apache.hadoop.hbase.client.Table ht, byte[][] ROWS, int ROWIDX, byte[][] FAMILIES, int FAMILYIDX, byte[][] QUALIFIERS, int QUALIFIERIDX)` Verify we do not read any values by accident around a single column Same requirements as getVerifySingleColumn
`private void`	`getVersionAndVerify(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] qualifier, long stamp, byte[] value)`
`private void`	`getVersionAndVerifyMissing(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] qualifier, long stamp)`
`private void`	`getVersionRangeAndVerify(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] qualifier, long[] stamps, byte[][] values, int start, int end)`
`private void`	`getVersionRangeAndVerifyGreaterThan(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] qualifier, long[] stamps, byte[][] values, int start, int end)`
`protected static void`	`initialize(Class<?>... cps)`
`private byte[][]`	`makeN(byte[] base, int n)`
`private byte[][]`	`makeNAscii(byte[] base, int n)`
`private byte[][]`	`makeNBig(byte[] base, int n)`
`private long[]`	`makeStamps(int n)`
`private void`	`putRows(org.apache.hadoop.hbase.client.Table ht, int numRows, String value, String key)`
`private void`	`reverseScanTest(org.apache.hadoop.hbase.client.Table table, boolean small)`
`private void`	`scanAllVersionsAndVerify(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] qualifier, long[] stamps, byte[][] values, int start, int end)`
`private void`	`scanTestNull(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] value)`
`private void`	`scanTestNull(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] value, boolean isReversedScan)`
`private void`	`scanVerifySingleColumn(org.apache.hadoop.hbase.client.Table ht, byte[][] ROWS, int ROWIDX, byte[][] FAMILIES, int FAMILYIDX, byte[][] QUALIFIERS, int QUALIFIERIDX, byte[][] VALUES, int VALUEIDX)` Verify a single column using scanners.
`private void`	`scanVerifySingleEmpty(org.apache.hadoop.hbase.client.Table ht, byte[][] ROWS, int ROWIDX, byte[][] FAMILIES, int FAMILYIDX, byte[][] QUALIFIERS, int QUALIFIERIDX)`
`private void`	`scanVersionAndVerify(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] qualifier, long stamp, byte[] value)`
`private void`	`scanVersionAndVerifyMissing(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] qualifier, long stamp)`
`private void`	`scanVersionRangeAndVerify(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] qualifier, long[] stamps, byte[][] values, int start, int end)`
`private void`	`scanVersionRangeAndVerifyGreaterThan(org.apache.hadoop.hbase.client.Table ht, byte[] row, byte[] family, byte[] qualifier, long[] stamps, byte[][] values, int start, int end)`
`static void`	`setUpBeforeClass()`
`private void`	`singleRowGetTest(org.apache.hadoop.hbase.client.Table ht, byte[][] ROWS, byte[][] FAMILIES, byte[][] QUALIFIERS, byte[][] VALUES)`
`private void`	`singleRowScanTest(org.apache.hadoop.hbase.client.Table ht, byte[][] ROWS, byte[][] FAMILIES, byte[][] QUALIFIERS, byte[][] VALUES)`
`private List<org.apache.hadoop.hbase.HRegionLocation>`	`splitTable(org.apache.hadoop.hbase.client.Table t)`
`static void`	`tearDownAfterClass()`
`void`	`testAddKeyValue()`
`void`	`testAppend()`
`void`	`testAppendWithoutWAL()`
`void`	`testBatchAppendWithReturnResultFalse()`
`void`	`testBatchOperationsWithErrors()` Test batch operations with combination of valid and invalid args
`void`	`testCacheOnWriteEvictOnClose()` Tests that cache on write works all the way up from the client-side.
`void`	`testCellSizeLimit()`
`void`	`testCellUtilTypeMethods()`
`void`	`testCheckAndDelete()`
`void`	`testCheckAndDeleteWithCompareOp()`
`void`	`testCheckAndMutateWithTimeRange()`
`void`	`testCheckAndPut()`
`void`	`testCheckAndPutWithCompareOp()`
`void`	`testClientPoolRoundRobin()`
`void`	`testClientPoolThreadLocal()`
`void`	`testCreateTableWithZeroRegionReplicas()`
`void`	`testDeleteFamilyVersion()`
`void`	`testDeleteFamilyVersionWithOtherDeletes()`
`void`	`testDeleteLatestVersionOfSpecifiedColumn()`
`void`	`testDeletes()`
`void`	`testDeleteSpecifiedVersionOfSpecifiedColumn()`
`void`	`testDeletesWithReverseScan()`
`void`	`testDeleteWithFailed()`
`void`	`testDuplicateAppend()` Test append result when there are duplicate rpc request.
`void`	`testDuplicateVersions()`
`void`	`testEmptyFilterList()`
`void`	`testFilterAcrossMultipleRegions()` Test filters when multiple regions.
`void`	`testFilterAllRecords()`
`void`	`testFilters()`
`void`	`testFiltersWithReverseScan()`
`void`	`testFilterWithLongCompartor()`
`void`	`testGet_EmptyTable()`
`void`	`testGet_NonExistentRow()`
`void`	`testGet_NullQualifier()`
`void`	`testGetClosestRowBefore()`
`void`	`testGetConfiguration()` Verifies that getConfiguration returns the same Configuration object used to create the HTable instance.
`void`	`testGetRegionsInRange()`
`void`	`testGetStartEndKeysWithRegionReplicas()`
`void`	`testHBase737()` test for HBASE-737
`void`	`testJira6912()`
`void`	`testJiraTest1014()` HBASE-1014 commit(BatchUpdate) method should return timestamp
`void`	`testJiraTest1182()` HBASE-1182 Scan for columns > some timestamp
`void`	`testJiraTest33()` HBASE-33 Add a HTable get/obtainScanner method that retrieves all versions of a particular column and row between two timestamps
`void`	`testJiraTest52()` HBASE-52 Add a means of scanning over all versions
`void`	`testJiraTest861()` HBASE-861 get with timestamp will return a value if there is a version with an earlier timestamp
`void`	`testJiraTest867()` HBASE-867 If millions of columns in a column family, hbase scanner won't come up Test will create numRows rows, each with numColsPerRow columns (1 version each), and attempt to scan them all.
`void`	`testKeepDeletedCells()` Basic client side validation of HBASE-4536
`void`	`testKeyOnlyFilter()`
`void`	`testKeyOnlyFilterWithReverseScan()`
`void`	`testListTables()`
`void`	`testMajorCompactionBetweenTwoUpdates()`
`void`	`testMaxKeyValueSize()`
`void`	`testMillions()`
`void`	`testMiscHTableStuff()`
`void`	`testModifyTableWithZeroRegionReplicas()`
`void`	`testMultipleRegionsAndBatchPuts()`
`void`	`testMultipleRowMultipleFamily()`
`void`	`testMultiRowMutation()`
`void`	`testNegativeTimestamp()`
`void`	`testNonCachedGetRegionLocation()`
`void`	`testNull()`
`void`	`testNullQualifier()`
`void`	`testNullWithReverseScan()`
`void`	`testPurgeFutureDeletes()` Basic client side validation of HBASE-10118
`void`	`testPut()`
`void`	`testPutNoCF()`
`void`	`testRawScanRespectsVersions()`
`void`	`testReadWithFilter()` Test for HBASE-17125
`void`	`testRegionCache()`
`void`	`testReversedScanUnderMultiRegions()` Tests reversed scan under multi regions
`void`	`testRowMutation()`
`void`	`testRowsPut()`
`void`	`testRowsPutBufferedManyManyFlushes()`
`void`	`testScan_NullQualifier()`
`void`	`testScanMetrics()` Test ScanMetrics
`void`	`testScanVariableReuse()` For HBASE-2156
`void`	`testSimpleMissing()` Test simple table and non-existent row cases.
`void`	`testSimpleMissingWithReverseScan()` Test simple table and non-existent row cases.
`void`	`testSingleRowMultipleFamily()` Test basic puts, gets, scans, and deletes for a single row in a multiple family table.
`void`	`testSmallReversedScanUnderMultiRegions()` Tests reversed scan under multi regions
`void`	`testSmallScan()`
`void`	`testSuperSimple()`
`void`	`testSuperSimpleWithReverseScan()`
`void`	`testUnmanagedHConnection()` simple test that just executes parts of the client API that accept a pre-created Connection instance
`void`	`testUnmanagedHConnectionReconnect()` test of that unmanaged HConnections are able to reconnect properly (see HBASE-5058)
`void`	`testUpdates()`
`void`	`testUpdatesWithMajorCompaction()`
`void`	`testVersionLimits()`
`void`	`testVersions()`
`void`	`testWeirdCacheBehaviour()` Test from client side of an involved filter against a multi family that involves deletes.
`private void`	`waitForStoreFileCount(org.apache.hadoop.hbase.regionserver.HStore store, int count, int timeout)`
`private List<org.apache.hadoop.hbase.HRegionLocation>`	`waitOnSplit(org.apache.hadoop.hbase.client.Table t)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

CLASS_RULE

public static final HBaseClassTestRule CLASS_RULE

LOG

private static final org.slf4j.Logger LOG

TEST_UTIL

protected static final HBaseTestingUtility TEST_UTIL

ROW
```
private static byte[] ROW
```

FAMILY
```
private static byte[] FAMILY
```

INVALID_FAMILY

private static final byte[] INVALID_FAMILY

QUALIFIER
```
private static byte[] QUALIFIER
```

VALUE
```
private static byte[] VALUE
```

SLAVES
```
protected static int SLAVES
```

name
```
public org.junit.rules.TestName name
```

Constructor Detail
- TestFromClientSide
```
public TestFromClientSide()
```

Method Detail

initialize

protected static final void initialize(Class<?>... cps)
                                throws Exception

Throws:: Exception

setUpBeforeClass

public static void setUpBeforeClass()
                             throws Exception

Throws:: Exception

tearDownAfterClass

public static void tearDownAfterClass()
                               throws Exception

Throws:: Exception

testDuplicateAppend
```
public void testDuplicateAppend()
                         throws Exception
```
Test append result when there are duplicate rpc request.

Throws:

Exception

testKeepDeletedCells

public void testKeepDeletedCells()
                          throws Exception

Basic client side validation of HBASE-4536

Throws:: Exception

testPurgeFutureDeletes

public void testPurgeFutureDeletes()
                            throws Exception

Basic client side validation of HBASE-10118

Throws:: Exception

testGetConfiguration
```
public void testGetConfiguration()
                          throws Exception
```
Verifies that getConfiguration returns the same Configuration object used to create the HTable instance.

Throws:

Exception

testWeirdCacheBehaviour
```
public void testWeirdCacheBehaviour()
                             throws Exception
```
Test from client side of an involved filter against a multi family that involves deletes.

Throws:

Exception

deleteColumns

private void deleteColumns(org.apache.hadoop.hbase.client.Table ht,
                           String value,
                           String keyPrefix)
                    throws IOException

Throws:: IOException

getNumberOfRows

private int getNumberOfRows(String keyPrefix,
                            String value,
                            org.apache.hadoop.hbase.client.Table ht)
                     throws Exception

Throws:: Exception

buildScanner

private org.apache.hadoop.hbase.client.ResultScanner buildScanner(String keyPrefix,
                                                                  String value,
                                                                  org.apache.hadoop.hbase.client.Table ht)
                                                           throws IOException

Throws:: IOException

putRows

private void putRows(org.apache.hadoop.hbase.client.Table ht,
                     int numRows,
                     String value,
                     String key)
              throws IOException

Throws:: IOException

testFilterAcrossMultipleRegions
```
public void testFilterAcrossMultipleRegions()
                                     throws IOException,
                                            InterruptedException
```
Test filters when multiple regions. It does counts. Needs eye-balling of logs to ensure that we're not scanning more regions that we're supposed to. Related to the TestFilterAcrossRegions over in the o.a.h.h.filter package.

Throws:

IOException

InterruptedException

createScanWithRowFilter

private org.apache.hadoop.hbase.client.Scan createScanWithRowFilter(byte[] key)

createScanWithRowFilter

private org.apache.hadoop.hbase.client.Scan createScanWithRowFilter(byte[] key,
                                                                    byte[] startRow,
                                                                    org.apache.hadoop.hbase.CompareOperator op)

assertRowCount

private void assertRowCount(org.apache.hadoop.hbase.client.Table t,
                            int expected)
                     throws IOException

Throws:: IOException

splitTable

private List<org.apache.hadoop.hbase.HRegionLocation> splitTable(org.apache.hadoop.hbase.client.Table t)
                                                          throws IOException,
                                                                 InterruptedException

Throws:: IOException; InterruptedException

waitOnSplit

private List<org.apache.hadoop.hbase.HRegionLocation> waitOnSplit(org.apache.hadoop.hbase.client.Table t)
                                                           throws IOException

Throws:: IOException

testSuperSimple

public void testSuperSimple()
                     throws Exception

Throws:: Exception

testMaxKeyValueSize

public void testMaxKeyValueSize()
                         throws Exception

Throws:: Exception

testFilters

public void testFilters()
                 throws Exception

Throws:: Exception

testFilterWithLongCompartor

public void testFilterWithLongCompartor()
                                 throws Exception

Throws:: Exception

testKeyOnlyFilter

public void testKeyOnlyFilter()
                       throws Exception

Throws:: Exception

testSimpleMissing
```
public void testSimpleMissing()
                       throws Exception
```
Test simple table and non-existent row cases.

Throws:

Exception

testSingleRowMultipleFamily
```
public void testSingleRowMultipleFamily()
                                 throws Exception
```
Test basic puts, gets, scans, and deletes for a single row in a multiple family table.

Throws:

Exception

testNull

public void testNull()
              throws Exception

Throws:: Exception

testNullQualifier

public void testNullQualifier()
                       throws Exception

Throws:: Exception

testVersions

public void testVersions()
                  throws Exception

Throws:: Exception

testVersionLimits

public void testVersionLimits()
                       throws Exception

Throws:: Exception

testDeleteFamilyVersion

public void testDeleteFamilyVersion()
                             throws Exception

Throws:: Exception

testDeleteFamilyVersionWithOtherDeletes

public void testDeleteFamilyVersionWithOtherDeletes()
                                             throws Exception

Throws:: Exception

testDeleteWithFailed

public void testDeleteWithFailed()
                          throws Exception

Throws:: Exception

testDeletes

public void testDeletes()
                 throws Exception

Throws:: Exception

testBatchOperationsWithErrors
```
public void testBatchOperationsWithErrors()
                                   throws Exception
```
Test batch operations with combination of valid and invalid args

Throws:

Exception

testMillions

public void testMillions()
                  throws Exception

Throws:: Exception

testMultipleRegionsAndBatchPuts

public void testMultipleRegionsAndBatchPuts()
                                     throws Exception

Throws:: Exception

testMultipleRowMultipleFamily

public void testMultipleRowMultipleFamily()
                                   throws Exception

Throws:: Exception

testJiraTest867
```
public void testJiraTest867()
                     throws Exception
```
HBASE-867 If millions of columns in a column family, hbase scanner won't come up Test will create numRows rows, each with numColsPerRow columns (1 version each), and attempt to scan them all. To test at scale, up numColsPerRow to the millions (have not gotten that to work running as junit though)

Throws:

Exception

testJiraTest861
```
public void testJiraTest861()
                     throws Exception
```
HBASE-861 get with timestamp will return a value if there is a version with an earlier timestamp

Throws:

Exception

testJiraTest33
```
public void testJiraTest33()
                    throws Exception
```
HBASE-33 Add a HTable get/obtainScanner method that retrieves all versions of a particular column and row between two timestamps

Throws:

Exception

testJiraTest1014
```
public void testJiraTest1014()
                      throws Exception
```
HBASE-1014 commit(BatchUpdate) method should return timestamp

Throws:

Exception

testJiraTest1182
```
public void testJiraTest1182()
                      throws Exception
```
HBASE-1182 Scan for columns > some timestamp

Throws:

Exception

testJiraTest52
```
public void testJiraTest52()
                    throws Exception
```
HBASE-52 Add a means of scanning over all versions

Throws:

Exception

getVersionRangeAndVerifyGreaterThan

private void getVersionRangeAndVerifyGreaterThan(org.apache.hadoop.hbase.client.Table ht,
                                                 byte[] row,
                                                 byte[] family,
                                                 byte[] qualifier,
                                                 long[] stamps,
                                                 byte[][] values,
                                                 int start,
                                                 int end)
                                          throws IOException

Throws:: IOException

getVersionRangeAndVerify

private void getVersionRangeAndVerify(org.apache.hadoop.hbase.client.Table ht,
                                      byte[] row,
                                      byte[] family,
                                      byte[] qualifier,
                                      long[] stamps,
                                      byte[][] values,
                                      int start,
                                      int end)
                               throws IOException

Throws:: IOException

getAllVersionsAndVerify

private void getAllVersionsAndVerify(org.apache.hadoop.hbase.client.Table ht,
                                     byte[] row,
                                     byte[] family,
                                     byte[] qualifier,
                                     long[] stamps,
                                     byte[][] values,
                                     int start,
                                     int end)
                              throws IOException

Throws:: IOException

scanVersionRangeAndVerifyGreaterThan

private void scanVersionRangeAndVerifyGreaterThan(org.apache.hadoop.hbase.client.Table ht,
                                                  byte[] row,
                                                  byte[] family,
                                                  byte[] qualifier,
                                                  long[] stamps,
                                                  byte[][] values,
                                                  int start,
                                                  int end)
                                           throws IOException

Throws:: IOException

scanVersionRangeAndVerify

private void scanVersionRangeAndVerify(org.apache.hadoop.hbase.client.Table ht,
                                       byte[] row,
                                       byte[] family,
                                       byte[] qualifier,
                                       long[] stamps,
                                       byte[][] values,
                                       int start,
                                       int end)
                                throws IOException

Throws:: IOException

scanAllVersionsAndVerify

private void scanAllVersionsAndVerify(org.apache.hadoop.hbase.client.Table ht,
                                      byte[] row,
                                      byte[] family,
                                      byte[] qualifier,
                                      long[] stamps,
                                      byte[][] values,
                                      int start,
                                      int end)
                               throws IOException

Throws:: IOException

getVersionAndVerify

private void getVersionAndVerify(org.apache.hadoop.hbase.client.Table ht,
                                 byte[] row,
                                 byte[] family,
                                 byte[] qualifier,
                                 long stamp,
                                 byte[] value)
                          throws Exception

Throws:: Exception

getVersionAndVerifyMissing

private void getVersionAndVerifyMissing(org.apache.hadoop.hbase.client.Table ht,
                                        byte[] row,
                                        byte[] family,
                                        byte[] qualifier,
                                        long stamp)
                                 throws Exception

Throws:: Exception

scanVersionAndVerify

private void scanVersionAndVerify(org.apache.hadoop.hbase.client.Table ht,
                                  byte[] row,
                                  byte[] family,
                                  byte[] qualifier,
                                  long stamp,
                                  byte[] value)
                           throws Exception

Throws:: Exception

scanVersionAndVerifyMissing

private void scanVersionAndVerifyMissing(org.apache.hadoop.hbase.client.Table ht,
                                         byte[] row,
                                         byte[] family,
                                         byte[] qualifier,
                                         long stamp)
                                  throws Exception

Throws:: Exception

getTestNull

private void getTestNull(org.apache.hadoop.hbase.client.Table ht,
                         byte[] row,
                         byte[] family,
                         byte[] value)
                  throws Exception

Throws:: Exception

getTestNull

private void getTestNull(org.apache.hadoop.hbase.client.Table ht,
                         byte[] row,
                         byte[] family,
                         long value)
                  throws Exception

Throws:: Exception

scanTestNull

private void scanTestNull(org.apache.hadoop.hbase.client.Table ht,
                          byte[] row,
                          byte[] family,
                          byte[] value)
                   throws Exception

Throws:: Exception

scanTestNull

private void scanTestNull(org.apache.hadoop.hbase.client.Table ht,
                          byte[] row,
                          byte[] family,
                          byte[] value,
                          boolean isReversedScan)
                   throws Exception

Throws:: Exception

singleRowGetTest

private void singleRowGetTest(org.apache.hadoop.hbase.client.Table ht,
                              byte[][] ROWS,
                              byte[][] FAMILIES,
                              byte[][] QUALIFIERS,
                              byte[][] VALUES)
                       throws Exception

Throws:: Exception

singleRowScanTest

private void singleRowScanTest(org.apache.hadoop.hbase.client.Table ht,
                               byte[][] ROWS,
                               byte[][] FAMILIES,
                               byte[][] QUALIFIERS,
                               byte[][] VALUES)
                        throws Exception

Throws:: Exception

getVerifySingleColumn

private void getVerifySingleColumn(org.apache.hadoop.hbase.client.Table ht,
                                   byte[][] ROWS,
                                   int ROWIDX,
                                   byte[][] FAMILIES,
                                   int FAMILYIDX,
                                   byte[][] QUALIFIERS,
                                   int QUALIFIERIDX,
                                   byte[][] VALUES,
                                   int VALUEIDX)
                            throws Exception

Verify a single column using gets. Expects family and qualifier arrays to be valid for at least the range: idx-2 < idx < idx+2

Throws:: Exception

scanVerifySingleColumn

private void scanVerifySingleColumn(org.apache.hadoop.hbase.client.Table ht,
                                    byte[][] ROWS,
                                    int ROWIDX,
                                    byte[][] FAMILIES,
                                    int FAMILYIDX,
                                    byte[][] QUALIFIERS,
                                    int QUALIFIERIDX,
                                    byte[][] VALUES,
                                    int VALUEIDX)
                             throws Exception

Verify a single column using scanners. Expects family and qualifier arrays to be valid for at least the range: idx-2 to idx+2 Expects row array to be valid for at least idx to idx+2

Throws:: Exception

getVerifySingleEmpty

private void getVerifySingleEmpty(org.apache.hadoop.hbase.client.Table ht,
                                  byte[][] ROWS,
                                  int ROWIDX,
                                  byte[][] FAMILIES,
                                  int FAMILYIDX,
                                  byte[][] QUALIFIERS,
                                  int QUALIFIERIDX)
                           throws Exception

Verify we do not read any values by accident around a single column Same requirements as getVerifySingleColumn

Throws:: Exception

scanVerifySingleEmpty

private void scanVerifySingleEmpty(org.apache.hadoop.hbase.client.Table ht,
                                   byte[][] ROWS,
                                   int ROWIDX,
                                   byte[][] FAMILIES,
                                   int FAMILYIDX,
                                   byte[][] QUALIFIERS,
                                   int QUALIFIERIDX)
                            throws Exception

Throws:: Exception

assertKey

private void assertKey(org.apache.hadoop.hbase.Cell key,
                       byte[] row,
                       byte[] family,
                       byte[] qualifier,
                       byte[] value)
                throws Exception

Throws:: Exception

assertIncrementKey

static void assertIncrementKey(org.apache.hadoop.hbase.Cell key,
                               byte[] row,
                               byte[] family,
                               byte[] qualifier,
                               long value)
                        throws Exception

Throws:: Exception

assertNumKeys

private void assertNumKeys(org.apache.hadoop.hbase.client.Result result,
                           int n)
                    throws Exception

Throws:: Exception

assertNResult

private void assertNResult(org.apache.hadoop.hbase.client.Result result,
                           byte[] row,
                           byte[][] families,
                           byte[][] qualifiers,
                           byte[][] values,
                           int[][] idxs)
                    throws Exception

Throws:: Exception

assertNResult

private void assertNResult(org.apache.hadoop.hbase.client.Result result,
                           byte[] row,
                           byte[] family,
                           byte[] qualifier,
                           long[] stamps,
                           byte[][] values,
                           int start,
                           int end)
                    throws IOException

Throws:: IOException

assertDoubleResult

private void assertDoubleResult(org.apache.hadoop.hbase.client.Result result,
                                byte[] row,
                                byte[] familyA,
                                byte[] qualifierA,
                                byte[] valueA,
                                byte[] familyB,
                                byte[] qualifierB,
                                byte[] valueB)
                         throws Exception

Validate that result contains two specified keys, exactly. It is assumed key A sorts before key B.

Throws:: Exception

assertSingleResult

private void assertSingleResult(org.apache.hadoop.hbase.client.Result result,
                                byte[] row,
                                byte[] family,
                                byte[] qualifier,
                                byte[] value)
                         throws Exception

Throws:: Exception

assertSingleResult

private void assertSingleResult(org.apache.hadoop.hbase.client.Result result,
                                byte[] row,
                                byte[] family,
                                byte[] qualifier,
                                long value)
                         throws Exception

Throws:: Exception

assertSingleResult

private void assertSingleResult(org.apache.hadoop.hbase.client.Result result,
                                byte[] row,
                                byte[] family,
                                byte[] qualifier,
                                long ts,
                                byte[] value)
                         throws Exception

Throws:: Exception

assertEmptyResult

private void assertEmptyResult(org.apache.hadoop.hbase.client.Result result)
                        throws Exception

Throws:: Exception

assertNullResult

private void assertNullResult(org.apache.hadoop.hbase.client.Result result)
                       throws Exception

Throws:: Exception

getSingleScanResult

private org.apache.hadoop.hbase.client.Result getSingleScanResult(org.apache.hadoop.hbase.client.Table ht,
                                                                  org.apache.hadoop.hbase.client.Scan scan)
                                                           throws IOException

Throws:: IOException

makeNAscii

private byte[][] makeNAscii(byte[] base,
                            int n)

makeN

private byte[][] makeN(byte[] base,
                       int n)

makeNBig

private byte[][] makeNBig(byte[] base,
                          int n)

makeStamps
```
private long[] makeStamps(int n)
```

equals

static boolean equals(byte[] left,
                      byte[] right)

testDuplicateVersions

public void testDuplicateVersions()
                           throws Exception

Throws:: Exception

testUpdates

public void testUpdates()
                 throws Exception

Throws:: Exception

testUpdatesWithMajorCompaction

public void testUpdatesWithMajorCompaction()
                                    throws Exception

Throws:: Exception

testMajorCompactionBetweenTwoUpdates

public void testMajorCompactionBetweenTwoUpdates()
                                          throws Exception

Throws:: Exception

testGet_EmptyTable

public void testGet_EmptyTable()
                        throws IOException

Throws:: IOException

testGet_NullQualifier

public void testGet_NullQualifier()
                           throws IOException

Throws:: IOException

testGet_NonExistentRow

public void testGet_NonExistentRow()
                            throws IOException

Throws:: IOException

testPut

public void testPut()
             throws IOException

Throws:: IOException

testPutNoCF

public void testPutNoCF()
                 throws IOException

Throws:: IOException

testRowsPut

public void testRowsPut()
                 throws IOException

Throws:: IOException

testRowsPutBufferedManyManyFlushes

public void testRowsPutBufferedManyManyFlushes()
                                        throws IOException

Throws:: IOException

testAddKeyValue

public void testAddKeyValue()
                     throws IOException

Throws:: IOException

testHBase737

public void testHBase737()
                  throws IOException

test for HBASE-737

Throws:: IOException

testListTables

public void testListTables()
                    throws IOException,
                           InterruptedException

Throws:: IOException; InterruptedException

testUnmanagedHConnection
```
public void testUnmanagedHConnection()
                              throws IOException
```
simple test that just executes parts of the client API that accept a pre-created Connection instance

Throws:

IOException

testUnmanagedHConnectionReconnect
```
public void testUnmanagedHConnectionReconnect()
                                       throws Exception
```
test of that unmanaged HConnections are able to reconnect properly (see HBASE-5058)

Throws:

Exception

testMiscHTableStuff

public void testMiscHTableStuff()
                         throws IOException

Throws:: IOException

testGetClosestRowBefore

public void testGetClosestRowBefore()
                             throws IOException,
                                    InterruptedException

Throws:: IOException; InterruptedException

getReverseScanResult

private org.apache.hadoop.hbase.client.Result getReverseScanResult(org.apache.hadoop.hbase.client.Table table,
                                                                   byte[] row,
                                                                   byte[] fam)
                                                            throws IOException

Throws:: IOException

testScanVariableReuse

public void testScanVariableReuse()
                           throws Exception

For HBASE-2156

Throws:: Exception

testMultiRowMutation

public void testMultiRowMutation()
                          throws Exception

Throws:: Exception

testRowMutation

public void testRowMutation()
                     throws Exception

Throws:: Exception

testBatchAppendWithReturnResultFalse

public void testBatchAppendWithReturnResultFalse()
                                          throws Exception

Throws:: Exception

testAppend

public void testAppend()
                throws Exception

Throws:: Exception

doAppend

private List<org.apache.hadoop.hbase.client.Result> doAppend(boolean walUsed)
                                                      throws IOException

Throws:: IOException

testAppendWithoutWAL

public void testAppendWithoutWAL()
                          throws Exception

Throws:: Exception

testClientPoolRoundRobin

public void testClientPoolRoundRobin()
                              throws IOException

Throws:: IOException

testClientPoolThreadLocal

public void testClientPoolThreadLocal()
                               throws IOException

Throws:: IOException

testCheckAndPut

public void testCheckAndPut()
                     throws IOException

Throws:: IOException

testCheckAndMutateWithTimeRange

public void testCheckAndMutateWithTimeRange()
                                     throws IOException

Throws:: IOException

testCheckAndPutWithCompareOp

public void testCheckAndPutWithCompareOp()
                                  throws IOException

Throws:: IOException

testCheckAndDelete

public void testCheckAndDelete()
                        throws IOException

Throws:: IOException

testCheckAndDeleteWithCompareOp

public void testCheckAndDeleteWithCompareOp()
                                     throws IOException

Throws:: IOException

testScanMetrics

public void testScanMetrics()
                     throws Exception

Test ScanMetrics

Throws:: Exception

getScanMetrics

private org.apache.hadoop.hbase.client.metrics.ScanMetrics getScanMetrics(org.apache.hadoop.hbase.client.Scan scan)
                                                                   throws Exception

Throws:: Exception

testCacheOnWriteEvictOnClose
```
public void testCacheOnWriteEvictOnClose()
                                  throws Exception
```
Tests that cache on write works all the way up from the client-side. Performs inserts, flushes, and compactions, verifying changes in the block cache along the way.

Throws:

Exception

waitForStoreFileCount

private void waitForStoreFileCount(org.apache.hadoop.hbase.regionserver.HStore store,
                                   int count,
                                   int timeout)
                            throws InterruptedException

Throws:: InterruptedException

testNonCachedGetRegionLocation

public void testNonCachedGetRegionLocation()
                                    throws Exception

Throws:: Exception

testGetRegionsInRange

public void testGetRegionsInRange()
                           throws Exception

Throws:: Exception

getRegionsInRange

private List<org.apache.hadoop.hbase.HRegionLocation> getRegionsInRange(org.apache.hadoop.hbase.TableName tableName,
                                                                        byte[] startKey,
                                                                        byte[] endKey)
                                                                 throws IOException

Throws:: IOException

testJira6912

public void testJira6912()
                  throws Exception

Throws:: Exception

testScan_NullQualifier

public void testScan_NullQualifier()
                            throws IOException

Throws:: IOException

testNegativeTimestamp

public void testNegativeTimestamp()
                           throws IOException

Throws:: IOException

testRawScanRespectsVersions

public void testRawScanRespectsVersions()
                                 throws Exception

Throws:: Exception

testEmptyFilterList

public void testEmptyFilterList()
                         throws Exception

Throws:: Exception

testSmallScan

public void testSmallScan()
                   throws Exception

Throws:: Exception

testSuperSimpleWithReverseScan

public void testSuperSimpleWithReverseScan()
                                    throws Exception

Throws:: Exception

testFiltersWithReverseScan

public void testFiltersWithReverseScan()
                                throws Exception

Throws:: Exception

testKeyOnlyFilterWithReverseScan

public void testKeyOnlyFilterWithReverseScan()
                                      throws Exception

Throws:: Exception

testSimpleMissingWithReverseScan

public void testSimpleMissingWithReverseScan()
                                      throws Exception

Test simple table and non-existent row cases.

Throws:: Exception

testNullWithReverseScan

public void testNullWithReverseScan()
                             throws Exception

Throws:: Exception

testDeletesWithReverseScan

public void testDeletesWithReverseScan()
                                throws Exception

Throws:: Exception

testReversedScanUnderMultiRegions

public void testReversedScanUnderMultiRegions()
                                       throws Exception

Tests reversed scan under multi regions

Throws:: Exception

testSmallReversedScanUnderMultiRegions

public void testSmallReversedScanUnderMultiRegions()
                                            throws Exception

Tests reversed scan under multi regions

Throws:: Exception

reverseScanTest

private void reverseScanTest(org.apache.hadoop.hbase.client.Table table,
                             boolean small)
                      throws IOException

Throws:: IOException

testGetStartEndKeysWithRegionReplicas

public void testGetStartEndKeysWithRegionReplicas()
                                           throws IOException

Throws:: IOException

testFilterAllRecords

public void testFilterAllRecords()
                          throws IOException

Throws:: IOException

testRegionCache

public void testRegionCache()
                     throws IOException

Throws:: IOException

testCellSizeLimit

public void testCellSizeLimit()
                       throws IOException

Throws:: IOException

testDeleteSpecifiedVersionOfSpecifiedColumn

public void testDeleteSpecifiedVersionOfSpecifiedColumn()
                                                 throws Exception

Throws:: Exception

testDeleteLatestVersionOfSpecifiedColumn

public void testDeleteLatestVersionOfSpecifiedColumn()
                                              throws Exception

Throws:: Exception

testReadWithFilter

public void testReadWithFilter()
                        throws Exception

Test for HBASE-17125

Throws:: Exception

testCellUtilTypeMethods

public void testCellUtilTypeMethods()
                             throws IOException

Throws:: IOException

testCreateTableWithZeroRegionReplicas

public void testCreateTableWithZeroRegionReplicas()
                                           throws Exception

Throws:: Exception

testModifyTableWithZeroRegionReplicas

public void testModifyTableWithZeroRegionReplicas()
                                           throws Exception

Throws:: Exception

Class TestFromClientSide

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CLASS_RULE

LOG

TEST_UTIL

ROW

FAMILY

INVALID_FAMILY

QUALIFIER

VALUE

SLAVES

name

Constructor Detail

TestFromClientSide

Method Detail

initialize

setUpBeforeClass

tearDownAfterClass

testDuplicateAppend

testKeepDeletedCells

testPurgeFutureDeletes

testGetConfiguration

testWeirdCacheBehaviour

deleteColumns

getNumberOfRows

buildScanner

putRows

testFilterAcrossMultipleRegions

createScanWithRowFilter

createScanWithRowFilter

assertRowCount

splitTable

waitOnSplit

testSuperSimple

testMaxKeyValueSize

testFilters

testFilterWithLongCompartor

testKeyOnlyFilter

testSimpleMissing

testSingleRowMultipleFamily

testNull

testNullQualifier

testVersions

testVersionLimits

testDeleteFamilyVersion

testDeleteFamilyVersionWithOtherDeletes

testDeleteWithFailed

testDeletes

testBatchOperationsWithErrors

testMillions

testMultipleRegionsAndBatchPuts

testMultipleRowMultipleFamily

testJiraTest867

testJiraTest861

testJiraTest33

testJiraTest1014

testJiraTest1182

testJiraTest52

getVersionRangeAndVerifyGreaterThan

getVersionRangeAndVerify

getAllVersionsAndVerify

scanVersionRangeAndVerifyGreaterThan

scanVersionRangeAndVerify

scanAllVersionsAndVerify

getVersionAndVerify

getVersionAndVerifyMissing

scanVersionAndVerify

scanVersionAndVerifyMissing

getTestNull

getTestNull

scanTestNull

scanTestNull

singleRowGetTest

singleRowScanTest

getVerifySingleColumn

scanVerifySingleColumn