TestHRegion (Apache HBase 2.1.0-cdh6.x-SNAPSHOT Test API)

java.lang.Object
- org.apache.hadoop.hbase.regionserver.TestHRegion

Direct Known Subclasses:

TestHRegionWithInMemoryFlush
```
public class TestHRegion
extends Object
```
Basic stand-alone testing of HRegion. No clusters! A lot of the meta information for an HRegion now lives inside other HRegions or in the HBaseMaster, so only basic testing is possible.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`TestHRegion.FlushThread`
`static class`	`TestHRegion.HRegionForTesting` The same as HRegion class, the only difference is that instantiateHStore will create a different HStore - HStoreForTesting.
`static class`	`TestHRegion.HStoreForTesting` HStoreForTesting is merely the same as HStore, the difference is in the doCompaction method of HStoreForTesting there is a checkpoint "hbase.hstore.compaction.complete" which doesn't let hstore compaction complete.
`protected class`	`TestHRegion.PutThread`

Field Summary

Fields
Modifier and Type	Field and Description
`static HBaseClassTestRule`	`CLASS_RULE`
`static org.apache.hadoop.conf.Configuration`	`CONF`
`protected String`	`method`
`protected MetricsAssertHelper`	`metricsAssertHelper`
`org.junit.rules.TestName`	`name`
`protected byte[]`	`qual`
`protected byte[]`	`qual1`
`protected byte[]`	`qual2`
`protected byte[]`	`qual3`
`protected byte[]`	`row`
`protected byte[]`	`row2`
`protected TableName`	`tableName`
`protected static HBaseTestingUtility`	`TEST_UTIL`
`org.junit.rules.ExpectedException`	`thrown`
`protected byte[]`	`value`
`protected byte[]`	`value1`
`protected byte[]`	`value2`

Constructor Summary

Constructors
Constructor and Description

TestHRegion()

