HBaseTestingUtility (Hortonworks Data Platform Apache HBase Java API Reference)

java.lang.Object
- org.apache.hadoop.hbase.HBaseCommonTestingUtility
- - org.apache.hadoop.hbase.HBaseTestingUtility

Direct Known Subclasses:

IntegrationTestingUtility
```
@InterfaceAudience.Public
 @InterfaceStability.Evolving
public class HBaseTestingUtility
extends HBaseCommonTestingUtility
```
Facility for testing HBase. Replacement for old HBaseTestCase and HBaseClusterTestCase functionality. Create an instance and keep it around testing HBase. This class is meant to be your one-stop shop for anything you might need testing. Manages one cluster at a time only. Managed cluster can be an in-process MiniHBaseCluster, or a deployed cluster of type DistributedHBaseCluster. Not all methods work with the real cluster. Depends on log4j being on classpath and hbase-site.xml for logging and test-run configuration. It does not set logging levels nor make changes to configuration parameters.
To preserve test data directories, pass the system property "hbase.testing.preserve.testdir" setting it to true.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`HBaseTestingUtility.SeenRowTracker` A tracker for tracking and validating table rows generated with `HBaseTestingUtility#loadTable(HTable, byte[])`

Field Summary

Fields
Modifier and Type	Field and Description
`static Collection<Object[]>`	`BLOOM_AND_COMPRESSION_COMBINATIONS`
`static List<Object[]>`	`BOOLEAN_PARAMETERIZED` This is for unit tests parameterized with a two booleans.
`static byte[][]`	`COLUMNS`
`static Compression.Algorithm[]`	`COMPRESSION_ALGORITHMS` Compression algorithms to use in testing
`static List<Object[]>`	`COMPRESSION_ALGORITHMS_PARAMETERIZED` Compression algorithms to use in parameterized JUnit 4 tests
`static int`	`DEFAULT_REGIONS_PER_SERVER` The default number of regions per regionserver when creating a pre-split table.
`static byte[]`	`fam1`
`static byte[]`	`fam2`
`static byte[]`	`fam3`
`static char`	`FIRST_CHAR`
`static byte[][]`	`KEYS`
`static byte[][]`	`KEYS_FOR_HBA_CREATE_TABLE`
`static char`	`LAST_CHAR`
`static List<Object[]>`	`MEMSTORETS_TAGS_PARAMETRIZED` This is for unit tests parameterized with a single boolean.
`static String`	`REGIONS_PER_SERVER_KEY`
`static byte[][]`	`ROWS` All the row values for the data loaded by `#loadTable(HTable, byte[])`
`static String`	`START_KEY`
`static byte[]`	`START_KEY_BYTES`

Fields inherited from class org.apache.hadoop.hbase.HBaseCommonTestingUtility
BASE_TEST_DIRECTORY_KEY, conf, DEFAULT_BASE_TEST_DIRECTORY, LOG

Constructor Summary

Constructors
Constructor and Description

HBaseTestingUtility()

HBaseTestingUtility(Configuration conf)

