TestHRegion (Hortonworks Data Platform Apache HBase Java API Reference)

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

```
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

protected class TestHRegion.PutThread

Nested Classes
Modifier and Type	Class and Description
`protected class`	`TestHRegion.FlushThread`
`protected class`	`TestHRegion.PutThread`

Field Summary

Fields
Modifier and Type	Field and Description
`static Configuration`	`CONF`
`protected String`	`method`
`protected MetricsAssertHelper`	`metricsAssertHelper`
`TestName`	`name`
`protected byte[]`	`qual1`
`protected byte[]`	`qual2`
`protected byte[]`	`qual3`
`protected byte[]`	`row`
`protected byte[]`	`row2`
`protected byte[]`	`tableName`
`protected byte[]`	`value1`
`protected byte[]`	`value2`

Constructor Summary

Constructors
Constructor and Description

TestHRegion()

Constructors
Constructor and Description
`TestHRegion()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`doTestDelete_AndPostInsert(Delete delete)`
`static HRegion`	`initHRegion(byte[] tableName, byte[] startKey, byte[] stopKey, String callingMethod, Configuration conf, boolean isReadOnly, byte[]... families)`
`static HRegion`	`initHRegion(byte[] tableName, byte[] startKey, byte[] stopKey, String callingMethod, Configuration conf, boolean isReadOnly, Durability durability, WAL wal, byte[]... families)`
`static HRegion`	`initHRegion(byte[] tableName, String callingMethod, Configuration conf, boolean isReadOnly, byte[]... families)`
`static HRegion`	`initHRegion(byte[] tableName, String callingMethod, Configuration conf, byte[]... families)`
`static HRegion`	`initHRegion(TableName tableName, String callingMethod, Configuration conf, byte[]... families)`
`void`	`setup()`
`void`	`tearDown()`
`void`	`testAllColumnsWithBloomFilter()`
`void`	`testAppendTimestampsAreMonotonic()`
`void`	`testAppendWithReadOnlyTable()`
`void`	`testBasicSplit()` Splits twice and verifies getting from each of the split regions.
`void`	`testBatchMutateWithWrongRegionException()`
`void`	`testBatchPut_whileMultipleRowLocksHeld()`
`void`	`testBatchPut_whileNoRowLocksHeld()`
`void`	`testBatchPutWithTsSlop()`
`void`	`testBloomFilterSize()`
`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`	`testClearForceSplit()`
`void`	`testCloseCarryingSnapshot()` Test for Bug 2 of HBASE-10466.
`void`	`testCloseRegionWrittenToWAL()`
`void`	`testCloseWithFailingFlush()`
`void`	`testCompactionAffectedByScanners()`
`void`	`testCompactionFromPrimary()`
`void`	`testDelete_CheckFamily()`
`void`	`testDelete_CheckTimestampUpdated()`
`void`	`testDelete_mixed()`
`void`	`testDelete_multiDeleteColumn()`
`void`	`testDeleteColumns_PostInsert()`
`void`	`testDeleteFamily_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`	`testFlushCacheWhileScanning()` Flushes the cache in a thread while scanning.
`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`	`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`	`testMemstoreSnapshotSize()`
`void`	`testMerge()`
`void`	`testOpenRegionWrittenToWAL()`
`void`	`testOpenRegionWrittenToWALForLogReplay()`
`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`	`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`	`testSkipRecoveredEditsReplay()`
`void`	`testSkipRecoveredEditsReplayAllIgnored()`
`void`	`testSkipRecoveredEditsReplaySomeIgnored()`
`void`	`testSkipRecoveredEditsReplayTheLastFileIgnored()`
`void`	`testSplitRegion()`
`void`	`testSplitRegionWithReverseScan()`
`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`	`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

name
```
public TestName name
```

CONF
```
public static Configuration CONF
```

tableName
```
protected byte[] tableName
```

method
```
protected String method
```

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

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

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

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

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

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

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

testDeleteColumns_PostInsert

public void testDeleteColumns_PostInsert()
                                  throws IOException,
                                         InterruptedException

Throws:: IOException; InterruptedException

testDeleteFamily_PostInsert

public void testDeleteFamily_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

testMerge

public void testMerge()
               throws IOException

Throws:: IOException

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

testBasicSplit
```
public void testBasicSplit()
                    throws Exception