Constructors
Constructor and Description
`TestHRegion()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`assertScan(HRegion r, byte[] fs, byte[] firstValue)`
`void`	`doTestDelete_AndPostInsert(Delete delete)`
`HRegion`	`initHRegion(TableName tableName, byte[] startKey, byte[] stopKey, boolean isReadOnly, Durability durability, WAL wal, byte[]... families)`
`protected HRegion`	`initHRegion(TableName tableName, byte[] startKey, byte[] stopKey, String callingMethod, org.apache.hadoop.conf.Configuration conf, boolean isReadOnly, byte[]... families)`
`protected HRegion`	`initHRegion(TableName tableName, String callingMethod, org.apache.hadoop.conf.Configuration conf, boolean isReadOnly, byte[]... families)`
`protected HRegion`	`initHRegion(TableName tableName, String callingMethod, org.apache.hadoop.conf.Configuration conf, byte[]... families)`
`protected org.apache.hadoop.conf.Configuration`	`initSplit()`
`void`	`setup()`
`void`	`tearDown()`
`void`	`testaddFamily_PostInsert()`
`void`	`testAllColumnsWithBloomFilter()`
`void`	`testAppendTimestampsAreMonotonic()`
`void`	`testAppendWithReadOnlyTable()`
`void`	`testAtomicBatchPut()`
`void`	`testBatchMutateWithWrongRegionException()`
`void`	`testBatchPut_whileMultipleRowLocksHeld()`
`void`	`testBatchPut_whileNoRowLocksHeld()`
`void`	`testBatchPutWithTsSlop()`
`void`	`testBloomFilterSize()`
`void`	`testBulkLoadReplicationEnabled()`
`void`	`testCellTTLs()`
`void`	`testCheckAndDelete_ThatDeleteWasWritten()`
`void`	`testCheckAndMutate_WithCorrectValue()`
`void`	`testCheckAndMutate_WithEmptyRowValue()`
`void`	`testCheckAndMutate_WithNonEqualCompareOp()`
`void`	`testCheckAndMutate_WithWrongValue()`
`void`	`testCheckAndMutateTimestampsAreMonotonic()`
`void`	`testCheckAndPut_ThatPutWasWritten()`
`void`	`testCheckAndPut_wrongRowInPut()`
`void`	`testCheckAndRowMutateTimestampsAreMonotonic()`
`void`	`testCloseCarryingSnapshot()` Test for Bug 2 of HBASE-10466.
`void`	`testCloseRegionWrittenToWAL()`
`void`	`testCloseWithFailingFlush()`
`void`	`testCompactionAffectedByScanners()`
`void`	`testCompactionFromPrimary()`
`void`	`testDataInMemoryWithoutWAL()`
`void`	`testDelete_CheckFamily()`
`void`	`testDelete_CheckTimestampUpdated()`
`void`	`testDelete_mixed()`
`void`	`testDelete_multiDeleteColumn()`
`void`	`testDeleteColumns_PostInsert()`
`void`	`testDeleteRowWithBloomFilter()` Testcase to cover bug-fix for HBASE-2823 Ensures correct delete when issuing delete row on columns with bloom filter set to row+col (BloomType.ROWCOL)
`void`	`testDeleteRowWithFutureTs()`
`void`	`testDurability()`
`void`	`testFamilyWithAndWithoutColon()`
`void`	`testFlushAndMemstoreSizeCounting()` A test case of HBASE-21041
`void`	`testFlushCacheWhileScanning()` Flushes the cache in a thread while scanning.
`void`	`testFlushedFileWithNoTags()`
`void`	`testFlushMarkers()`
`void`	`testFlushMarkersWALFail()`
`void`	`testFlushResult()` Test that we get the expected flush results back
`void`	`testFlushSizeAccounting()` Test we do not lose data if we fail a flush and then close.
`void`	`testGet_Basic()`
`void`	`testGet_Empty()`
`void`	`testGet_FamilyChecker()`
`void`	`testgetHDFSBlocksDistribution()`
`void`	`testGetScanner_WithNoFamilies()`
`void`	`testGetScanner_WithNotOkFamilies()`
`void`	`testGetScanner_WithOkFamilies()`
`void`	`testGetScanner_WithRegionClosed()` This method tests https://issues.apache.org/jira/browse/HBASE-2516.
`void`	`testGetWhileRegionClose()`
`void`	`testGetWithFilter()`
`void`	`testHolesInMeta()`
`void`	`testIncrementTimestampsAreMonotonic()`
`void`	`testIncrWithReadOnlyTable()`
`void`	`testIndexesScanWithOneDeletedRow()`
`void`	`testLongQualifier()` Write an HFile block full with Cells whose qualifier that are identical between 0 and Short.MAX_VALUE.
`void`	`testMemstoreSizeAccountingWithFailedPostBatchMutate()`
`void`	`testMemstoreSnapshotSize()`
`void`	`testMutateRow_WriteRequestCount()`
`void`	`testOpenRegionWrittenToWAL()`
`void`	`testParallelAppendWithMemStoreFlush()` Test case to check append function with memstore flushing
`void`	`testParallelIncrementWithMemStoreFlush()` Test case to check increment function with memstore flushing
`void`	`testPutWithLatestTS()` Tests that the special LATEST_TIMESTAMP option for puts gets replaced by the actual timestamp
`void`	`testPutWithMemStoreFlush()` Test case to check put function with memstore flushing for same row, same ts
`void`	`testPutWithTsSlop()` Tests that there is server-side filtering for invalid timestamp upper bound.
`void`	`testRecoveredEditsReplayCompaction()`
`void`	`testRecoveredEditsReplayCompaction(boolean mismatchedRegionName)`
`void`	`testRegionInfoFileCreation()` Verifies that the .regioninfo file is written on region creation and that is recreated if missing during region opening.
`void`	`testRegionReplicaSecondary()`
`void`	`testRegionReplicaSecondaryIsReadOnly()`
`void`	`testRegionScanner_Next()`
`void`	`testRegionTooBusy()` Test RegionTooBusyException thrown when region is busy
`void`	`testReverseScanner_FromMemStore_SingleCF_FullScan()`
`void`	`testReverseScanner_FromMemStore_SingleCF_LargerKey()`
`void`	`testReverseScanner_FromMemStore_SingleCF_Normal()`
`void`	`testReverseScanner_FromMemStoreAndHFiles_MultiCFs1()`
`void`	`testReverseScanner_FromMemStoreAndHFiles_MultiCFs2()`
`void`	`testReverseScanner_moreRowsMayExistAfter()`
`void`	`testReverseScanner_smaller_blocksize()`
`void`	`testReverseScanner_StackOverflow()` Test for HBASE-14497: Reverse Scan threw StackOverflow caused by readPt checking
`void`	`testReverseScanShouldNotScanMemstoreIfReadPtLesser()`
`void`	`testReverseScanWhenPutCellsAfterOpenReverseScan()`
`void`	`testScanner_DeleteOneFamilyNotAnother()`
`void`	`testScanner_ExplicitColumns_FromFilesOnly_EnforceVersions()`
`void`	`testScanner_ExplicitColumns_FromMemStore_EnforceVersions()`
`void`	`testScanner_ExplicitColumns_FromMemStoreAndFiles_EnforceVersions()`
`void`	`testScanner_JoinedScanners()` Added for HBASE-5416 Here we test scan optimization when only subset of CFs are used in filter conditions.
`void`	`testScanner_JoinedScannersWithLimits()` HBASE-5416 Test case when scan limits amount of KVs returned on each next() call.
`void`	`testScanner_StopRow1542()`
`void`	`testScanner_Wildcard_FromFilesOnly_EnforceVersions()`
`void`	`testScanner_Wildcard_FromMemStore_EnforceVersions()`
`void`	`testScanner_Wildcard_FromMemStoreAndFiles_EnforceVersions()`
`void`	`testSequenceId()` Test that I can use the max flushed sequence id after the close.
`void`	`testSkipRecoveredEditsReplay()`
`void`	`testSkipRecoveredEditsReplayAllIgnored()`
`void`	`testSkipRecoveredEditsReplaySomeIgnored()`
`void`	`testSkipRecoveredEditsReplayTheLastFileIgnored()`
`void`	`testStatusSettingToAbortIfAnyExceptionDuringRegionInitilization()` Testcase to check state of region initialization task set to ABORTED or not if any exceptions during initialization
`void`	`testToShowNPEOnRegionScannerReseek()`
`void`	`testWeirdCacheBehaviour()`
`void`	`testWriteRequestsCounter()`
`void`	`testWritesWhileGetting()` Writes very wide records and gets the latest row every time..
`void`	`testWritesWhileRollWriter()` HBASE-16429 Make sure no stuck if roll writer when ring buffer is filled with appends
`void`	`testWritesWhileScanning()` Writes very wide records and scans for the latest every time..

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

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

thrown

public final org.junit.rules.ExpectedException thrown

TEST_UTIL

protected static HBaseTestingUtility TEST_UTIL

CONF

public static org.apache.hadoop.conf.Configuration CONF

tableName
```
protected TableName tableName
```

method
```
protected String method
```

qual
```
protected final byte[] qual
```

qual1
```
protected final byte[] qual1
```

qual2
```
protected final byte[] qual2
```

qual3
```
protected final byte[] qual3
```

value
```
protected final byte[] value
```

value1
```
protected final byte[] value1
```

value2
```
protected final byte[] value2
```

row
```
protected final byte[] row
```

row2
```
protected final byte[] row2
```

metricsAssertHelper

protected final MetricsAssertHelper metricsAssertHelper

Constructor Detail
- TestHRegion
```
public TestHRegion()
```

Method Detail

setup

public void setup()
           throws IOException

Throws:: IOException

tearDown

public void tearDown()
              throws Exception

Throws:: Exception

testSequenceId
```
public void testSequenceId()
                    throws IOException