Constructors
Constructor and Description
`HBaseTestingUtility()`
`HBaseTestingUtility(Configuration conf)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static void`	`assertKVListsEqual(String additionalMsg, List<? extends Cell> expected, List<? extends Cell> actual)`
`void`	`assertRegionOnlyOnServer(HRegionInfo hri, ServerName server, long timeout)` Check to make sure the region is open on the specified region server, but not on any other one.
`void`	`assertRegionOnServer(HRegionInfo hri, ServerName server, long timeout)` Due to async racing issue, a region may not be in the online region list of a region server yet, after the assignment znode is deleted and the new assignment is recorded in master.
`String`	`checksumRows(Table table)` Return an md5 digest of the entire contents of a table.
`boolean`	`cleanupDataTestDirOnTestFS()` Cleans the test data directory on the test filesystem.
`boolean`	`cleanupDataTestDirOnTestFS(String subdirName)` Cleans a subdirectory under the test data directory on the test filesystem.
`boolean`	`cleanupTestDir()`
`void`	`closeRegion(byte[] regionName)` Closes the named region.
`static void`	`closeRegion(Region r)` Close the Region `r`.
`void`	`closeRegion(String regionName)` Closes the named region.
`static void`	`closeRegionAndWAL(HRegion r)` Close both the HRegion `r` and it's underlying WAL.
`static void`	`closeRegionAndWAL(Region r)` Close both the region `r` and it's underlying WAL.
`void`	`closeRegionByRow(byte[] row, RegionLocator table)` Closes the region containing the given row.
`void`	`closeRegionByRow(String row, RegionLocator table)` Closes the region containing the given row.
`void`	`compact(boolean major)` Compact all regions in the mini hbase cluster
`void`	`compact(TableName tableName, boolean major)` Compact all of a table's reagion in the mini hbase cluster
`int`	`countRows(Table table)` Return the number of rows in the given table.
`int`	`countRows(Table table, byte[]... families)`
`int`	`countRows(TableName tableName)` Return the number of rows in the given table.
`static ZooKeeperWatcher`	`createAndForceNodeToOpenedState(HBaseTestingUtility TEST_UTIL, HRegion region, ServerName serverName)` Creates a znode with OPENED state.
`static ZooKeeperWatcher`	`createAndForceNodeToOpenedState(HBaseTestingUtility TEST_UTIL, Region region, ServerName serverName)` Creates a znode with OPENED state.
`HRegion`	`createHRegion(HRegionInfo info, Path rootDir, Configuration conf, HTableDescriptor htd)` Create an HRegion.
`HRegion`	`createLocalHRegion(byte[] tableName, byte[] startKey, byte[] stopKey, String callingMethod, Configuration conf, boolean isReadOnly, Durability durability, WAL wal, byte[]... families)`
`HRegion`	`createLocalHRegion(HRegionInfo info, HTableDescriptor desc)` Create an HRegion that writes to the local tmp dirs
`HRegion`	`createLocalHRegion(HRegionInfo info, HTableDescriptor desc, WAL wal)` Create an HRegion that writes to the local tmp dirs with specified wal
`HRegion`	`createLocalHRegion(HTableDescriptor desc, byte[] startKey, byte[] endKey)` Create an HRegion that writes to the local tmp dirs
`static HBaseTestingUtility`	`createLocalHTU()` Create an HBaseTestingUtility where all tmp files are written to the local test data dir.
`static HBaseTestingUtility`	`createLocalHTU(Configuration c)` Create an HBaseTestingUtility where all tmp files are written to the local test data dir.
`RegionServerServices`	`createMockRegionServerService()` Create a stubbed out RegionServerService, mainly for getting FS.
`RegionServerServices`	`createMockRegionServerService(RpcServerInterface rpc)` Create a stubbed out RegionServerService, mainly for getting FS.
`RegionServerServices`	`createMockRegionServerService(ServerName name)` Create a stubbed out RegionServerService, mainly for getting FS.
`List<HRegionInfo>`	`createMultiRegionsInMeta(Configuration conf, HTableDescriptor htd, byte[][] startKeys)` Create rows in hbase:meta for regions of the specified table with the specified start keys.
`HTable`	`createMultiRegionTable(TableName tableName, byte[] family)` Create a table with multiple regions.
`HTable`	`createMultiRegionTable(TableName tableName, byte[][] families)` Create a table with multiple regions.
`HTable`	`createMultiRegionTable(TableName tableName, byte[][] families, int numVersions)` Create a table with multiple regions.
`HTable`	`createMultiRegionTable(TableName tableName, byte[] family, int numRegions)` Create a table with multiple regions.
`static int`	`createPreSplitLoadTestTable(Configuration conf, HTableDescriptor desc, HColumnDescriptor hcd)` Creates a pre-split table for load testing.
`static int`	`createPreSplitLoadTestTable(Configuration conf, HTableDescriptor desc, HColumnDescriptor[] hcds, int numRegionsPerServer)` Creates a pre-split table for load testing.
`static int`	`createPreSplitLoadTestTable(Configuration conf, HTableDescriptor desc, HColumnDescriptor hcd, int numRegionsPerServer)` Creates a pre-split table for load testing.
`static int`	`createPreSplitLoadTestTable(Configuration conf, TableName tableName, byte[][] columnFamilies, Compression.Algorithm compression, DataBlockEncoding dataBlockEncoding, int numRegionsPerServer, int regionReplication, Durability durability)` Creates a pre-split table for load testing.
`static int`	`createPreSplitLoadTestTable(Configuration conf, TableName tableName, byte[] columnFamily, Compression.Algorithm compression, DataBlockEncoding dataBlockEncoding)` Creates a pre-split table for load testing.
`static int`	`createPreSplitLoadTestTable(Configuration conf, TableName tableName, byte[] columnFamily, Compression.Algorithm compression, DataBlockEncoding dataBlockEncoding, int numRegionsPerServer, int regionReplication, Durability durability)` Creates a pre-split table for load testing.
`HTable`	`createRandomTable(String tableName, Collection<String> families, int maxVersions, int numColsPerRow, int numFlushes, int numRegions, int numRowsPerFlush)` Creates a random table with the given parameters
`static HRegion`	`createRegionAndWAL(HRegionInfo info, Path rootDir, Configuration conf, HTableDescriptor htd)` Create a region with it's own WAL.
`static HRegion`	`createRegionAndWAL(HRegionInfo info, Path rootDir, Configuration conf, HTableDescriptor htd, boolean initialize)` Create a region with it's own WAL.
`Path`	`createRootDir()` Same as `createRootDir(boolean create)` except that `create` flag is false.
`Path`	`createRootDir(boolean create)` Creates an hbase rootdir in user home directory.
`HTable`	`createTable(byte[] tableName, byte[] family)` Create a table.
`HTable`	`createTable(byte[] tableName, byte[][] families)` Create a table.
`HTable`	`createTable(byte[] tableName, byte[][] families, Configuration c)` Create a table.
`HTable`	`createTable(byte[] tableName, byte[][] families, Configuration c, int numVersions)` Create a table.
`HTable`	`createTable(byte[] tableName, byte[][] families, int numVersions, byte[] startKey, byte[] endKey, int numRegions)`
`HTable`	`createTable(byte[] tableName, byte[] family, byte[][] splitRows)` Create a table.
`HTable`	`createTable(byte[] tableName, byte[] family, int numVersions)` Create a table.
`HTable`	`createTable(HTableDescriptor htd, byte[][] splitRows)` Create a table.
`HTable`	`createTable(HTableDescriptor htd, byte[][] families, byte[][] splitKeys, Configuration c)` Create a table.
`HTable`	`createTable(HTableDescriptor htd, byte[][] families, Configuration c)` Create a table.
`HTable`	`createTable(String tableName, byte[][] families, int numVersions, byte[] startKey, byte[] endKey, int numRegions)`
`HTable`	`createTable(TableName tableName, byte[] family)` Create a table.
`HTable`	`createTable(TableName tableName, byte[][] families)` Create a table.
`HTable`	`createTable(TableName tableName, byte[][] families, byte[][] splitKeys)` Create a table.
`HTable`	`createTable(TableName tableName, byte[][] families, byte[][] splitKeys, Configuration c)` Create a table.
`HTable`	`createTable(TableName tableName, byte[][] families, Configuration c)` Create a table.
`HTable`	`createTable(TableName tableName, byte[][] families, Configuration c, int numVersions)` Create a table.
`HTable`	`createTable(TableName tableName, byte[][] families, int numVersions, byte[][] splitKeys)` Create a table.
`HTable`	`createTable(TableName tableName, byte[][] families, int numVersions, byte[] startKey, byte[] endKey, int numRegions)`
`HTable`	`createTable(TableName tableName, byte[] family, byte[][] splitRows)` Create a table.
`HTable`	`createTable(TableName tableName, byte[] family, int numVersions)` Create a table.
`Table`	`createTable(TableName tableName, String family)` Create a table.
`Table`	`createTable(TableName tableName, String[] families)` Create a table.
`HTableDescriptor`	`createTableDescriptor(String name)` Create a table of name `name` with `COLUMNS` for families.
`HTableDescriptor`	`createTableDescriptor(String name, int minVersions, int versions, int ttl, KeepDeletedCells keepDeleted)` Create a table of name `name` with `COLUMNS` for families.
`HRegion`	`createTestRegion(String tableName, HColumnDescriptor hcd)`
`static WAL`	`createWal(Configuration conf, Path rootDir, HRegionInfo hri)` Create an unmanaged WAL.
`void`	`deleteNumericRows(HTable t, byte[] f, int startRow, int endRow)`
`void`	`deleteTable(byte[] tableName)` Drop an existing table
`void`	`deleteTable(String tableName)` Drop an existing table
`void`	`deleteTable(TableName tableName)` Drop an existing table
`HTable`	`deleteTableData(byte[] tableName)` Provide an existing table name to truncate.
`HTable`	`deleteTableData(TableName tableName)` Provide an existing table name to truncate.
`void`	`deleteTableIfAny(TableName tableName)` Drop an existing table
`void`	`enableDebug(Class<?> clazz)` Switches the logger for the given class to DEBUG level.
`boolean`	`ensureSomeNonStoppedRegionServersAvailable(int num)` Make sure that at least the specified number of region servers are running.
`boolean`	`ensureSomeRegionServersAvailable(int num)` Make sure that at least the specified number of region servers are running
`void`	`expireMasterSession()` Expire the Master's session
`void`	`expireRegionServerSession(int index)` Expire a region server's session
`void`	`expireSession(ZooKeeperWatcher nodeZK)`
`void`	`expireSession(ZooKeeperWatcher nodeZK, boolean checkStatus)` Expire a ZooKeeper session as recommended in ZooKeeper documentation http://wiki.apache.org/hadoop/ZooKeeper/FAQ#A4 There are issues when doing this: [1] http://www.mail-archive.com/dev@zookeeper.apache.org/msg01942.html [2] https://issues.apache.org/jira/browse/ZOOKEEPER-1105
`void`	`expireSession(ZooKeeperWatcher nodeZK, Server server)` Deprecated.
`String`	`explainTableAvailability(TableName tableName)`
`String`	`explainTableState(TableName tableName)`
`void`	`flush()` Flushes all caches in the mini hbase cluster
`void`	`flush(TableName tableName)` Flushes all caches in the mini hbase cluster
`static List<HColumnDescriptor>`	`generateColumnDescriptors()` Create a set of column descriptors with the combination of compression, encoding, bloom codecs available.
`static List<HColumnDescriptor>`	`generateColumnDescriptors(String prefix)` Create a set of column descriptors with the combination of compression, encoding, bloom codecs available.
`static NavigableSet<String>`	`getAllOnlineRegions(MiniHBaseCluster cluster)`
`String`	`getClusterKey()`
`Configuration`	`getConfiguration()` Returns this classes's instance of `Configuration`.
`Connection`	`getConnection()` Get a Connection to the cluster.
`Path`	`getDataTestDirOnTestFS()` Returns a Path in the test filesystem, obtained from `getTestFileSystem()` to write temporary test data.
`Path`	`getDataTestDirOnTestFS(String subdirName)` Returns a Path in the test filesystem, obtained from `getTestFileSystem()` to write temporary test data.
`Path`	`getDefaultRootDirPath()` Same as {`getDefaultRootDirPath(boolean create)` except that `create` flag is false.
`Path`	`getDefaultRootDirPath(boolean create)` Returns the path to the default root dir the minicluster uses.
`MiniDFSCluster`	`getDFSCluster()`
`static User`	`getDifferentUser(Configuration c, String differentiatingSuffix)` This method clones the passed `c` configuration setting a new user into the clone.
`static List<Cell>`	`getFromStoreFile(HStore store, byte[] row, NavigableSet<byte[]> columns)` Do a small get/scan against one store.
`static List<Cell>`	`getFromStoreFile(HStore store, Get get)` Do a small get/scan against one store.
`HBaseAdmin`	`getHBaseAdmin()` Returns a Admin instance.
`MiniHBaseCluster`	`getHBaseCluster()` Get the Mini HBase cluster.
`HBaseCluster`	`getHBaseClusterInterface()` Returns the HBaseCluster instance.
`static int`	`getMetaRSPort(Configuration conf)`
`HTableDescriptor`	`getMetaTableDescriptor()`
`List<byte[]>`	`getMetaTableRows()` Returns all rows from the hbase:meta table.
`List<byte[]>`	`getMetaTableRows(TableName tableName)` Returns all rows from the hbase:meta table for a given user table
`MiniHBaseCluster`	`getMiniHBaseCluster()`
`byte[][]`	`getRegionSplitStartKeys(byte[] startKey, byte[] endKey, int numRegions)` Create region split keys between startkey and endKey
`HRegionServer`	`getRSForFirstRegionInTable(TableName tableName)` Tool to get the reference to the region server object that holds the region of the specified user table.
`HRegion`	`getSplittableRegion(TableName tableName, int maxAttempts)`
`static Compression.Algorithm[]`	`getSupportedCompressionAlgorithms()` Get supported compression algorithms.
`FileSystem`	`getTestFileSystem()`
`MiniZooKeeperCluster`	`getZkCluster()`
`ZooKeeperWatcher`	`getZooKeeperWatcher()` Returns a ZooKeeperWatcher instance.
`static ZooKeeperWatcher`	`getZooKeeperWatcher(HBaseTestingUtility TEST_UTIL)` Gets a ZooKeeperWatcher.
`boolean`	`isReadShortCircuitOn()` Get the HBase setting for dfs.client.read.shortcircuit from the conf or a system property.
`void`	`loadNumericRows(Table t, byte[] f, int startRow, int endRow)`
`int`	`loadRegion(HRegion r, byte[] f)`
`int`	`loadRegion(HRegion r, byte[] f, boolean flush)` Load region with rows from 'aaa' to 'zzz'.
`int`	`loadRegion(Region r, byte[] f)`
`int`	`loadTable(Table t, byte[] f)` Load table with rows from 'aaa' to 'zzz'.
`int`	`loadTable(Table t, byte[][] f)` Load table of multiple column families with rows from 'aaa' to 'zzz'.
`int`	`loadTable(Table t, byte[][] f, byte[] value)` Load table of multiple column families with rows from 'aaa' to 'zzz'.
`int`	`loadTable(Table t, byte[][] f, byte[] value, boolean writeToWAL)` Load table of multiple column families with rows from 'aaa' to 'zzz'.
`int`	`loadTable(Table t, byte[] f, boolean writeToWAL)` Load table with rows from 'aaa' to 'zzz'.
`static void`	`modifyTableSync(Admin admin, HTableDescriptor desc)` Modify a table, synchronous.
`Waiter.ExplainingPredicate<IOException>`	`predicateNoRegionsInTransition()` Returns a `Waiter.Predicate` for checking that there are no regions in transition in master
`Waiter.Predicate<IOException>`	`predicateTableAvailable(TableName tableName)` Returns a `Waiter.Predicate` for checking that table is enabled
`Waiter.Predicate<IOException>`	`predicateTableDisabled(TableName tableName)` Returns a `Waiter.Predicate` for checking that table is enabled
`Waiter.Predicate<IOException>`	`predicateTableEnabled(TableName tableName)` Returns a `Waiter.Predicate` for checking that table is enabled
`static int`	`randomFreePort()` Returns a random free port and marks that port as taken.
`static String`	`randomMultiCastAddress()`
`static int`	`randomPort()` Returns a random port.
`void`	`restartHBaseCluster(int servers)` Starts the hbase cluster up again after shutting it down previously in a test.
`static <T> String`	`safeGetAsStr(List<T> lst, int i)`
`void`	`setDFSCluster(MiniDFSCluster cluster)`
`void`	`setDFSCluster(MiniDFSCluster cluster, boolean requireDown)` Set the MiniDFSCluster
`void`	`setFileSystemURI(String fsURI)`
`void`	`setHBaseCluster(HBaseCluster hbaseCluster)`
`static void`	`setMaxRecoveryErrorCount(OutputStream stream, int max)` Set maxRecoveryErrorCount in DFSClient.
`static void`	`setReplicas(Admin admin, TableName table, int replicaCount)` Set the number of Region replicas.
`protected Path`	`setupDataTestDir()` Home our data in a dir under `HBaseCommonTestingUtility.DEFAULT_BASE_TEST_DIRECTORY`.
`void`	`setZkCluster(MiniZooKeeperCluster zkCluster)`
`void`	`shutdownMiniCluster()` Stops mini hbase, zk, and hdfs clusters.
`void`	`shutdownMiniDFSCluster()` Shuts down instance created by call to `startMiniDFSCluster(int)` or does nothing.
`void`	`shutdownMiniHBaseCluster()` Shutdown HBase mini cluster.
`void`	`shutdownMiniMapReduceCluster()` Stops the previously started `MiniMRCluster`.
`void`	`shutdownMiniZKCluster()` Shuts down zk cluster created by call to `startMiniZKCluster(File)` or does nothing.
`MiniHBaseCluster`	`startMiniCluster()` Start up a minicluster of hbase, dfs, and zookeeper.
`MiniHBaseCluster`	`startMiniCluster(int numSlaves)` Start up a minicluster of hbase, optionally dfs, and zookeeper.
`MiniHBaseCluster`	`startMiniCluster(int numSlaves, boolean create)` Start up a minicluster of hbase, dfs, and zookeeper.
`MiniHBaseCluster`	`startMiniCluster(int numMasters, int numSlaves)` start minicluster
`MiniHBaseCluster`	`startMiniCluster(int numMasters, int numSlaves, boolean create)` Start minicluster.
`MiniHBaseCluster`	`startMiniCluster(int numMasters, int numSlaves, int numDataNodes)` Same as `startMiniCluster(int, int)`, but with custom number of datanodes.
`MiniHBaseCluster`	`startMiniCluster(int numMasters, int numSlaves, int numDataNodes, String[] dataNodeHosts, Class<? extends HMaster> masterClass, Class<? extends MiniHBaseCluster.MiniHBaseClusterRegionServer> regionserverClass)`
`MiniHBaseCluster`	`startMiniCluster(int numMasters, int numSlaves, int numDataNodes, String[] dataNodeHosts, Class<? extends HMaster> masterClass, Class<? extends MiniHBaseCluster.MiniHBaseClusterRegionServer> regionserverClass, boolean create)` Same as `startMiniCluster(int, int, String[], Class, Class)`, but with custom number of datanodes.
`MiniHBaseCluster`	`startMiniCluster(int numMasters, int numSlaves, String[] dataNodeHosts)` Start up a minicluster of hbase, optionally dfs, and zookeeper.
`MiniHBaseCluster`	`startMiniCluster(int numMasters, int numSlaves, String[] dataNodeHosts, boolean create)`
`MiniHBaseCluster`	`startMiniCluster(int numMasters, int numSlaves, String[] dataNodeHosts, Class<? extends HMaster> masterClass, Class<? extends MiniHBaseCluster.MiniHBaseClusterRegionServer> regionserverClass)` Start up a minicluster of hbase, optionally dfs, and zookeeper.
`MiniDFSCluster`	`startMiniDFSCluster(int servers)` Start a minidfscluster.
`MiniDFSCluster`	`startMiniDFSCluster(int servers, String[] hosts)` Start a minidfscluster.
`MiniDFSCluster`	`startMiniDFSCluster(int servers, String[] racks, String[] hosts)`
`MiniDFSCluster`	`startMiniDFSCluster(String[] hosts)` Start a minidfscluster.
`MiniDFSCluster`	`startMiniDFSClusterForTestWAL(int namenodePort)`
`MiniHBaseCluster`	`startMiniHBaseCluster(int numMasters, int numSlaves)`
`MiniHBaseCluster`	`startMiniHBaseCluster(int numMasters, int numSlaves, Class<? extends HMaster> masterClass, Class<? extends MiniHBaseCluster.MiniHBaseClusterRegionServer> regionserverClass, boolean create)` Starts up mini hbase cluster.
`MiniMRCluster`	`startMiniMapReduceCluster()` Starts a `MiniMRCluster` with a default number of `TaskTracker`'s.
`MiniZooKeeperCluster`	`startMiniZKCluster()` Call this if you only want a zk cluster.
`MiniZooKeeperCluster`	`startMiniZKCluster(int zooKeeperServerNum, int... clientPortList)` Call this if you only want a zk cluster.
`HTable`	`truncateTable(byte[] tableName)` Truncate a table using the admin command.
`HTable`	`truncateTable(byte[] tableName, boolean preserveRegions)` Truncate a table using the admin command.
`HTable`	`truncateTable(TableName tableName)` Truncate a table using the admin command.
`HTable`	`truncateTable(TableName tableName, boolean preserveRegions)` Truncate a table using the admin command.
`void`	`verifyNumericRows(HRegion region, byte[] f, int startRow, int endRow)`
`void`	`verifyNumericRows(HRegion region, byte[] f, int startRow, int endRow, boolean present)`
`void`	`verifyNumericRows(Region region, byte[] f, int startRow, int endRow)`
`void`	`verifyNumericRows(Region region, byte[] f, int startRow, int endRow, boolean present)`
`void`	`verifyNumericRows(Table table, byte[] f, int startRow, int endRow, int replicaId)`
`<E extends Exception> long`	`waitFor(long timeout, long interval, boolean failIfTimeout, Waiter.Predicate<E> predicate)` Wrapper method for `Waiter.waitFor(Configuration, long, long, boolean, Predicate)`.
`<E extends Exception> long`	`waitFor(long timeout, long interval, Waiter.Predicate<E> predicate)` Wrapper method for `Waiter.waitFor(Configuration, long, long, Predicate)`.
`<E extends Exception> long`	`waitFor(long timeout, Waiter.Predicate<E> predicate)` Wrapper method for `Waiter.waitFor(Configuration, long, Predicate)`.
`static void`	`waitForHostPort(String host, int port)`
`void`	`waitLabelAvailable(long timeoutMillis, String... labels)` Wait until labels is ready in VisibilityLabelsCache.
`void`	`waitTableAvailable(Admin admin, byte[] table, long timeoutMillis)`
`void`	`waitTableAvailable(byte[] table, long timeoutMillis)` Wait until all regions in a table have been assigned
`void`	`waitTableAvailable(TableName table)` Wait until all regions in a table have been assigned.
`void`	`waitTableAvailable(TableName table, long timeoutMillis)`
`void`	`waitTableDisabled(Admin admin, byte[] table)`
`void`	`waitTableDisabled(Admin admin, byte[] table, long timeoutMillis)`
`void`	`waitTableDisabled(byte[] table)` Waits for a table to be 'disabled'.
`void`	`waitTableDisabled(byte[] table, long timeoutMillis)` Waits for a table to be 'disabled'.
`void`	`waitTableEnabled(byte[] table, long timeoutMillis)` Waits for a table to be 'enabled'.
`void`	`waitTableEnabled(TableName table)` Waits for a table to be 'enabled'.
`void`	`waitTableEnabled(TableName table, long timeoutMillis)`
`void`	`waitUntilAllRegionsAssigned(TableName tableName)` Wait until all regions for a table in hbase:meta have a non-empty info:server, up to 60 seconds.
`void`	`waitUntilAllRegionsAssigned(TableName tableName, long timeout)` Wait until all regions for a table in hbase:meta have a non-empty info:server, or until timeout.
`void`	`waitUntilNoRegionsInTransition(long timeout)` Wait until no regions in transition.

Methods inherited from class org.apache.hadoop.hbase.HBaseCommonTestingUtility
createSubDir, getDataTestDir, getDataTestDir

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

Field Detail

REGIONS_PER_SERVER_KEY

public static final String REGIONS_PER_SERVER_KEY

See Also:: Constant Field Values

DEFAULT_REGIONS_PER_SERVER
```
public static final int DEFAULT_REGIONS_PER_SERVER
```
The default number of regions per regionserver when creating a pre-split table.

See Also:

Constant Field Values

COMPRESSION_ALGORITHMS_PARAMETERIZED
```
public static final List<Object[]> COMPRESSION_ALGORITHMS_PARAMETERIZED
```
Compression algorithms to use in parameterized JUnit 4 tests

BOOLEAN_PARAMETERIZED
```
public static final List<Object[]> BOOLEAN_PARAMETERIZED
```
This is for unit tests parameterized with a two booleans.

MEMSTORETS_TAGS_PARAMETRIZED
```
public static final List<Object[]> MEMSTORETS_TAGS_PARAMETRIZED
```
This is for unit tests parameterized with a single boolean.

COMPRESSION_ALGORITHMS

public static final Compression.Algorithm[] COMPRESSION_ALGORITHMS

Compression algorithms to use in testing

BLOOM_AND_COMPRESSION_COMBINATIONS

public static final Collection<Object[]> BLOOM_AND_COMPRESSION_COMBINATIONS

fam1
```
public static final byte[] fam1
```

fam2
```
public static final byte[] fam2
```

fam3
```
public static final byte[] fam3
```

COLUMNS
```
public static final byte[][] COLUMNS
```

FIRST_CHAR
```
public static final char FIRST_CHAR
```
See Also:

Constant Field Values

LAST_CHAR
```
public static final char LAST_CHAR
```
See Also:

Constant Field Values

START_KEY_BYTES

public static final byte[] START_KEY_BYTES

START_KEY
```
public static final String START_KEY
```

ROWS
```
public static final byte[][] ROWS
```
All the row values for the data loaded by #loadTable(HTable, byte[])

KEYS
```
public static final byte[][] KEYS
```

KEYS_FOR_HBA_CREATE_TABLE

public static final byte[][] KEYS_FOR_HBA_CREATE_TABLE

Constructor Detail

HBaseTestingUtility
```
public HBaseTestingUtility()
```

HBaseTestingUtility

public HBaseTestingUtility(Configuration conf)

Method Detail

createLocalHTU
```
public static HBaseTestingUtility createLocalHTU()
```
Create an HBaseTestingUtility where all tmp files are written to the local test data dir. It is needed to properly base FSUtil.getRootDirs so that they drop temp files in the proper test dir. Use this when you aren't using an Mini HDFS cluster.

Returns:

HBaseTestingUtility that use local fs for temp files.

createLocalHTU
```
public static HBaseTestingUtility createLocalHTU(Configuration c)
```
Create an HBaseTestingUtility where all tmp files are written to the local test data dir. It is needed to properly base FSUtil.getRootDirs so that they drop temp files in the proper test dir. Use this when you aren't using an Mini HDFS cluster.

Parameters:

c - Configuration (will be modified)

Returns:

HBaseTestingUtility that use local fs for temp files.

closeRegion

public static void closeRegion(Region r)
                        throws IOException

Close the Region r. For use in tests.

Throws:: IOException

getConfiguration
```
public Configuration getConfiguration()
```
Returns this classes's instance of Configuration. Be careful how you use the returned Configuration since HConnection instances can be shared. The Map of HConnections is keyed by the Configuration. If say, a Connection was being used against a cluster that had been shutdown, see shutdownMiniCluster(), then the Connection will no longer be wholesome. Rather than use the return direct, its usually best to make a copy and use that. Do Configuration c = new Configuration(INSTANCE.getConfiguration());

Overrides:

getConfiguration in class HBaseCommonTestingUtility

Returns:

Instance of Configuration.

setHBaseCluster

public void setHBaseCluster(HBaseCluster hbaseCluster)

setupDataTestDir
```
protected Path setupDataTestDir()
```
Home our data in a dir under HBaseCommonTestingUtility.DEFAULT_BASE_TEST_DIRECTORY. Give it a random name so can have many concurrent tests running if we need to. It needs to amend the TEST_DIRECTORY_KEY System property, as it's what minidfscluster bases it data dir on. Moding a System property is not the way to do concurrent instances -- another instance could grab the temporary value unintentionally -- but not anything can do about it at moment; single instance only is how the minidfscluster works. We also create the underlying directory for hadoop.log.dir, mapreduce.cluster.local.dir and hadoop.tmp.dir, and set the values in the conf, and as a system property for hadoop.tmp.dir

Overrides:

setupDataTestDir in class HBaseCommonTestingUtility

Returns:

The calculated data test build directory, if newly-created.

getMetaTableDescriptor

public HTableDescriptor getMetaTableDescriptor()

Returns:: META table descriptor

getDataTestDirOnTestFS
```
public Path getDataTestDirOnTestFS()
                            throws IOException
```
Returns a Path in the test filesystem, obtained from getTestFileSystem() to write temporary test data. Call this method after setting up the mini dfs cluster if the test relies on it.

Returns:

a unique path in the test filesystem

Throws:

IOException

getDataTestDirOnTestFS
```
public Path getDataTestDirOnTestFS(String subdirName)
                            throws IOException
```
Returns a Path in the test filesystem, obtained from getTestFileSystem() to write temporary test data. Call this method after setting up the mini dfs cluster if the test relies on it.

Parameters:

subdirName - name of the subdir to create under the base test dir

Returns:

a unique path in the test filesystem

Throws:

IOException

cleanupDataTestDirOnTestFS
```
public boolean cleanupDataTestDirOnTestFS()
                                   throws IOException
```
Cleans the test data directory on the test filesystem.

Returns:

True if we removed the test dirs

Throws:

IOException

cleanupDataTestDirOnTestFS
```
public boolean cleanupDataTestDirOnTestFS(String subdirName)
                                   throws IOException
```
Cleans a subdirectory under the test data directory on the test filesystem.

Returns:

True if we removed child

Throws:

IOException

startMiniDFSCluster
```
public MiniDFSCluster startMiniDFSCluster(int servers)
                                   throws Exception
```
Start a minidfscluster.

Parameters:

servers - How many DNs to start.

Returns:

The mini dfs cluster created.

Throws:

Exception

See Also:

#shutdownMiniDFSCluster()}

startMiniDFSCluster
```
public MiniDFSCluster startMiniDFSCluster(String[] hosts)
                                   throws Exception
```
Start a minidfscluster. This is useful if you want to run datanode on distinct hosts for things like HDFS block location verification. If you start MiniDFSCluster without host names, all instances of the datanodes will have the same host name.

Parameters:

hosts - hostnames DNs to run on.

Returns:

The mini dfs cluster created.

Throws:

Exception

See Also:

#shutdownMiniDFSCluster()}

startMiniDFSCluster
```
public MiniDFSCluster startMiniDFSCluster(int servers,
                                          String[] hosts)
                                   throws Exception
```
Start a minidfscluster. Can only create one.

Parameters:

servers - How many DNs to start.

hosts - hostnames DNs to run on.

Returns:

The mini dfs cluster created.

Throws:

Exception

See Also:

#shutdownMiniDFSCluster()}

startMiniDFSCluster

public MiniDFSCluster startMiniDFSCluster(int servers,
                                          String[] racks,
                                          String[] hosts)
                                   throws Exception

Throws:: Exception

startMiniDFSClusterForTestWAL

public MiniDFSCluster startMiniDFSClusterForTestWAL(int namenodePort)
                                             throws IOException

Throws:: IOException

isReadShortCircuitOn
```
public boolean isReadShortCircuitOn()
```
Get the HBase setting for dfs.client.read.shortcircuit from the conf or a system property. This allows to specify this parameter on the command line. If not set, default is true.

shutdownMiniDFSCluster
```
public void shutdownMiniDFSCluster()
                            throws IOException
```
Shuts down instance created by call to startMiniDFSCluster(int) or does nothing.

Throws:

IOException

startMiniZKCluster
```
public MiniZooKeeperCluster startMiniZKCluster()
                                        throws Exception
```
Call this if you only want a zk cluster.

Returns:

zk cluster started.

Throws:

Exception

See Also:

if you want zk + dfs + hbase mini cluster., shutdownMiniZKCluster()

startMiniZKCluster

public MiniZooKeeperCluster startMiniZKCluster(int zooKeeperServerNum,
                                               int... clientPortList)
                                        throws Exception

Call this if you only want a zk cluster.

Parameters:: zooKeeperServerNum -
Returns:: zk cluster started.
Throws:: Exception
See Also:: if you want zk + dfs + hbase mini cluster., shutdownMiniZKCluster()

shutdownMiniZKCluster
```
public void shutdownMiniZKCluster()
                           throws IOException
```
Shuts down zk cluster created by call to startMiniZKCluster(File) or does nothing.

Throws:

IOException

See Also:

startMiniZKCluster()

startMiniCluster
```
public MiniHBaseCluster startMiniCluster()
                                  throws Exception
```
Start up a minicluster of hbase, dfs, and zookeeper.

Returns:

Mini hbase cluster instance created.

Throws:

Exception

See Also:

#shutdownMiniDFSCluster()}

startMiniCluster
```
public MiniHBaseCluster startMiniCluster(int numSlaves,
                                         boolean create)
                                  throws Exception
```
Start up a minicluster of hbase, dfs, and zookeeper. Set the create flag to create root or data directory path or not (will overwrite if dir already exists)

Returns:

Mini hbase cluster instance created.

Throws:

Exception

See Also:

#shutdownMiniDFSCluster()}

startMiniCluster
```
public MiniHBaseCluster startMiniCluster(int numSlaves)
                                  throws Exception
```
Start up a minicluster of hbase, optionally dfs, and zookeeper. Modifies Configuration. Homes the cluster data directory under a random subdirectory in a directory under System property test.build.data. Directory is cleaned up on exit.

Parameters:

numSlaves - Number of slaves to start up. We'll start this many datanodes and regionservers. If numSlaves is > 1, then make sure hbase.regionserver.info.port is -1 (i.e. no ui per regionserver) otherwise bind errors.

Returns:

Mini hbase cluster instance created.

Throws:

Exception

See Also:

#shutdownMiniCluster()}

startMiniCluster
```
public MiniHBaseCluster startMiniCluster(int numMasters,
                                         int numSlaves,
                                         boolean create)
                                  throws Exception
```
Start minicluster. Whether to create a new root or data dir path even if such a path has been created earlier is decided based on flag create

Returns:

Mini hbase cluster instance created.

Throws:

Exception

See Also:

#shutdownMiniCluster()}

startMiniCluster

public MiniHBaseCluster startMiniCluster(int numMasters,
                                         int numSlaves)
                                  throws Exception

start minicluster

Returns:: Mini hbase cluster instance created.
Throws:: Exception
See Also:: #shutdownMiniCluster()}

startMiniCluster

public MiniHBaseCluster startMiniCluster(int numMasters,
                                         int numSlaves,
                                         String[] dataNodeHosts,
                                         boolean create)
                                  throws Exception

Throws:: Exception

startMiniCluster
```
public MiniHBaseCluster startMiniCluster(int numMasters,
                                         int numSlaves,
                                         String[] dataNodeHosts)
                                  throws Exception
```
Start up a minicluster of hbase, optionally dfs, and zookeeper. Modifies Configuration. Homes the cluster data directory under a random subdirectory in a directory under System property test.build.data. Directory is cleaned up on exit.

Parameters:

numMasters - Number of masters to start up. We'll start this many hbase masters. If numMasters > 1, you can find the active/primary master with MiniHBaseCluster.getMaster().

numSlaves - Number of slaves to start up. We'll start this many regionservers. If dataNodeHosts == null, this also indicates the number of datanodes to start. If dataNodeHosts != null, the number of datanodes is based on dataNodeHosts.length. If numSlaves is > 1, then make sure hbase.regionserver.info.port is -1 (i.e. no ui per regionserver) otherwise bind errors.

dataNodeHosts - hostnames DNs to run on. This is useful if you want to run datanode on distinct hosts for things like HDFS block location verification. If you start MiniDFSCluster without host names, all instances of the datanodes will have the same host name.

Returns:

Mini hbase cluster instance created.

Throws:

Exception

See Also:

#shutdownMiniCluster()}

startMiniCluster

public MiniHBaseCluster startMiniCluster(int numMasters,
                                         int numSlaves,
                                         int numDataNodes)
                                  throws Exception

Same as startMiniCluster(int, int), but with custom number of datanodes.

Parameters:: numDataNodes - Number of data nodes.
Throws:: Exception

startMiniCluster
```
public MiniHBaseCluster startMiniCluster(int numMasters,
                                         int numSlaves,
                                         String[] dataNodeHosts,
                                         Class<? extends HMaster> masterClass,
                                         Class<? extends MiniHBaseCluster.MiniHBaseClusterRegionServer> regionserverClass)
                                  throws Exception
```
Start up a minicluster of hbase, optionally dfs, and zookeeper. Modifies Configuration. Homes the cluster data directory under a random subdirectory in a directory under System property test.build.data. Directory is cleaned up on exit.

Parameters:

numMasters - Number of masters to start up. We'll start this many hbase masters. If numMasters > 1, you can find the active/primary master with MiniHBaseCluster.getMaster().

numSlaves - Number of slaves to start up. We'll start this many regionservers. If dataNodeHosts == null, this also indicates the number of datanodes to start. If dataNodeHosts != null, the number of datanodes is based on dataNodeHosts.length. If numSlaves is > 1, then make sure hbase.regionserver.info.port is -1 (i.e. no ui per regionserver) otherwise bind errors.

dataNodeHosts - hostnames DNs to run on. This is useful if you want to run datanode on distinct hosts for things like HDFS block location verification. If you start MiniDFSCluster without host names, all instances of the datanodes will have the same host name.

masterClass - The class to use as HMaster, or null for default

regionserverClass - The class to use as HRegionServer, or null for default

Returns:

Mini hbase cluster instance created.

Throws:

Exception

See Also:

#shutdownMiniCluster()}

startMiniCluster

public MiniHBaseCluster startMiniCluster(int numMasters,
                                         int numSlaves,
                                         int numDataNodes,
                                         String[] dataNodeHosts,
                                         Class<? extends HMaster> masterClass,
                                         Class<? extends MiniHBaseCluster.MiniHBaseClusterRegionServer> regionserverClass)
                                  throws Exception

Throws:: Exception

startMiniCluster

public MiniHBaseCluster startMiniCluster(int numMasters,
                                         int numSlaves,
                                         int numDataNodes,
                                         String[] dataNodeHosts,
                                         Class<? extends HMaster> masterClass,
                                         Class<? extends MiniHBaseCluster.MiniHBaseClusterRegionServer> regionserverClass,
                                         boolean create)
                                  throws Exception

Same as startMiniCluster(int, int, String[], Class, Class), but with custom number of datanodes.

Parameters:: numDataNodes - Number of data nodes.; create - Set this flag to create a new root or data directory path or not (will overwrite if exists already).
Throws:: Exception

startMiniHBaseCluster

public MiniHBaseCluster startMiniHBaseCluster(int numMasters,
                                              int numSlaves)
                                       throws IOException,
                                              InterruptedException

Throws:: IOException; InterruptedException

startMiniHBaseCluster

public MiniHBaseCluster startMiniHBaseCluster(int numMasters,
                                              int numSlaves,
                                              Class<? extends HMaster> masterClass,
                                              Class<? extends MiniHBaseCluster.MiniHBaseClusterRegionServer> regionserverClass,
                                              boolean create)
                                       throws IOException,
                                              InterruptedException

Starts up mini hbase cluster. Usually used after call to startMiniCluster(int, int) when doing stepped startup of clusters. Usually you won't want this. You'll usually want startMiniCluster().

Parameters:: numMasters -; numSlaves -; create - Whether to create a root or data directory path or not; will overwrite if exists already.
Returns:: Reference to the hbase mini hbase cluster.
Throws:: IOException; InterruptedException
See Also:: #startMiniCluster()}

restartHBaseCluster
```
public void restartHBaseCluster(int servers)
                         throws IOException,
                                InterruptedException
```
Starts the hbase cluster up again after shutting it down previously in a test. Use this if you want to keep dfs/zk up and just stop/start hbase.

Parameters:

servers - number of region servers

Throws:

IOException

InterruptedException

getMiniHBaseCluster
```
public MiniHBaseCluster getMiniHBaseCluster()
```
Returns:

Current mini hbase cluster. Only has something in it after a call to startMiniCluster().

See Also:

startMiniCluster()

shutdownMiniCluster
```
public void shutdownMiniCluster()
                         throws Exception
```
Stops mini hbase, zk, and hdfs clusters.

Throws:

IOException

Exception

See Also:

#startMiniCluster(int)}

cleanupTestDir
```
public boolean cleanupTestDir()
                       throws IOException
```
Overrides:

cleanupTestDir in class HBaseCommonTestingUtility

Returns:

True if we removed the test dirs

Throws:

IOException

shutdownMiniHBaseCluster
```
public void shutdownMiniHBaseCluster()
                              throws IOException
```
Shutdown HBase mini cluster. Does not shutdown zk or dfs if running.

Throws:

IOException

getDefaultRootDirPath
```
public Path getDefaultRootDirPath(boolean create)
                           throws IOException
```
Returns the path to the default root dir the minicluster uses. If create is true, a new root directory path is fetched irrespective of whether it has been fetched before or not. If false, previous path is used. Note: this does not cause the root dir to be created.

Returns:

Fully qualified path for the default hbase root dir

Throws:

IOException

getDefaultRootDirPath
```
public Path getDefaultRootDirPath()
                           throws IOException
```
Same as {getDefaultRootDirPath(boolean create) except that create flag is false. Note: this does not cause the root dir to be created.

Returns:

Fully qualified path for the default hbase root dir

Throws:

IOException

createRootDir
```
public Path createRootDir(boolean create)
                   throws IOException
```
Creates an hbase rootdir in user home directory. Also creates hbase version file. Normally you won't make use of this method. Root hbasedir is created for you as part of mini cluster startup. You'd only use this method if you were doing manual operation.

Parameters:

create - This flag decides whether to get a new root or data directory path or not, if it has been fetched already. Note : Directory will be made irrespective of whether path has been fetched or not. If directory already exists, it will be overwritten

Returns:

Fully qualified path to hbase root dir

Throws:

IOException

createRootDir
```
public Path createRootDir()
                   throws IOException
```
Same as createRootDir(boolean create) except that create flag is false.

Returns:

Fully qualified path to hbase root dir

Throws:

IOException

flush
```
public void flush()
           throws IOException
```
Flushes all caches in the mini hbase cluster

Throws:

IOException

flush

public void flush(TableName tableName)
           throws IOException

Flushes all caches in the mini hbase cluster

Throws:: IOException

compact

public void compact(boolean major)
             throws IOException

Compact all regions in the mini hbase cluster

Throws:: IOException

compact

public void compact(TableName tableName,
                    boolean major)
             throws IOException

Compact all of a table's reagion in the mini hbase cluster

Throws:: IOException

createTable

public Table createTable(TableName tableName,
                         String family)
                  throws IOException

Create a table.

Parameters:: tableName -; family -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(byte[] tableName,
                          byte[] family)
                   throws IOException

Create a table.

Parameters:: tableName -; family -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public Table createTable(TableName tableName,
                         String[] families)
                  throws IOException

Create a table.

Parameters:: tableName -; families -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(TableName tableName,
                          byte[] family)
                   throws IOException

Create a table.

Parameters:: tableName -; family -
Returns:: An HTable instance for the created table.
Throws:: IOException

createMultiRegionTable

public HTable createMultiRegionTable(TableName tableName,
                                     byte[] family,
                                     int numRegions)
                              throws IOException

Create a table with multiple regions.

Parameters:: tableName -; family -; numRegions -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(byte[] tableName,
                          byte[][] families)
                   throws IOException

Create a table.

Parameters:: tableName -; families -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(TableName tableName,
                          byte[][] families)
                   throws IOException

Create a table.

Parameters:: tableName -; families -
Returns:: An HTable instance for the created table.
Throws:: IOException

createMultiRegionTable

public HTable createMultiRegionTable(TableName tableName,
                                     byte[][] families)
                              throws IOException

Create a table with multiple regions.

Parameters:: tableName -; families -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(TableName tableName,
                          byte[][] families,
                          byte[][] splitKeys)
                   throws IOException

Create a table.

Parameters:: tableName -; families -; splitKeys -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(byte[] tableName,
                          byte[][] families,
                          int numVersions,
                          byte[] startKey,
                          byte[] endKey,
                          int numRegions)
                   throws IOException

Throws:: IOException

createTable

public HTable createTable(String tableName,
                          byte[][] families,
                          int numVersions,
                          byte[] startKey,
                          byte[] endKey,
                          int numRegions)
                   throws IOException

Throws:: IOException

createTable

public HTable createTable(TableName tableName,
                          byte[][] families,
                          int numVersions,
                          byte[] startKey,
                          byte[] endKey,
                          int numRegions)
                   throws IOException

Throws:: IOException

createTable

public HTable createTable(HTableDescriptor htd,
                          byte[][] families,
                          Configuration c)
                   throws IOException

Create a table.

Parameters:: htd -; families -; c - Configuration to use
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(HTableDescriptor htd,
                          byte[][] families,
                          byte[][] splitKeys,
                          Configuration c)
                   throws IOException

Create a table.

Parameters:: htd -; families -; splitKeys -; c - Configuration to use
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(HTableDescriptor htd,
                          byte[][] splitRows)
                   throws IOException

Create a table.

Parameters:: htd -; splitRows -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(TableName tableName,
                          byte[][] families,
                          Configuration c)
                   throws IOException

Create a table.

Parameters:: tableName -; families -; c - Configuration to use
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(TableName tableName,
                          byte[][] families,
                          byte[][] splitKeys,
                          Configuration c)
                   throws IOException

Create a table.

Parameters:: tableName -; families -; splitKeys -; c - Configuration to use
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(byte[] tableName,
                          byte[][] families,
                          Configuration c)
                   throws IOException

Create a table.

Parameters:: tableName -; families -; c - Configuration to use
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(TableName tableName,
                          byte[][] families,
                          Configuration c,
                          int numVersions)
                   throws IOException

Create a table.

Parameters:: tableName -; families -; c - Configuration to use; numVersions -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(byte[] tableName,
                          byte[][] families,
                          Configuration c,
                          int numVersions)
                   throws IOException

Create a table.

Parameters:: tableName -; families -; c - Configuration to use; numVersions -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(byte[] tableName,
                          byte[] family,
                          int numVersions)
                   throws IOException

Create a table.

Parameters:: tableName -; family -; numVersions -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(TableName tableName,
                          byte[] family,
                          int numVersions)
                   throws IOException

Create a table.

Parameters:: tableName -; family -; numVersions -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(TableName tableName,
                          byte[][] families,
                          int numVersions,
                          byte[][] splitKeys)
                   throws IOException

Create a table.

Parameters:: tableName -; families -; numVersions -; splitKeys -
Returns:: An HTable instance for the created table.
Throws:: IOException

createMultiRegionTable

public HTable createMultiRegionTable(TableName tableName,
                                     byte[][] families,
                                     int numVersions)
                              throws IOException

Create a table with multiple regions.

Parameters:: tableName -; families -; numVersions -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(byte[] tableName,
                          byte[] family,
                          byte[][] splitRows)
                   throws IOException

Create a table.

Parameters:: tableName -; family -; splitRows -
Returns:: An HTable instance for the created table.
Throws:: IOException

createTable

public HTable createTable(TableName tableName,
                          byte[] family,
                          byte[][] splitRows)
                   throws IOException

Create a table.

Parameters:: tableName -; family -; splitRows -
Returns:: An HTable instance for the created table.
Throws:: IOException

createMultiRegionTable

public HTable createMultiRegionTable(TableName tableName,
                                     byte[] family)
                              throws IOException

Create a table with multiple regions.

Parameters:: tableName -; family -
Returns:: An HTable instance for the created table.
Throws:: IOException

createWal

public static WAL createWal(Configuration conf,
                            Path rootDir,
                            HRegionInfo hri)
                     throws IOException

Create an unmanaged WAL. Be sure to close it when you're through.

Throws:: IOException

createRegionAndWAL

public static HRegion createRegionAndWAL(HRegionInfo info,
                                         Path rootDir,
                                         Configuration conf,
                                         HTableDescriptor htd)
                                  throws IOException

Create a region with it's own WAL. Be sure to call closeRegionAndWAL(HRegion) to clean up all resources.

Throws:: IOException

createRegionAndWAL

public static HRegion createRegionAndWAL(HRegionInfo info,
                                         Path rootDir,
                                         Configuration conf,
                                         HTableDescriptor htd,
                                         boolean initialize)
                                  throws IOException

Create a region with it's own WAL. Be sure to call closeRegionAndWAL(HRegion) to clean up all resources.

Throws:: IOException

closeRegionAndWAL

public static void closeRegionAndWAL(Region r)
                              throws IOException

Close both the region r and it's underlying WAL. For use in tests.

Throws:: IOException

closeRegionAndWAL

public static void closeRegionAndWAL(HRegion r)
                              throws IOException

Close both the HRegion r and it's underlying WAL. For use in tests.

Throws:: IOException

modifyTableSync

public static void modifyTableSync(Admin admin,
                                   HTableDescriptor desc)
                            throws IOException,
                                   InterruptedException

Modify a table, synchronous. Waiting logic similar to that of admin.rb#alter_status.

Throws:: IOException; InterruptedException

setReplicas

public static void setReplicas(Admin admin,
                               TableName table,
                               int replicaCount)
                        throws IOException,
                               InterruptedException

Set the number of Region replicas.

Throws:: IOException; InterruptedException

deleteTable
```
public void deleteTable(String tableName)
                 throws IOException
```
Drop an existing table

Parameters:

tableName - existing table

Throws:

IOException

deleteTable
```
public void deleteTable(byte[] tableName)
                 throws IOException
```
Drop an existing table

Parameters:

tableName - existing table

Throws:

IOException

deleteTable
```
public void deleteTable(TableName tableName)
                 throws IOException
```
Drop an existing table

Parameters:

tableName - existing table

Throws:

IOException

deleteTableIfAny

public void deleteTableIfAny(TableName tableName)
                      throws IOException

Drop an existing table

Parameters:: tableName - existing table
Throws:: IOException

createTableDescriptor

public HTableDescriptor createTableDescriptor(String name,
                                              int minVersions,
                                              int versions,
                                              int ttl,
                                              KeepDeletedCells keepDeleted)

Create a table of name name with COLUMNS for families.

Parameters:: name - Name to give table.; versions - How many versions to allow per column.
Returns:: Column descriptor.

createTableDescriptor
```
public HTableDescriptor createTableDescriptor(String name)
```
Create a table of name name with COLUMNS for families.

Parameters:

name - Name to give table.

Returns:

Column descriptor.

createHRegion

public HRegion createHRegion(HRegionInfo info,
                             Path rootDir,
                             Configuration conf,
                             HTableDescriptor htd)
                      throws IOException

Create an HRegion. Be sure to call closeRegion(Region) when you're finished with it.

Throws:: IOException

createLocalHRegion

public HRegion createLocalHRegion(HTableDescriptor desc,
                                  byte[] startKey,
                                  byte[] endKey)
                           throws IOException

Create an HRegion that writes to the local tmp dirs

Parameters:: desc -; startKey -; endKey -
Returns:
Throws:: IOException

createLocalHRegion

public HRegion createLocalHRegion(HRegionInfo info,
                                  HTableDescriptor desc)
                           throws IOException

Create an HRegion that writes to the local tmp dirs

Parameters:: info -; desc -
Returns:
Throws:: IOException

createLocalHRegion

public HRegion createLocalHRegion(HRegionInfo info,
                                  HTableDescriptor desc,
                                  WAL wal)
                           throws IOException

Create an HRegion that writes to the local tmp dirs with specified wal

Parameters:: info - regioninfo; desc - table descriptor; wal - wal for this region.
Returns:: created hregion
Throws:: IOException

createLocalHRegion

public HRegion createLocalHRegion(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

deleteTableData
```
public HTable deleteTableData(byte[] tableName)
                       throws IOException
```
Provide an existing table name to truncate. Scans the table and issues a delete for each row read.

Parameters:

tableName - existing table

Returns:

HTable to that new table

Throws:

IOException

deleteTableData
```
public HTable deleteTableData(TableName tableName)
                       throws IOException
```
Provide an existing table name to truncate. Scans the table and issues a delete for each row read.

Parameters:

tableName - existing table

Returns:

HTable to that new table

Throws:

IOException

truncateTable
```
public HTable truncateTable(TableName tableName,
                            boolean preserveRegions)
                     throws IOException
```
Truncate a table using the admin command. Effectively disables, deletes, and recreates the table.

Parameters:

tableName - table which must exist.

preserveRegions - keep the existing split points

Returns:

HTable for the new table

Throws:

IOException

truncateTable
```
public HTable truncateTable(TableName tableName)
                     throws IOException
```
Truncate a table using the admin command. Effectively disables, deletes, and recreates the table. For previous behavior of issuing row deletes, see deleteTableData. Expressly does not preserve regions of existing table.

Parameters:

tableName - table which must exist.

Returns:

HTable for the new table

Throws:

IOException

truncateTable
```
public HTable truncateTable(byte[] tableName,
                            boolean preserveRegions)
                     throws IOException
```
Truncate a table using the admin command. Effectively disables, deletes, and recreates the table.

Parameters:

tableName - table which must exist.

preserveRegions - keep the existing split points

Returns:

HTable for the new table

Throws:

IOException

truncateTable
```
public HTable truncateTable(byte[] tableName)
                     throws IOException
```
Truncate a table using the admin command. Effectively disables, deletes, and recreates the table. For previous behavior of issuing row deletes, see deleteTableData. Expressly does not preserve regions of existing table.

Parameters:

tableName - table which must exist.

Returns:

HTable for the new table

Throws:

IOException

loadTable
```
public int loadTable(Table t,
                     byte[] f)
              throws IOException
```
Load table with rows from 'aaa' to 'zzz'.

Parameters:

t - Table

f - Family

Returns:

Count of rows loaded.

Throws:

IOException

loadTable

public int loadTable(Table t,
                     byte[] f,
                     boolean writeToWAL)
              throws IOException

Load table with rows from 'aaa' to 'zzz'.

Parameters:: t - Table; f - Family
Returns:: Count of rows loaded.
Throws:: IOException

loadTable
```
public int loadTable(Table t,
                     byte[][] f)
              throws IOException
```
Load table of multiple column families with rows from 'aaa' to 'zzz'.

Parameters:

t - Table

f - Array of Families to load

Returns:

Count of rows loaded.

Throws:

IOException

loadTable
```
public int loadTable(Table t,
                     byte[][] f,
                     byte[] value)
              throws IOException
```
Load table of multiple column families with rows from 'aaa' to 'zzz'.

Parameters:

t - Table

f - Array of Families to load

value - the values of the cells. If null is passed, the row key is used as value

Returns:

Count of rows loaded.

Throws:

IOException

loadTable
```
public int loadTable(Table t,
                     byte[][] f,
                     byte[] value,
                     boolean writeToWAL)
              throws IOException
```
Load table of multiple column families with rows from 'aaa' to 'zzz'.

Parameters:

t - Table

f - Array of Families to load

value - the values of the cells. If null is passed, the row key is used as value

Returns:

Count of rows loaded.

Throws:

IOException

loadRegion

public int loadRegion(HRegion r,
                      byte[] f)
               throws IOException

Throws:: IOException

loadRegion

public int loadRegion(Region r,
                      byte[] f)
               throws IOException

Throws:: IOException

loadRegion
```
public int loadRegion(HRegion r,
                      byte[] f,
                      boolean flush)
               throws IOException
```
Load region with rows from 'aaa' to 'zzz'.

Parameters:

r - Region

f - Family

flush - flush the cache if true

Returns:

Count of rows loaded.

Throws:

IOException

loadNumericRows

public void loadNumericRows(Table t,
                            byte[] f,
                            int startRow,
                            int endRow)
                     throws IOException

Throws:: IOException

verifyNumericRows

public void verifyNumericRows(Table table,
                              byte[] f,
                              int startRow,
                              int endRow,
                              int replicaId)
                       throws IOException

Throws:: IOException

verifyNumericRows

public void verifyNumericRows(Region region,
                              byte[] f,
                              int startRow,
                              int endRow)
                       throws IOException

Throws:: IOException

verifyNumericRows

public void verifyNumericRows(HRegion region,
                              byte[] f,
                              int startRow,
                              int endRow)
                       throws IOException

Throws:: IOException

verifyNumericRows

public void verifyNumericRows(Region region,
                              byte[] f,
                              int startRow,
                              int endRow,
                              boolean present)
                       throws IOException

Throws:: IOException

verifyNumericRows

public void verifyNumericRows(HRegion region,
                              byte[] f,
                              int startRow,
                              int endRow,
                              boolean present)
                       throws IOException

Throws:: IOException

deleteNumericRows

public void deleteNumericRows(HTable t,
                              byte[] f,
                              int startRow,
                              int endRow)
                       throws IOException

Throws:: IOException

countRows

public int countRows(Table table)
              throws IOException

Return the number of rows in the given table.

Throws:: IOException

countRows

public int countRows(Table table,
                     byte[]... families)
              throws IOException

Throws:: IOException

countRows

public int countRows(TableName tableName)
              throws IOException

Return the number of rows in the given table.

Throws:: IOException

checksumRows

public String checksumRows(Table table)
                    throws Exception

Return an md5 digest of the entire contents of a table.

Throws:: Exception

createMultiRegionsInMeta

public List<HRegionInfo> createMultiRegionsInMeta(Configuration conf,
                                                  HTableDescriptor htd,
                                                  byte[][] startKeys)
                                           throws IOException

Create rows in hbase:meta for regions of the specified table with the specified start keys. The first startKey should be a 0 length byte array if you want to form a proper range of regions.

Parameters:: conf -; htd -; startKeys -
Returns:: list of region info for regions added to meta
Throws:: IOException

getMetaTableRows
```
public List<byte[]> getMetaTableRows()
                              throws IOException
```
Returns all rows from the hbase:meta table.

Throws:

IOException - When reading the rows fails.

getMetaTableRows
```
public List<byte[]> getMetaTableRows(TableName tableName)
                              throws IOException
```
Returns all rows from the hbase:meta table for a given user table

Throws:

IOException - When reading the rows fails.

getRSForFirstRegionInTable
```
public HRegionServer getRSForFirstRegionInTable(TableName tableName)
                                         throws IOException,
                                                InterruptedException
```
Tool to get the reference to the region server object that holds the region of the specified user table. It first searches for the meta rows that contain the region of the specified table, then gets the index of that RS, and finally retrieves the RS's reference.

Parameters:

tableName - user table to lookup in hbase:meta

Returns:

region server that holds it, null if the row doesn't exist

Throws:

IOException

InterruptedException

startMiniMapReduceCluster
```
public MiniMRCluster startMiniMapReduceCluster()
                                        throws IOException
```
Starts a MiniMRCluster with a default number of TaskTracker's.

Throws:

IOException - When starting the cluster fails.

shutdownMiniMapReduceCluster
```
public void shutdownMiniMapReduceCluster()
```
Stops the previously started MiniMRCluster.

createMockRegionServerService

public RegionServerServices createMockRegionServerService()
                                                   throws IOException

Create a stubbed out RegionServerService, mainly for getting FS.

Throws:: IOException

createMockRegionServerService

public RegionServerServices createMockRegionServerService(RpcServerInterface rpc)
                                                   throws IOException

Create a stubbed out RegionServerService, mainly for getting FS. This version is used by TestTokenAuthentication

Throws:: IOException

createMockRegionServerService
```
public RegionServerServices createMockRegionServerService(ServerName name)
                                                   throws IOException
```
Create a stubbed out RegionServerService, mainly for getting FS. This version is used by TestOpenRegionHandler

Throws:

IOException

enableDebug
```
public void enableDebug(Class<?> clazz)
```
Switches the logger for the given class to DEBUG level.

Parameters:

clazz - The class for which to switch to debug logging.

expireMasterSession

public void expireMasterSession()
                         throws Exception

Expire the Master's session

Throws:: Exception

expireRegionServerSession

public void expireRegionServerSession(int index)
                               throws Exception

Expire a region server's session

Parameters:: index - which RS
Throws:: Exception

expireSession

public void expireSession(ZooKeeperWatcher nodeZK)
                   throws Exception

Throws:: Exception

expireSession

@Deprecated
public void expireSession(ZooKeeperWatcher nodeZK,
                                      Server server)
                               throws Exception

Deprecated.

Throws:: Exception

expireSession
```
public void expireSession(ZooKeeperWatcher nodeZK,
                          boolean checkStatus)
                   throws Exception
```
Expire a ZooKeeper session as recommended in ZooKeeper documentation http://wiki.apache.org/hadoop/ZooKeeper/FAQ#A4 There are issues when doing this: [1] http://www.mail-archive.com/dev@zookeeper.apache.org/msg01942.html [2] https://issues.apache.org/jira/browse/ZOOKEEPER-1105

Parameters:

nodeZK - - the ZK watcher to expire

checkStatus - - true to check if we can create an HTable with the current configuration.

Throws:

Exception

getHBaseCluster
```
public MiniHBaseCluster getHBaseCluster()
```
Get the Mini HBase cluster.

Returns:

hbase cluster

See Also:

getHBaseClusterInterface()

getHBaseClusterInterface
```
public HBaseCluster getHBaseClusterInterface()
```
Returns the HBaseCluster instance.
Returned object can be any of the subclasses of HBaseCluster, and the tests referring this should not assume that the cluster is a mini cluster or a distributed one. If the test only works on a mini cluster, then specific method getMiniHBaseCluster() can be used instead w/o the need to type-cast.

getConnection
```
public Connection getConnection()
                         throws IOException
```
Get a Connection to the cluster. Not thread-safe (This class needs a lot of work to make it thread-safe).

Returns:

A Connection that can be shared. Don't close. Will be closed on shutdown of cluster.

Throws:

IOException

getHBaseAdmin
```
public HBaseAdmin getHBaseAdmin()
                         throws IOException
```
Returns a Admin instance. This instance is shared between HBaseTestingUtility instance users. Closing it has no effect, it will be closed automatically when the cluster shutdowns

Returns:

An Admin instance.

Throws:

IOException

getZooKeeperWatcher
```
public ZooKeeperWatcher getZooKeeperWatcher()
                                     throws IOException
```
Returns a ZooKeeperWatcher instance. This instance is shared between HBaseTestingUtility instance users. Don't close it, it will be closed automatically when the cluster shutdowns

Returns:

The ZooKeeperWatcher instance.

Throws:

IOException

closeRegion
```
public void closeRegion(String regionName)
                 throws IOException
```
Closes the named region.

Parameters:

regionName - The region to close.

Throws:

IOException

closeRegion
```
public void closeRegion(byte[] regionName)
                 throws IOException
```
Closes the named region.

Parameters:

regionName - The region to close.

Throws:

IOException

closeRegionByRow

public void closeRegionByRow(String row,
                             RegionLocator table)
                      throws IOException

Closes the region containing the given row.

Parameters:: row - The row to find the containing region.; table - The table to find the region.
Throws:: IOException

closeRegionByRow

public void closeRegionByRow(byte[] row,
                             RegionLocator table)
                      throws IOException

Closes the region containing the given row.

Parameters:: row - The row to find the containing region.; table - The table to find the region.
Throws:: IOException

getSplittableRegion

public HRegion getSplittableRegion(TableName tableName,
                                   int maxAttempts)

getZkCluster

public MiniZooKeeperCluster getZkCluster()

setZkCluster

public void setZkCluster(MiniZooKeeperCluster zkCluster)

getDFSCluster
```
public MiniDFSCluster getDFSCluster()
```

setDFSCluster

public void setDFSCluster(MiniDFSCluster cluster)
                   throws IllegalStateException,
                          IOException

Throws:: IllegalStateException; IOException

setDFSCluster
```
public void setDFSCluster(MiniDFSCluster cluster,
                          boolean requireDown)
                   throws IllegalStateException,
                          IOException
```
Set the MiniDFSCluster

Parameters:

cluster - cluster to use

requireDown - require the that cluster not be "up" (MiniDFSCluster#isClusterUp) before it is set.

Throws:

IllegalStateException - if the passed cluster is up when it is required to be down

IOException - if the FileSystem could not be set from the passed dfs cluster

getTestFileSystem

public FileSystem getTestFileSystem()
                             throws IOException

Throws:: IOException

waitTableAvailable
```
public void waitTableAvailable(TableName table)
                        throws InterruptedException,
                               IOException
```
Wait until all regions in a table have been assigned. Waits default timeout before giving up (30 seconds).

Parameters:

table - Table to wait on.

Throws:

InterruptedException

IOException

waitTableAvailable

public void waitTableAvailable(TableName table,
                               long timeoutMillis)
                        throws InterruptedException,
                               IOException

Throws:: InterruptedException; IOException

explainTableAvailability

public String explainTableAvailability(TableName tableName)
                                throws IOException

Throws:: IOException

explainTableState

public String explainTableState(TableName tableName)
                         throws IOException

Throws:: IOException

waitTableAvailable

public void waitTableAvailable(byte[] table,
                               long timeoutMillis)
                        throws InterruptedException,
                               IOException

Wait until all regions in a table have been assigned

Parameters:: table - Table to wait on.; timeoutMillis - Timeout.
Throws:: InterruptedException; IOException

waitTableAvailable

public void waitTableAvailable(Admin admin,
                               byte[] table,
                               long timeoutMillis)
                        throws InterruptedException,
                               IOException

Throws:: InterruptedException; IOException

waitTableEnabled
```
public void waitTableEnabled(TableName table)
                      throws InterruptedException,
                             IOException
```
Waits for a table to be 'enabled'. Enabled means that table is set as 'enabled' and the regions have been all assigned. Will timeout after default period (30 seconds)

Parameters:

table - Table to wait on.

table -

Throws:

InterruptedException

IOException

See Also:

#waitTableAvailable(byte[])

waitTableEnabled
```
public void waitTableEnabled(byte[] table,
                             long timeoutMillis)
                      throws InterruptedException,
                             IOException
```
Waits for a table to be 'enabled'. Enabled means that table is set as 'enabled' and the regions have been all assigned.

Parameters:

table - Table to wait on.

timeoutMillis - Time to wait on it being marked enabled.

Throws:

InterruptedException

IOException

See Also:

#waitTableAvailable(byte[])

waitTableEnabled

public void waitTableEnabled(TableName table,
                             long timeoutMillis)
                      throws IOException

Throws:: IOException

waitTableDisabled
```
public void waitTableDisabled(byte[] table)
                       throws InterruptedException,
                              IOException
```
Waits for a table to be 'disabled'. Disabled means that table is set as 'disabled' Will timeout after default period (30 seconds)

Parameters:

table - Table to wait on.

Throws:

InterruptedException

IOException

waitTableDisabled

public void waitTableDisabled(Admin admin,
                              byte[] table)
                       throws InterruptedException,
                              IOException

Throws:: InterruptedException; IOException

waitTableDisabled
```
public void waitTableDisabled(byte[] table,
                              long timeoutMillis)
                       throws InterruptedException,
                              IOException
```
Waits for a table to be 'disabled'. Disabled means that table is set as 'disabled'

Parameters:

table - Table to wait on.

timeoutMillis - Time to wait on it being marked disabled.

Throws:

InterruptedException

IOException

waitTableDisabled

public void waitTableDisabled(Admin admin,
                              byte[] table,
                              long timeoutMillis)
                       throws InterruptedException,
                              IOException

Throws:: InterruptedException; IOException

ensureSomeRegionServersAvailable
```
public boolean ensureSomeRegionServersAvailable(int num)
                                         throws IOException
```
Make sure that at least the specified number of region servers are running

Parameters:

num - minimum number of region servers that should be running

Returns:

true if we started some servers

Throws:

IOException

ensureSomeNonStoppedRegionServersAvailable
```
public boolean ensureSomeNonStoppedRegionServersAvailable(int num)
                                                   throws IOException
```
Make sure that at least the specified number of region servers are running. We don't count the ones that are currently stopping or are stopped.

Parameters:

num - minimum number of region servers that should be running

Returns:

true if we started some servers

Throws:

IOException

getDifferentUser
```
public static User getDifferentUser(Configuration c,
                                    String differentiatingSuffix)
                             throws IOException
```
This method clones the passed c configuration setting a new user into the clone. Use it getting new instances of FileSystem. Only works for DistributedFileSystem.

Parameters:

c - Initial configuration

differentiatingSuffix - Suffix to differentiate this user from others.

Returns:

A new configuration instance with a different user set into it.

Throws:

IOException

getAllOnlineRegions

public static NavigableSet<String> getAllOnlineRegions(MiniHBaseCluster cluster)
                                                throws IOException

Throws:: IOException

setMaxRecoveryErrorCount

public static void setMaxRecoveryErrorCount(OutputStream stream,
                                            int max)

Set maxRecoveryErrorCount in DFSClient. In 0.20 pre-append its hard-coded to 5 and makes tests linger. Here is the exception you'll see:

 2010-06-15 11:52:28,511 WARN  [DataStreamer for file /hbase/.logs/wal.1276627923013 block blk_928005470262850423_1021] hdfs.DFSClient$DFSOutputStream(2657): Error Recovery for block blk_928005470262850423_1021 failed  because recovery from primary datanode 127.0.0.1:53683 failed 4 times.  Pipeline was 127.0.0.1:53687, 127.0.0.1:53683. Will retry...

Parameters:: stream - A DFSClient.DFSOutputStream.; max -
Throws:: NoSuchFieldException; SecurityException; IllegalAccessException; IllegalArgumentException

waitUntilAllRegionsAssigned
```
public void waitUntilAllRegionsAssigned(TableName tableName)
                                 throws IOException
```
Wait until all regions for a table in hbase:meta have a non-empty info:server, up to 60 seconds. This means all regions have been deployed, master has been informed and updated hbase:meta with the regions deployed server.

Parameters:

tableName - the table name

Throws:

IOException

waitUntilAllRegionsAssigned
```
public void waitUntilAllRegionsAssigned(TableName tableName,
                                        long timeout)
                                 throws IOException
```
Wait until all regions for a table in hbase:meta have a non-empty info:server, or until timeout. This means all regions have been deployed, master has been informed and updated hbase:meta with the regions deployed server.

Parameters:

tableName - the table name

timeout - timeout, in milliseconds

Throws:

IOException

getFromStoreFile

public static List<Cell> getFromStoreFile(HStore store,
                                          Get get)
                                   throws IOException

Do a small get/scan against one store. This is required because store has no actual methods of querying itself, and relies on StoreScanner.

Throws:: IOException

getRegionSplitStartKeys
```
public byte[][] getRegionSplitStartKeys(byte[] startKey,
                                        byte[] endKey,
                                        int numRegions)
```
Create region split keys between startkey and endKey

Parameters:

startKey -

endKey -

numRegions - the number of regions to be created. it has to be greater than 3.

Returns:

getFromStoreFile

public static List<Cell> getFromStoreFile(HStore store,
                                          byte[] row,
                                          NavigableSet<byte[]> columns)
                                   throws IOException

Do a small get/scan against one store. This is required because store has no actual methods of querying itself, and relies on StoreScanner.

Throws:: IOException

getZooKeeperWatcher

public static ZooKeeperWatcher getZooKeeperWatcher(HBaseTestingUtility TEST_UTIL)
                                            throws ZooKeeperConnectionException,
                                                   IOException

Gets a ZooKeeperWatcher.

Parameters:: TEST_UTIL -
Throws:: ZooKeeperConnectionException; IOException

createAndForceNodeToOpenedState

public static ZooKeeperWatcher createAndForceNodeToOpenedState(HBaseTestingUtility TEST_UTIL,
                                                               Region region,
                                                               ServerName serverName)
                                                        throws ZooKeeperConnectionException,
                                                               IOException,
                                                               KeeperException,
                                                               NodeExistsException

Creates a znode with OPENED state.

Parameters:: TEST_UTIL -; region -; serverName -
Returns:
Throws:: IOException; ZooKeeperConnectionException; KeeperException; NodeExistsException

createAndForceNodeToOpenedState

public static ZooKeeperWatcher createAndForceNodeToOpenedState(HBaseTestingUtility TEST_UTIL,
                                                               HRegion region,
                                                               ServerName serverName)
                                                        throws ZooKeeperConnectionException,
                                                               IOException,
                                                               KeeperException,
                                                               NodeExistsException

Creates a znode with OPENED state.

Parameters:: TEST_UTIL -; region -; serverName -
Returns:
Throws:: IOException; ZooKeeperConnectionException; KeeperException; NodeExistsException

assertKVListsEqual

public static void assertKVListsEqual(String additionalMsg,
                                      List<? extends Cell> expected,
                                      List<? extends Cell> actual)

safeGetAsStr

public static <T> String safeGetAsStr(List<T> lst,
                                      int i)

getClusterKey
```
public String getClusterKey()
```

createRandomTable

public HTable createRandomTable(String tableName,
                                Collection<String> families,
                                int maxVersions,
                                int numColsPerRow,
                                int numFlushes,
                                int numRegions,
                                int numRowsPerFlush)
                         throws IOException,
                                InterruptedException

Creates a random table with the given parameters

Throws:: IOException; InterruptedException

randomPort
```
public static int randomPort()
```
Returns a random port. These ports cannot be registered with IANA and are intended for dynamic allocation (see http://bit.ly/dynports).

randomFreePort
```
public static int randomFreePort()
```
Returns a random free port and marks that port as taken. Not thread-safe. Expected to be called from single-threaded test setup code/

randomMultiCastAddress

public static String randomMultiCastAddress()

waitForHostPort

public static void waitForHostPort(String host,
                                   int port)
                            throws IOException

Throws:: IOException