```
Splits twice and verifies getting from each of the split regions.

Throws:

Exception

testSplitRegion

public void testSplitRegion()
                     throws IOException

Throws:: IOException

testClearForceSplit

public void testClearForceSplit()
                         throws IOException

Throws:: IOException

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

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

Throws:

IOException

initHRegion

public static HRegion initHRegion(TableName tableName,
                                  String callingMethod,
                                  Configuration conf,
                                  byte[]... families)
                           throws IOException

Parameters:: tableName -; callingMethod -; conf -; families -
Returns:: A region on which you must call HRegion.closeHRegion(HRegion) when done.
Throws:: IOException

initHRegion

public static HRegion initHRegion(byte[] tableName,
                                  String callingMethod,
                                  Configuration conf,
                                  byte[]... families)
                           throws IOException

Parameters:: tableName -; callingMethod -; conf -; families -
Returns:: A region on which you must call HRegion.closeHRegion(HRegion) when done.
Throws:: IOException

initHRegion

public static HRegion initHRegion(byte[] tableName,
                                  String callingMethod,
                                  Configuration conf,
                                  boolean isReadOnly,
                                  byte[]... families)
                           throws IOException

Parameters:: tableName -; callingMethod -; conf -; isReadOnly -; families -
Returns:: A region on which you must call HRegion.closeHRegion(HRegion) when done.
Throws:: IOException

initHRegion

public static HRegion initHRegion(byte[] tableName,
                                  byte[] startKey,
                                  byte[] stopKey,
                                  String callingMethod,
                                  Configuration conf,
                                  boolean isReadOnly,
                                  byte[]... families)
                           throws IOException

Throws:: IOException

initHRegion

public static HRegion initHRegion(byte[] tableName,
                                  byte[] startKey,
                                  byte[] stopKey,
                                  String callingMethod,
                                  Configuration conf,
                                  boolean isReadOnly,
                                  Durability durability,
                                  WAL wal,
                                  byte[]... families)
                           throws IOException

Parameters:: tableName -; startKey -; stopKey -; callingMethod -; conf -; isReadOnly -; families -
Returns:: A region on which you must call HRegion.closeHRegion(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

testSplitRegionWithReverseScan

public void testSplitRegionWithReverseScan()
                                    throws IOException

Throws:: IOException

testWriteRequestsCounter

public void testWriteRequestsCounter()
                              throws IOException

Throws:: IOException

testOpenRegionWrittenToWAL

public void testOpenRegionWrittenToWAL()
                                throws Exception

Throws:: Exception

testOpenRegionWrittenToWALForLogReplay

public void testOpenRegionWrittenToWALForLogReplay()
                                            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

Class TestHRegion

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

name

CONF

tableName

method

qual1

qual2

qual3

value1

value2

row

row2

metricsAssertHelper

Constructor Detail

TestHRegion

Method Detail

setup

tearDown

testCloseCarryingSnapshot

testMemstoreSnapshotSize

testFlushSizeAccounting

testCloseWithFailingFlush

testCompactionAffectedByScanners

testToShowNPEOnRegionScannerReseek

testSkipRecoveredEditsReplay

testSkipRecoveredEditsReplaySomeIgnored

testSkipRecoveredEditsReplayAllIgnored

testSkipRecoveredEditsReplayTheLastFileIgnored

testRecoveredEditsReplayCompaction

testRecoveredEditsReplayCompaction

testFlushMarkers

testFlushMarkersWALFail

testGetWhileRegionClose

testWeirdCacheBehaviour

testAppendWithReadOnlyTable

testIncrWithReadOnlyTable

testFamilyWithAndWithoutColon

testBatchPut_whileNoRowLocksHeld

testBatchPut_whileMultipleRowLocksHeld

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

testDeleteColumns_PostInsert

testDeleteFamily_PostInsert

doTestDelete_AndPostInsert

testDelete_CheckTimestampUpdated

testGet_FamilyChecker

testGet_Basic

testGet_Empty

testMerge

testGetScanner_WithOkFamilies

testGetScanner_WithNotOkFamilies

testGetScanner_WithNoFamilies

testGetScanner_WithRegionClosed

testRegionScanner_Next

testScanner_ExplicitColumns_FromMemStore_EnforceVersions

testScanner_ExplicitColumns_FromFilesOnly_EnforceVersions

testScanner_ExplicitColumns_FromMemStoreAndFiles_EnforceVersions

testScanner_Wildcard_FromMemStore_EnforceVersions

testScanner_Wildcard_FromFilesOnly_EnforceVersions

testScanner_StopRow1542

testScanner_Wildcard_FromMemStoreAndFiles_EnforceVersions