```
Test that I can use the max flushed sequence id after the close.

Throws:

IOException

testCloseCarryingSnapshot
```
public void testCloseCarryingSnapshot()
                               throws IOException
```
Test for Bug 2 of HBASE-10466. "Bug 2: Conditions for the first flush of region close (so-called pre-flush) If memstoreSize is smaller than a certain value, or when region close starts a flush is ongoing, the first flush is skipped and only the second flush takes place. However, two flushes are required in case previous flush fails and leaves some data in snapshot. The bug could cause loss of data in current memstore. The fix is removing all conditions except abort check so we ensure 2 flushes for region close."

Throws:

IOException

testMemstoreSnapshotSize

public void testMemstoreSnapshotSize()
                              throws IOException

Throws:: IOException

testMemstoreSizeAccountingWithFailedPostBatchMutate

public void testMemstoreSizeAccountingWithFailedPostBatchMutate()
                                                         throws IOException

Throws:: IOException

testFlushAndMemstoreSizeCounting

public void testFlushAndMemstoreSizeCounting()
                                      throws Exception

A test case of HBASE-21041

Throws:: Exception - Exception

testFlushSizeAccounting
```
public void testFlushSizeAccounting()
                             throws Exception
```
Test we do not lose data if we fail a flush and then close. Part of HBase-10466. Tests the following from the issue description: "Bug 1: Wrong calculation of HRegion.memstoreSize: When a flush fails, data to be flushed is kept in each MemStore's snapshot and wait for next flush attempt to continue on it. But when the next flush succeeds, the counter of total memstore size in HRegion is always deduced by the sum of current memstore sizes instead of snapshots left from previous failed flush. This calculation is problematic that almost every time there is failed flush, HRegion.memstoreSize gets reduced by a wrong value. If region flush could not proceed for a couple cycles, the size in current memstore could be much larger than the snapshot. It's likely to drift memstoreSize much smaller than expected. In extreme case, if the error accumulates to even bigger than HRegion's memstore size limit, any further flush is skipped because flush does not do anything if memstoreSize is not larger than 0."

Throws:

Exception

testCloseWithFailingFlush

public void testCloseWithFailingFlush()
                               throws Exception

Throws:: Exception

testCompactionAffectedByScanners

public void testCompactionAffectedByScanners()
                                      throws Exception

Throws:: Exception

testToShowNPEOnRegionScannerReseek

public void testToShowNPEOnRegionScannerReseek()
                                        throws Exception

Throws:: Exception

testSkipRecoveredEditsReplay

public void testSkipRecoveredEditsReplay()
                                  throws Exception

Throws:: Exception

testSkipRecoveredEditsReplaySomeIgnored

public void testSkipRecoveredEditsReplaySomeIgnored()
                                             throws Exception

Throws:: Exception

testSkipRecoveredEditsReplayAllIgnored

public void testSkipRecoveredEditsReplayAllIgnored()
                                            throws Exception

Throws:: Exception

testSkipRecoveredEditsReplayTheLastFileIgnored

public void testSkipRecoveredEditsReplayTheLastFileIgnored()
                                                    throws Exception

Throws:: Exception

testRecoveredEditsReplayCompaction

public void testRecoveredEditsReplayCompaction()
                                        throws Exception

Throws:: Exception

testRecoveredEditsReplayCompaction

public void testRecoveredEditsReplayCompaction(boolean mismatchedRegionName)
                                        throws Exception

Throws:: Exception

testFlushMarkers

public void testFlushMarkers()
                      throws Exception

Throws:: Exception

testFlushMarkersWALFail

public void testFlushMarkersWALFail()
                             throws Exception

Throws:: Exception

testGetWhileRegionClose

public void testGetWhileRegionClose()
                             throws IOException

Throws:: IOException

testWeirdCacheBehaviour

public void testWeirdCacheBehaviour()
                             throws Exception

Throws:: Exception

testAppendWithReadOnlyTable

public void testAppendWithReadOnlyTable()
                                 throws Exception

Throws:: Exception

testIncrWithReadOnlyTable

public void testIncrWithReadOnlyTable()
                               throws Exception

Throws:: Exception

testFamilyWithAndWithoutColon

public void testFamilyWithAndWithoutColon()
                                   throws Exception

Throws:: Exception

testBatchPut_whileNoRowLocksHeld

public void testBatchPut_whileNoRowLocksHeld()
                                      throws IOException

Throws:: IOException

testBatchPut_whileMultipleRowLocksHeld

public void testBatchPut_whileMultipleRowLocksHeld()
                                            throws Exception

Throws:: Exception

testAtomicBatchPut

public void testAtomicBatchPut()
                        throws IOException

Throws:: IOException

testBatchPutWithTsSlop

public void testBatchPutWithTsSlop()
                            throws Exception

Throws:: Exception

testCheckAndMutate_WithEmptyRowValue

public void testCheckAndMutate_WithEmptyRowValue()
                                          throws IOException

Throws:: IOException

testCheckAndMutate_WithWrongValue

public void testCheckAndMutate_WithWrongValue()
                                       throws IOException

Throws:: IOException

testCheckAndMutate_WithCorrectValue

public void testCheckAndMutate_WithCorrectValue()
                                         throws IOException

Throws:: IOException

testCheckAndMutate_WithNonEqualCompareOp

public void testCheckAndMutate_WithNonEqualCompareOp()
                                              throws IOException

Throws:: IOException

testCheckAndPut_ThatPutWasWritten

public void testCheckAndPut_ThatPutWasWritten()
                                       throws IOException

Throws:: IOException

testCheckAndPut_wrongRowInPut

public void testCheckAndPut_wrongRowInPut()
                                   throws IOException

Throws:: IOException

testCheckAndDelete_ThatDeleteWasWritten

public void testCheckAndDelete_ThatDeleteWasWritten()
                                             throws IOException

Throws:: IOException

testDelete_multiDeleteColumn

public void testDelete_multiDeleteColumn()
                                  throws IOException

Throws:: IOException

testDelete_CheckFamily

public void testDelete_CheckFamily()
                            throws IOException

Throws:: IOException

testDelete_mixed

public void testDelete_mixed()
                      throws IOException,
                             InterruptedException

Throws:: IOException; InterruptedException

testDeleteRowWithFutureTs

public void testDeleteRowWithFutureTs()
                               throws IOException

Throws:: IOException

testPutWithLatestTS
```
public void testPutWithLatestTS()
                         throws IOException
```
Tests that the special LATEST_TIMESTAMP option for puts gets replaced by the actual timestamp

Throws:

IOException

testPutWithTsSlop
```
public void testPutWithTsSlop()
                       throws IOException
```
Tests that there is server-side filtering for invalid timestamp upper bound. Note that the timestamp lower bound is automatically handled for us by the TTL field.

Throws:

IOException

testScanner_DeleteOneFamilyNotAnother

public void testScanner_DeleteOneFamilyNotAnother()
                                           throws IOException

Throws:: IOException

testDataInMemoryWithoutWAL

public void testDataInMemoryWithoutWAL()
                                throws IOException

Throws:: IOException

testDeleteColumns_PostInsert

public void testDeleteColumns_PostInsert()
                                  throws IOException,
                                         InterruptedException

Throws:: IOException; InterruptedException

testaddFamily_PostInsert

public void testaddFamily_PostInsert()
                              throws IOException,
                                     InterruptedException

Throws:: IOException; InterruptedException

doTestDelete_AndPostInsert

public void doTestDelete_AndPostInsert(Delete delete)
                                throws IOException,
                                       InterruptedException

Throws:: IOException; InterruptedException

testDelete_CheckTimestampUpdated

public void testDelete_CheckTimestampUpdated()
                                      throws IOException

Throws:: IOException

testGet_FamilyChecker

public void testGet_FamilyChecker()
                           throws IOException

Throws:: IOException

testGet_Basic

public void testGet_Basic()
                   throws IOException

Throws:: IOException

testGet_Empty

public void testGet_Empty()
                   throws IOException

Throws:: IOException

testGetWithFilter

public void testGetWithFilter()
                       throws IOException,
                              InterruptedException

Throws:: IOException; InterruptedException

testGetScanner_WithOkFamilies

public void testGetScanner_WithOkFamilies()
                                   throws IOException

Throws:: IOException

testGetScanner_WithNotOkFamilies

public void testGetScanner_WithNotOkFamilies()
                                      throws IOException

Throws:: IOException

testGetScanner_WithNoFamilies

public void testGetScanner_WithNoFamilies()
                                   throws IOException

Throws:: IOException

testGetScanner_WithRegionClosed
```
public void testGetScanner_WithRegionClosed()
                                     throws IOException
```
This method tests https://issues.apache.org/jira/browse/HBASE-2516.

Throws:

IOException

testRegionScanner_Next

public void testRegionScanner_Next()
                            throws IOException

Throws:: IOException

testScanner_ExplicitColumns_FromMemStore_EnforceVersions

public void testScanner_ExplicitColumns_FromMemStore_EnforceVersions()
                                                              throws IOException

Throws:: IOException

testScanner_ExplicitColumns_FromFilesOnly_EnforceVersions

public void testScanner_ExplicitColumns_FromFilesOnly_EnforceVersions()
                                                               throws IOException

Throws:: IOException

testScanner_ExplicitColumns_FromMemStoreAndFiles_EnforceVersions

public void testScanner_ExplicitColumns_FromMemStoreAndFiles_EnforceVersions()
                                                                      throws IOException

Throws:: IOException

testScanner_Wildcard_FromMemStore_EnforceVersions

public void testScanner_Wildcard_FromMemStore_EnforceVersions()
                                                       throws IOException

Throws:: IOException

testScanner_Wildcard_FromFilesOnly_EnforceVersions

public void testScanner_Wildcard_FromFilesOnly_EnforceVersions()
                                                        throws IOException

Throws:: IOException

testScanner_StopRow1542

public void testScanner_StopRow1542()
                             throws IOException

Throws:: IOException

testScanner_Wildcard_FromMemStoreAndFiles_EnforceVersions

public void testScanner_Wildcard_FromMemStoreAndFiles_EnforceVersions()
                                                               throws IOException

Throws:: IOException

testScanner_JoinedScanners
```
public void testScanner_JoinedScanners()
                                throws IOException
```
Added for HBASE-5416 Here we test scan optimization when only subset of CFs are used in filter conditions.

Throws:

IOException

testScanner_JoinedScannersWithLimits
```
public void testScanner_JoinedScannersWithLimits()
                                          throws IOException
```
HBASE-5416 Test case when scan limits amount of KVs returned on each next() call.

Throws:

IOException

testLongQualifier
```
public void testLongQualifier()
                       throws Exception
```
Write an HFile block full with Cells whose qualifier that are identical between 0 and Short.MAX_VALUE. See HBASE-13329.

Throws:

Exception

testFlushCacheWhileScanning
```
public void testFlushCacheWhileScanning()
                                 throws IOException,
                                        InterruptedException
```
Flushes the cache in a thread while scanning. The tests verify that the scan is coherent - e.g. the returned results are always of the same or later update as the previous results.

Throws:

IOException - scan / compact

InterruptedException - thread join

testWritesWhileScanning
```
public void testWritesWhileScanning()
                             throws IOException,
                                    InterruptedException
```
Writes very wide records and scans for the latest every time.. Flushes and compacts the region every now and then to keep things realistic.

Throws:

IOException - by flush / scan / compaction

InterruptedException - when joining threads

testWritesWhileGetting
```
public void testWritesWhileGetting()
                            throws Exception
```
Writes very wide records and gets the latest row every time.. Flushes and compacts the region aggressivly to catch issues.

Throws:

IOException - by flush / scan / compaction

InterruptedException - when joining threads

Exception

testHolesInMeta

public void testHolesInMeta()
                     throws Exception

Throws:: Exception

testIndexesScanWithOneDeletedRow

public void testIndexesScanWithOneDeletedRow()
                                      throws IOException

Throws:: IOException

testBloomFilterSize

public void testBloomFilterSize()
                         throws IOException

Throws:: IOException

testAllColumnsWithBloomFilter

public void testAllColumnsWithBloomFilter()
                                   throws IOException

Throws:: IOException

testDeleteRowWithBloomFilter
```
public void testDeleteRowWithBloomFilter()
                                  throws IOException
```
Testcase to cover bug-fix for HBASE-2823 Ensures correct delete when issuing delete row on columns with bloom filter set to row+col (BloomType.ROWCOL)

Throws:

IOException

testgetHDFSBlocksDistribution

public void testgetHDFSBlocksDistribution()
                                   throws Exception

Throws:: Exception

testStatusSettingToAbortIfAnyExceptionDuringRegionInitilization
```
public void testStatusSettingToAbortIfAnyExceptionDuringRegionInitilization()
                                                                     throws Exception
```
Testcase to check state of region initialization task set to ABORTED or not if any exceptions during initialization

Throws:

Exception

testRegionInfoFileCreation
```
public void testRegionInfoFileCreation()
                                throws IOException
```
Verifies that the .regioninfo file is written on region creation and that is recreated if missing during region opening.

Throws:

IOException

testParallelIncrementWithMemStoreFlush

public void testParallelIncrementWithMemStoreFlush()
                                            throws Exception

Test case to check increment function with memstore flushing

Throws:: Exception

testParallelAppendWithMemStoreFlush

public void testParallelAppendWithMemStoreFlush()
                                         throws Exception

Test case to check append function with memstore flushing

Throws:: Exception

testPutWithMemStoreFlush
```
public void testPutWithMemStoreFlush()
                              throws Exception
```
Test case to check put function with memstore flushing for same row, same ts

Throws:

Exception

testDurability

public void testDurability()
                    throws Exception

Throws:: Exception

testRegionReplicaSecondary

public void testRegionReplicaSecondary()
                                throws IOException

Throws:: IOException

testRegionReplicaSecondaryIsReadOnly

public void testRegionReplicaSecondaryIsReadOnly()
                                          throws IOException

Throws:: IOException

testCompactionFromPrimary

public void testCompactionFromPrimary()
                               throws IOException

Throws:: IOException

assertScan

protected void assertScan(HRegion r,
                          byte[] fs,
                          byte[] firstValue)
                   throws IOException

Throws:: IOException

testFlushResult
```
public void testFlushResult()
                     throws IOException
```
Test that we get the expected flush results back

Throws:

IOException

initSplit

protected org.apache.hadoop.conf.Configuration initSplit()

initHRegion

protected HRegion initHRegion(TableName tableName,
                              String callingMethod,
                              org.apache.hadoop.conf.Configuration conf,
                              byte[]... families)
                       throws IOException

Returns:: A region on which you must call HBaseTestingUtility.closeRegionAndWAL(HRegion) when done.
Throws:: IOException

initHRegion

protected HRegion initHRegion(TableName tableName,
                              String callingMethod,
                              org.apache.hadoop.conf.Configuration conf,
                              boolean isReadOnly,
                              byte[]... families)
                       throws IOException

Returns:: A region on which you must call HBaseTestingUtility.closeRegionAndWAL(HRegion) when done.
Throws:: IOException

initHRegion

protected HRegion initHRegion(TableName tableName,
                              byte[] startKey,
                              byte[] stopKey,
                              String callingMethod,
                              org.apache.hadoop.conf.Configuration conf,
                              boolean isReadOnly,
                              byte[]... families)
                       throws IOException

Throws:: IOException

initHRegion

public HRegion initHRegion(TableName tableName,
                           byte[] startKey,
                           byte[] stopKey,
                           boolean isReadOnly,
                           Durability durability,
                           WAL wal,
                           byte[]... families)
                    throws IOException

Returns:: A region on which you must call HBaseTestingUtility.closeRegionAndWAL(HRegion) when done.
Throws:: IOException

testReverseScanner_FromMemStore_SingleCF_Normal

public void testReverseScanner_FromMemStore_SingleCF_Normal()
                                                     throws IOException

Throws:: IOException

testReverseScanner_FromMemStore_SingleCF_LargerKey

public void testReverseScanner_FromMemStore_SingleCF_LargerKey()
                                                        throws IOException

Throws:: IOException

testReverseScanner_FromMemStore_SingleCF_FullScan

public void testReverseScanner_FromMemStore_SingleCF_FullScan()
                                                       throws IOException

Throws:: IOException

testReverseScanner_moreRowsMayExistAfter

public void testReverseScanner_moreRowsMayExistAfter()
                                              throws IOException

Throws:: IOException

testReverseScanner_smaller_blocksize

public void testReverseScanner_smaller_blocksize()
                                          throws IOException

Throws:: IOException

testReverseScanner_FromMemStoreAndHFiles_MultiCFs1

public void testReverseScanner_FromMemStoreAndHFiles_MultiCFs1()
                                                        throws IOException

Throws:: IOException

testReverseScanner_FromMemStoreAndHFiles_MultiCFs2

public void testReverseScanner_FromMemStoreAndHFiles_MultiCFs2()
                                                        throws IOException

Throws:: IOException

testReverseScanner_StackOverflow
```
public void testReverseScanner_StackOverflow()
                                      throws IOException
```
Test for HBASE-14497: Reverse Scan threw StackOverflow caused by readPt checking

Throws:

IOException

testReverseScanShouldNotScanMemstoreIfReadPtLesser

public void testReverseScanShouldNotScanMemstoreIfReadPtLesser()
                                                        throws Exception

Throws:: Exception

testReverseScanWhenPutCellsAfterOpenReverseScan

public void testReverseScanWhenPutCellsAfterOpenReverseScan()
                                                     throws Exception

Throws:: Exception

testWriteRequestsCounter

public void testWriteRequestsCounter()
                              throws IOException

Throws:: IOException

testOpenRegionWrittenToWAL

public void testOpenRegionWrittenToWAL()
                                throws Exception

Throws:: Exception

testFlushedFileWithNoTags

public void testFlushedFileWithNoTags()
                               throws Exception

Throws:: Exception

testCloseRegionWrittenToWAL

public void testCloseRegionWrittenToWAL()
                                 throws Exception

Throws:: Exception

testRegionTooBusy
```
public void testRegionTooBusy()
                       throws IOException
```
Test RegionTooBusyException thrown when region is busy

Throws:

IOException

testCellTTLs

public void testCellTTLs()
                  throws IOException

Throws:: IOException

testIncrementTimestampsAreMonotonic

public void testIncrementTimestampsAreMonotonic()
                                         throws IOException

Throws:: IOException

testAppendTimestampsAreMonotonic

public void testAppendTimestampsAreMonotonic()
                                      throws IOException

Throws:: IOException

testCheckAndMutateTimestampsAreMonotonic

public void testCheckAndMutateTimestampsAreMonotonic()
                                              throws IOException

Throws:: IOException

testBatchMutateWithWrongRegionException

public void testBatchMutateWithWrongRegionException()
                                             throws Exception

Throws:: Exception

testCheckAndRowMutateTimestampsAreMonotonic

public void testCheckAndRowMutateTimestampsAreMonotonic()
                                                 throws IOException

Throws:: IOException

testWritesWhileRollWriter
```
public void testWritesWhileRollWriter()
                               throws IOException
```
HBASE-16429 Make sure no stuck if roll writer when ring buffer is filled with appends

Throws:

IOException - if IO error occurred during test

testMutateRow_WriteRequestCount

public void testMutateRow_WriteRequestCount()
                                     throws Exception

Throws:: Exception

testBulkLoadReplicationEnabled

public void testBulkLoadReplicationEnabled()
                                    throws IOException

Throws:: IOException

Class TestHRegion

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CLASS_RULE

name

thrown

TEST_UTIL

CONF

tableName

method

qual

qual1

qual2

qual3

value

value1

value2

row

row2

metricsAssertHelper

Constructor Detail

TestHRegion

Method Detail

setup

tearDown

testSequenceId

testCloseCarryingSnapshot

testMemstoreSnapshotSize

testMemstoreSizeAccountingWithFailedPostBatchMutate

testFlushAndMemstoreSizeCounting

testFlushSizeAccounting

testCloseWithFailingFlush

testCompactionAffectedByScanners

testToShowNPEOnRegionScannerReseek

testSkipRecoveredEditsReplay

testSkipRecoveredEditsReplaySomeIgnored

testSkipRecoveredEditsReplayAllIgnored

testSkipRecoveredEditsReplayTheLastFileIgnored

testRecoveredEditsReplayCompaction

testRecoveredEditsReplayCompaction

testFlushMarkers

testFlushMarkersWALFail

testGetWhileRegionClose

testWeirdCacheBehaviour

testAppendWithReadOnlyTable

testIncrWithReadOnlyTable

testFamilyWithAndWithoutColon

testBatchPut_whileNoRowLocksHeld

testBatchPut_whileMultipleRowLocksHeld

testAtomicBatchPut

testBatchPutWithTsSlop

testCheckAndMutate_WithEmptyRowValue

testCheckAndMutate_WithWrongValue

testCheckAndMutate_WithCorrectValue

testCheckAndMutate_WithNonEqualCompareOp

testCheckAndPut_ThatPutWasWritten

testCheckAndPut_wrongRowInPut

testCheckAndDelete_ThatDeleteWasWritten

testDelete_multiDeleteColumn

testDelete_CheckFamily

testDelete_mixed

testDeleteRowWithFutureTs

testPutWithLatestTS

testPutWithTsSlop

testScanner_DeleteOneFamilyNotAnother

testDataInMemoryWithoutWAL

testDeleteColumns_PostInsert

testaddFamily_PostInsert

doTestDelete_AndPostInsert

testDelete_CheckTimestampUpdated

testGet_FamilyChecker

testGet_Basic

testGet_Empty

testGetWithFilter

testGetScanner_WithOkFamilies

testGetScanner_WithNotOkFamilies