HBaseTestingUtility (Apache HBase 2.1.0-cdh6.3.2 Test API)

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

```
@InterfaceAudience.Public
public class HBaseTestingUtility
extends HBaseZKTestingUtility
```
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. In the configuration properties, default values for master-info-port and region-server-port are overridden such that a random port will be assigned (thus avoiding port contention if another local HBase instance is already running).
To preserve test data directories, pass the system property "hbase.testing.preserve.testdir" setting it to true. For triggering pre commit

Field Summary

Fields
Modifier and Type	Field and Description
`static Collection<Object[]>`	`BLOOM_AND_COMPRESSION_COMBINATIONS`
`static byte[][]`	`COLUMNS`
`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 boolean`	`PRESPLIT_TEST_TABLE`
`static String`	`PRESPLIT_TEST_TABLE_KEY`
`static String`	`REGIONS_PER_SERVER_KEY`
`static byte[][]`	`ROWS` All the row values for the data loaded by `loadTable(Table, byte[])`
`static String`	`START_KEY`
`static byte[]`	`START_KEY_BYTES`

Fields inherited from class org.apache.hadoop.hbase.HBaseZKTestingUtility
clusterTestDir, zooKeeperWatcher

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

Constructor Summary

Constructors
Constructor and Description
`HBaseTestingUtility()` Create an HBaseTestingUtility using a default configuration.
`HBaseTestingUtility(org.apache.hadoop.conf.Configuration conf)` Create an HBaseTestingUtility using a given configuration.

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(RegionInfo 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(RegionInfo 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.
`boolean`	`assignRegion(RegionInfo regionInfo)` Uses directly the assignment manager to assign the region.
`static boolean`	`available(int port)` Checks to see if a specific port is available.
`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.
`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`	`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(InternalScanner scanner)`
`int`	`countRows(Region region)`
`int`	`countRows(Region region, Scan scan)`
`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.
`int`	`countRows(Table table, Scan scan)`
`HRegion`	`createLocalHRegion(byte[] tableName, byte[] startKey, byte[] stopKey, String callingMethod, org.apache.hadoop.conf.Configuration conf, boolean isReadOnly, Durability durability, WAL wal, byte[]... families)` Deprecated. use `#createLocalHRegion(TableName, byte[], byte[], boolean, Durability, WAL, byte[]...)`
`HRegion`	`createLocalHRegion(RegionInfo info, TableDescriptor desc)` Create an HRegion that writes to the local tmp dirs.
`HRegion`	`createLocalHRegion(RegionInfo info, TableDescriptor desc, WAL wal)` Create an HRegion that writes to the local tmp dirs with specified wal
`HRegion`	`createLocalHRegion(TableDescriptor desc, byte[] startKey, byte[] endKey)` Create an HRegion that writes to the local tmp dirs
`HRegion`	`createLocalHRegion(TableName tableName, byte[] startKey, byte[] stopKey, boolean isReadOnly, Durability durability, WAL wal, byte[]... families)`
`HRegion`	`createLocalHRegionWithInMemoryFlags(TableName tableName, byte[] startKey, byte[] stopKey, boolean isReadOnly, Durability durability, WAL wal, boolean[] compactedMemStore, byte[]... families)`
`static HBaseTestingUtility`	`createLocalHTU()` Deprecated. use `HBaseTestingUtility()` instead
`static HBaseTestingUtility`	`createLocalHTU(org.apache.hadoop.conf.Configuration c)` Deprecated. use `HBaseTestingUtility(Configuration)` instead
`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(org.apache.hadoop.conf.Configuration conf, HTableDescriptor htd, byte[][] startKeys)` Deprecated. since 2.0 version and will be removed in 3.0 version. use `createMultiRegionsInMeta(Configuration, TableDescriptor, byte[][])`
`List<RegionInfo>`	`createMultiRegionsInMeta(org.apache.hadoop.conf.Configuration conf, TableDescriptor htd, byte[][] startKeys)` Create rows in hbase:meta for regions of the specified table with the specified start keys.
`Table`	`createMultiRegionTable(TableName tableName, byte[] family)` Create a table with multiple regions.
`Table`	`createMultiRegionTable(TableName tableName, byte[][] families)` Create a table with multiple regions.
`Table`	`createMultiRegionTable(TableName tableName, byte[][] families, int numVersions)` Create a table with multiple regions.
`Table`	`createMultiRegionTable(TableName tableName, byte[] family, int numRegions)` Create a table with multiple regions.
`static int`	`createPreSplitLoadTestTable(org.apache.hadoop.conf.Configuration conf, TableDescriptor desc, ColumnFamilyDescriptor hcd)` Creates a pre-split table for load testing.
`static int`	`createPreSplitLoadTestTable(org.apache.hadoop.conf.Configuration conf, TableDescriptor desc, ColumnFamilyDescriptor[] hcds, int numRegionsPerServer)` Creates a pre-split table for load testing.
`static int`	`createPreSplitLoadTestTable(org.apache.hadoop.conf.Configuration conf, TableDescriptor td, ColumnFamilyDescriptor[] cds, RegionSplitter.SplitAlgorithm splitter, int numRegionsPerServer)` Creates a pre-split table for load testing.
`static int`	`createPreSplitLoadTestTable(org.apache.hadoop.conf.Configuration conf, TableDescriptor desc, ColumnFamilyDescriptor hcd, int numRegionsPerServer)` Creates a pre-split table for load testing.
`static int`	`createPreSplitLoadTestTable(org.apache.hadoop.conf.Configuration conf, TableName tableName, byte[][] columnFamilies, org.apache.hadoop.hbase.io.compress.Compression.Algorithm compression, DataBlockEncoding dataBlockEncoding, int numRegionsPerServer, int regionReplication, Durability durability)` Creates a pre-split table for load testing.
`static int`	`createPreSplitLoadTestTable(org.apache.hadoop.conf.Configuration conf, TableName tableName, byte[] columnFamily, org.apache.hadoop.hbase.io.compress.Compression.Algorithm compression, DataBlockEncoding dataBlockEncoding)` Creates a pre-split table for load testing.
`static int`	`createPreSplitLoadTestTable(org.apache.hadoop.conf.Configuration conf, TableName tableName, byte[] columnFamily, org.apache.hadoop.hbase.io.compress.Compression.Algorithm compression, DataBlockEncoding dataBlockEncoding, int numRegionsPerServer, int regionReplication, Durability durability)` Creates a pre-split table for load testing.
`Table`	`createRandomTable(TableName 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(RegionInfo info, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.conf.Configuration conf, TableDescriptor htd)` Create a region with it's own WAL.
`static HRegion`	`createRegionAndWAL(RegionInfo info, org.apache.hadoop.fs.Path rootDir, org.apache.hadoop.conf.Configuration conf, TableDescriptor htd, boolean initialize)` Create a region with it's own WAL.
`org.apache.hadoop.fs.Path`	`createRootDir()` Same as `createRootDir(boolean create)` except that `create` flag is false.
`org.apache.hadoop.fs.Path`	`createRootDir(boolean create)` Creates an hbase rootdir in user home directory.
`Table`	`createTable(TableDescriptor htd, byte[][] splitRows)` Create a table.
`Table`	`createTable(TableDescriptor htd, byte[][] families, byte[][] splitKeys, BloomType type, int blockSize, org.apache.hadoop.conf.Configuration c)` Create a table.
`Table`	`createTable(TableDescriptor htd, byte[][] families, byte[][] splitKeys, org.apache.hadoop.conf.Configuration c)` Create a table.
`Table`	`createTable(TableDescriptor htd, byte[][] families, org.apache.hadoop.conf.Configuration c)` Create a table.
`Table`	`createTable(TableName tableName, byte[] family)` Create a table.
`Table`	`createTable(TableName tableName, byte[][] families)` Create a table.
`Table`	`createTable(TableName tableName, byte[][] families, byte[][] splitKeys)` Create a table.
`Table`	`createTable(TableName tableName, byte[][] families, byte[][] splitKeys, int replicaCount)` Create a table.
`Table`	`createTable(TableName tableName, byte[][] families, byte[][] splitKeys, int replicaCount, org.apache.hadoop.conf.Configuration c)` Create a table.
`Table`	`createTable(TableName tableName, byte[][] families, int numVersions)` Create a table.
`Table`	`createTable(TableName tableName, byte[][] families, int[] numVersions)` Create a table.
`Table`	`createTable(TableName tableName, byte[][] families, int numVersions, byte[][] splitKeys)` Create a table.
`Table`	`createTable(TableName tableName, byte[][] families, int numVersions, byte[] startKey, byte[] endKey, int numRegions)`
`Table`	`createTable(TableName tableName, byte[][] families, int numVersions, int blockSize)` Create a table.
`Table`	`createTable(TableName tableName, byte[][] families, int numVersions, int blockSize, String cpName)`
`Table`	`createTable(TableName tableName, byte[] family, byte[][] splitRows)` Create a table.
`Table`	`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)` Deprecated.
`HTableDescriptor`	`createTableDescriptor(String name, int minVersions, int versions, int ttl, KeepDeletedCells keepDeleted)` Deprecated.
`HTableDescriptor`	`createTableDescriptor(TableName name)` Create a table of name `name`.
`HTableDescriptor`	`createTableDescriptor(TableName tableName, byte[] family)`
`HTableDescriptor`	`createTableDescriptor(TableName tableName, byte[][] families, int maxVersions)`
`HTableDescriptor`	`createTableDescriptor(TableName name, int minVersions, int versions, int ttl, KeepDeletedCells keepDeleted)`
`HRegion`	`createTestRegion(String tableName, ColumnFamilyDescriptor cd)`
`static WAL`	`createWal(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.fs.Path rootDir, RegionInfo hri)` Create an unmanaged WAL.
`org.apache.hadoop.fs.Path`	`createWALRootDir()` Creates a hbase walDir in the user's home directory.
`void`	`deleteNumericRows(Table t, byte[] f, int startRow, int endRow)`
`void`	`deleteTable(TableName tableName)` Drop an existing table
`Table`	`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(ZKWatcher nodeZK)`
`void`	`expireSession(ZKWatcher nodeZK, boolean checkStatus)` Expire a ZooKeeper session as recommended in ZooKeeper documentation http://hbase.apache.org/book.html#trouble.zookeeper There are issues when doing this: [1] http://www.mail-archive.com/[email protected]/msg01942.html [2] https://issues.apache.org/jira/browse/ZOOKEEPER-1105
`String`	`explainTableAvailability(TableName tableName)`
`String`	`explainTableState(TableName table, TableState.State state)`
`TableState`	`findLastTableState(TableName table)`
`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.
`Admin`	`getAdmin()` Returns an Admin instance which is shared between HBaseTestingUtility instance users.
`static NavigableSet<String>`	`getAllOnlineRegions(MiniHBaseCluster cluster)`
`Result`	`getClosestRowBefore(Region r, byte[] row, byte[] family)`
`String`	`getClusterKey()`
`org.apache.hadoop.conf.Configuration`	`getConfiguration()` Returns this classes's instance of `Configuration`.
`Connection`	`getConnection()` Get a Connection to the cluster.
`org.apache.hadoop.fs.Path`	`getDataTestDirOnTestFS()` Returns a Path in the test filesystem, obtained from `getTestFileSystem()` to write temporary test data.
`org.apache.hadoop.fs.Path`	`getDataTestDirOnTestFS(String subdirName)` Returns a Path in the test filesystem, obtained from `getTestFileSystem()` to write temporary test data.
`org.apache.hadoop.fs.Path`	`getDefaultRootDirPath()` Same as {`getDefaultRootDirPath(boolean create)` except that `create` flag is false.
`org.apache.hadoop.fs.Path`	`getDefaultRootDirPath(boolean create)` Returns the path to the default root dir the minicluster uses.
`org.apache.hadoop.hdfs.MiniDFSCluster`	`getDFSCluster()`
`static User`	`getDifferentUser(org.apache.hadoop.conf.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()` Deprecated. Since 2.0. Will be removed in 3.0. Use `getAdmin()` instead.
`MiniHBaseCluster`	`getHBaseCluster()` Get the Mini HBase cluster.
`HBaseCluster`	`getHBaseClusterInterface()` Returns the HBaseCluster instance.
`Hbck`	`getHbck()` Returns an `Hbck` instance.
`static int`	`getMetaRSPort(Connection connection)`
`HTableDescriptor`	`getMetaTableDescriptor()` Deprecated. since 2.0 version and will be removed in 3.0 version. use `getMetaTableDescriptorBuilder()`
`TableDescriptorBuilder`	`getMetaTableDescriptorBuilder()`
`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()`
`int`	`getNumHFiles(TableName tableName, byte[] family)`
`int`	`getNumHFilesForRS(HRegionServer rs, TableName tableName, byte[] family)`
`HRegionServer`	`getOtherRegionServer(HRegionServer rs)`
`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 org.apache.hadoop.hbase.io.compress.Compression.Algorithm[]`	`getSupportedCompressionAlgorithms()` Get supported compression algorithms.
`org.apache.hadoop.fs.FileSystem`	`getTestFileSystem()`
`boolean`	`isNewVersionBehaviorEnabled()` Check whether the tests should assume NEW_VERSION_BEHAVIOR when creating new column families.
`boolean`	`isReadShortCircuitOn()` Get the HBase setting for dfs.client.read.shortcircuit from the conf or a system property.
`void`	`killMiniHBaseCluster()` Abruptly Shutdown HBase mini cluster.
`void`	`loadNumericRows(Table t, byte[] f, int startRow, int endRow)`
`void`	`loadRandomRows(Table t, byte[] f, int rowSize, int totalRows)`
`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 List<Object[]>`	`memStoreTSTagsAndOffheapCombination()`
`static void`	`modifyTableSync(Admin admin, TableDescriptor desc)` Modify a table, synchronous.
`void`	`moveRegionAndWait(RegionInfo destRegion, ServerName destServer)` Move region to destination server and wait till region is completely moved and online
`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()`
`static String`	`randomMultiCastAddress()`
`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(org.apache.hadoop.hdfs.MiniDFSCluster cluster)`
`void`	`setDFSCluster(org.apache.hadoop.hdfs.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 org.apache.hadoop.fs.Path`	`setupDataTestDir()` Home our data in a dir under `HBaseCommonTestingUtility.DEFAULT_BASE_TEST_DIRECTORY`.
`org.apache.hadoop.minikdc.MiniKdc`	`setupMiniKdc(File keytabFile)` Sets up `MiniKdc` for testing security.
`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.Does not shutdown zk or dfs if running.
`void`	`shutdownMiniMapReduceCluster()` Stops the previously started `MiniMRCluster`.
`MiniHBaseCluster`	`startMiniCluster()` Start up a minicluster of hbase, dfs, and zookeeper.
`MiniHBaseCluster`	`startMiniCluster(boolean withWALDir)` Start up a minicluster of hbase, dfs, and zookeeper where WAL's walDir is created separately.
`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 numSlaves, boolean create, boolean withWALDir)`
`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, boolean withWALDir)` 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.
`org.apache.hadoop.hdfs.MiniDFSCluster`	`startMiniDFSCluster(int servers)` Start a minidfscluster.
`org.apache.hadoop.hdfs.MiniDFSCluster`	`startMiniDFSCluster(int servers, String[] hosts)` Start a minidfscluster.
`org.apache.hadoop.hdfs.MiniDFSCluster`	`startMiniDFSCluster(int servers, String[] racks, String[] hosts)`
`org.apache.hadoop.hdfs.MiniDFSCluster`	`startMiniDFSCluster(String[] hosts)` Start a minidfscluster.
`org.apache.hadoop.hdfs.MiniDFSCluster`	`startMiniDFSClusterForTestWAL(int namenodePort)`
`MiniHBaseCluster`	`startMiniHBaseCluster(int numMasters, int numSlaves)`
`MiniHBaseCluster`	`startMiniHBaseCluster(int numMasters, int numSlaves, List<Integer> rsPorts)`
`MiniHBaseCluster`	`startMiniHBaseCluster(int numMasters, int numSlaves, List<Integer> rsPorts, Class<? extends HMaster> masterClass, Class<? extends MiniHBaseCluster.MiniHBaseClusterRegionServer> regionserverClass, boolean create, boolean withWALDir)` Starts up mini hbase cluster.
`org.apache.hadoop.mapred.MiniMRCluster`	`startMiniMapReduceCluster()` Starts a `MiniMRCluster` with a default number of `TaskTracker`'s.
`Table`	`truncateTable(TableName tableName)` Truncate a table using the admin command.
`Table`	`truncateTable(TableName tableName, boolean preserveRegions)` Truncate a table using the admin command.
`void`	`unassignRegion(byte[] regionName)` Unassign the named region.
`void`	`unassignRegion(String regionName)` Unassign the named region.
`void`	`unassignRegionByRow(byte[] row, RegionLocator table)` Closes the region containing the given row.
`void`	`unassignRegionByRow(String row, RegionLocator table)` Closes the region containing the given row.
`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)`
`void`	`verifyTableDescriptorIgnoreTableName(TableDescriptor ltd, TableDescriptor rtd)`
`static void`	`waitForHostPort(String host, int port)`
`void`	`waitLabelAvailable(long timeoutMillis, String... labels)` Wait until labels is ready in VisibilityLabelsCache.
`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(byte[] table)` Waits for a table to be 'disabled'.
`void`	`waitTableDisabled(byte[] table, long timeoutMillis)` Waits for a table to be 'disabled'.
`void`	`waitTableDisabled(TableName table, long millisTimeout)`
`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 a configuable timeout value (default is 60 seconds) This means all regions have been deployed, master has been informed and updated hbase:meta with the regions deployed server.
`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`	`waitUntilAllSystemRegionsAssigned()` Waith until all system table's regions get assigned
`void`	`waitUntilNoRegionsInTransition()` Wait until no regions in transition.
`void`	`waitUntilNoRegionsInTransition(long timeout)` Wait until no regions in transition.

Methods inherited from class org.apache.hadoop.hbase.HBaseZKTestingUtility
cleanupTestDir, getZkCluster, getZooKeeperWatcher, getZooKeeperWatcher, setupClusterTestDir, setZkCluster, shutdownMiniZKCluster, startMiniZKCluster, startMiniZKCluster

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

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

PRESPLIT_TEST_TABLE_KEY

public static final String PRESPLIT_TEST_TABLE_KEY

See Also:: Constant Field Values

PRESPLIT_TEST_TABLE

public static final boolean PRESPLIT_TEST_TABLE

See Also:: Constant Field Values

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

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(Table, 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()
```
  Create an HBaseTestingUtility using a default configuration.
  Initially, all tmp files are written to a local test data directory. Once startMiniDFSCluster(int) is called, either directly or via startMiniCluster(), tmp data will be written to the DFS directory instead.
  Previously, there was a distinction between the type of utility returned by createLocalHTU() and this constructor; this is no longer the case. All HBaseTestingUtility objects will behave as local until a DFS cluster is started, at which point they will switch to using mini DFS for storage.
- HBaseTestingUtility
```
public HBaseTestingUtility(@Nullable
                           org.apache.hadoop.conf.Configuration conf)
```
  Create an HBaseTestingUtility using a given configuration.
  Initially, all tmp files are written to a local test data directory. Once startMiniDFSCluster(int) is called, either directly or via startMiniCluster(), tmp data will be written to the DFS directory instead.
  Previously, there was a distinction between the type of utility returned by createLocalHTU() and this constructor; this is no longer the case. All HBaseTestingUtility objects will behave as local until a DFS cluster is started, at which point they will switch to using mini DFS for storage.
  
  Parameters:
  
  conf - The configuration to use for further operations

Method Detail

available
```
public static boolean available(int port)
```
Checks to see if a specific port is available.

Parameters:

port - the port number to check for availability

Returns:

true if the port is available, or false if not

memStoreTSTagsAndOffheapCombination

public static List<Object[]> memStoreTSTagsAndOffheapCombination()

createLocalHTU
```
@Deprecated
public static HBaseTestingUtility createLocalHTU()
```
Deprecated. use HBaseTestingUtility() instead

Returns:

a normal HBaseTestingUtility

createLocalHTU

@Deprecated
public static HBaseTestingUtility createLocalHTU(org.apache.hadoop.conf.Configuration c)

Deprecated. use HBaseTestingUtility(Configuration) instead

Returns:: a normal HBaseTestingUtility

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

getConfiguration
```
public org.apache.hadoop.conf.Configuration getConfiguration()
```
Returns this classes's instance of Configuration. Be careful how you use the returned Configuration since Connection instances can be shared. The Map of Connections 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 org.apache.hadoop.fs.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
```
@Deprecated
public HTableDescriptor getMetaTableDescriptor()
```
Deprecated. since 2.0 version and will be removed in 3.0 version. use getMetaTableDescriptorBuilder()

Returns:

META table descriptor

getMetaTableDescriptorBuilder

public TableDescriptorBuilder getMetaTableDescriptorBuilder()

Returns:: META table descriptor

getDataTestDirOnTestFS
```
public org.apache.hadoop.fs.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 org.apache.hadoop.fs.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 org.apache.hadoop.hdfs.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 org.apache.hadoop.hdfs.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 org.apache.hadoop.hdfs.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 org.apache.hadoop.hdfs.MiniDFSCluster startMiniDFSCluster(int servers,
                                                                 String[] racks,
                                                                 String[] hosts)
                                                          throws Exception

Throws:: Exception

startMiniDFSClusterForTestWAL

public org.apache.hadoop.hdfs.MiniDFSCluster startMiniDFSClusterForTestWAL(int namenodePort)
                                                                    throws IOException

Throws:: IOException

isNewVersionBehaviorEnabled
```
public boolean isNewVersionBehaviorEnabled()
```
Check whether the tests should assume NEW_VERSION_BEHAVIOR when creating new column families. Default to false.

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

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(boolean withWALDir)
                                  throws Exception
```
Start up a minicluster of hbase, dfs, and zookeeper where WAL's walDir is created separately.

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 numSlaves,
                                         boolean create,
                                         boolean withWALDir)
                                  throws Exception

Throws:: Exception

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,
                                         boolean withWALDir)
                                  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,
                                              List<Integer> rsPorts)
                                       throws IOException,
                                              InterruptedException

Throws:: IOException; InterruptedException

startMiniHBaseCluster

public MiniHBaseCluster startMiniHBaseCluster(int numMasters,
                                              int numSlaves,
                                              List<Integer> rsPorts,
                                              Class<? extends HMaster> masterClass,
                                              Class<? extends MiniHBaseCluster.MiniHBaseClusterRegionServer> regionserverClass,
                                              boolean create,
                                              boolean withWALDir)
                                       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:: rsPorts - Ports that RegionServer should use; pass ports if you want to test cluster restart where for sure the regionservers come up on same address+port (but just with different startcode); by default mini hbase clusters choose new arbitrary ports on each cluster start.; 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)

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

Throws:

IOException - in case command is unsuccessful

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

Throws:

IOException - throws in case command is unsuccessful

getDefaultRootDirPath
```
public org.apache.hadoop.fs.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 org.apache.hadoop.fs.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 org.apache.hadoop.fs.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 org.apache.hadoop.fs.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

createWALRootDir
```
public org.apache.hadoop.fs.Path createWALRootDir()
                                           throws IOException
```
Creates a hbase walDir in the user's home directory. Normally you won't make use of this method. Root hbaseWALDir is created for you as part of mini cluster startup. You'd only use this method if you were doing manual operation.

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:: A Table instance for the created table.
Throws:: IOException

createTable

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

Create a table.

Parameters:: tableName -; families -
Returns:: A Table instance for the created table.
Throws:: IOException

createTable

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

Create a table.

Parameters:: tableName -; family -
Returns:: A Table instance for the created table.
Throws:: IOException

createMultiRegionTable

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

Create a table with multiple regions.

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

createTable

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

Create a table.

Parameters:: tableName -; families -
Returns:: A Table instance for the created table.
Throws:: IOException

createMultiRegionTable

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

Create a table with multiple regions.

Parameters:: tableName -; families -
Returns:: A Table instance for the created table.
Throws:: IOException

createTable

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

Create a table.

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

createTable
```
public Table createTable(TableName tableName,
                         byte[][] families,
                         byte[][] splitKeys,
                         int replicaCount)
                  throws IOException
```
Create a table.

Parameters:

tableName - the table name

families - the families

splitKeys - the splitkeys

replicaCount - the region replica count

Returns:

A Table instance for the created table.

Throws:

IOException - throws IOException

createTable

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

Throws:: IOException

createTable

public Table createTable(TableDescriptor htd,
                         byte[][] families,
                         org.apache.hadoop.conf.Configuration c)
                  throws IOException

Create a table.

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

createTable

public Table createTable(TableDescriptor htd,
                         byte[][] families,
                         byte[][] splitKeys,
                         org.apache.hadoop.conf.Configuration c)
                  throws IOException

Create a table.

Parameters:: htd - table descriptor; families - array of column families; splitKeys - array of split keys; c - Configuration to use
Returns:: A Table instance for the created table.
Throws:: IOException - if getAdmin or createTable fails

createTable

public Table createTable(TableDescriptor htd,
                         byte[][] families,
                         byte[][] splitKeys,
                         BloomType type,
                         int blockSize,
                         org.apache.hadoop.conf.Configuration c)
                  throws IOException

Create a table.

Parameters:: htd - table descriptor; families - array of column families; splitKeys - array of split keys; type - Bloom type; blockSize - block size; c - Configuration to use
Returns:: A Table instance for the created table.
Throws:: IOException - if getAdmin or createTable fails

createTable
```
public Table createTable(TableDescriptor htd,
                         byte[][] splitRows)
                  throws IOException
```
Create a table.

Parameters:

htd - table descriptor

splitRows - array of split keys

Returns:

A Table instance for the created table.

Throws:

IOException

createTable

public Table createTable(TableName tableName,
                         byte[][] families,
                         byte[][] splitKeys,
                         int replicaCount,
                         org.apache.hadoop.conf.Configuration c)
                  throws IOException

Create a table.

Parameters:: tableName - the table name; families - the families; splitKeys - the split keys; replicaCount - the replica count; c - Configuration to use
Returns:: A Table instance for the created table.
Throws:: IOException

createTable

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

Create a table.

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

createTable

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

Create a table.

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

createTable

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

Create a table.

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

createMultiRegionTable

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

Create a table with multiple regions.

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

createTable

public Table createTable(TableName tableName,
                         byte[][] families,
                         int numVersions,
                         int blockSize)
                  throws IOException

Create a table.

Parameters:: tableName -; families -; numVersions -; blockSize -
Returns:: A Table instance for the created table.
Throws:: IOException

createTable

public Table createTable(TableName tableName,
                         byte[][] families,
                         int numVersions,
                         int blockSize,
                         String cpName)
                  throws IOException

Throws:: IOException

createTable

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

Create a table.

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

createTable

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

Create a table.

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

createMultiRegionTable

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

Create a table with multiple regions.

Parameters:: tableName -; family -
Returns:: A Table instance for the created table.
Throws:: IOException

modifyTableSync

public static void modifyTableSync(Admin admin,
                                   TableDescriptor 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(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

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

Deprecated.

createTableDescriptor
```
@Deprecated
public HTableDescriptor createTableDescriptor(String name)
```
Deprecated.

Create a table of name name.

Parameters:

name - Name to give table.

Returns:

Column descriptor.

createTableDescriptor

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

createTableDescriptor
```
public HTableDescriptor createTableDescriptor(TableName name)
```
Create a table of name name.

Parameters:

name - Name to give table.

Returns:

Column descriptor.

createTableDescriptor

public HTableDescriptor createTableDescriptor(TableName tableName,
                                              byte[] family)

createTableDescriptor

public HTableDescriptor createTableDescriptor(TableName tableName,
                                              byte[][] families,
                                              int maxVersions)

createLocalHRegion
```
public HRegion createLocalHRegion(TableDescriptor desc,
                                  byte[] startKey,
                                  byte[] endKey)
                           throws IOException
```
Create an HRegion that writes to the local tmp dirs

Parameters:

desc - a table descriptor indicating which table the region belongs to

startKey - the start boundary of the region

endKey - the end boundary of the region

Returns:

a region that writes to local dir for testing

Throws:

IOException

createLocalHRegion

public HRegion createLocalHRegion(RegionInfo info,
                                  TableDescriptor desc)
                           throws IOException

Create an HRegion that writes to the local tmp dirs. Creates the WAL for you. Be sure to call closeRegionAndWAL(HRegion) when you're finished with it.

Throws:: IOException

createLocalHRegion

public HRegion createLocalHRegion(RegionInfo info,
                                  TableDescriptor 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

@Deprecated
public HRegion createLocalHRegion(byte[] tableName,
                                              byte[] startKey,
                                              byte[] stopKey,
                                              String callingMethod,
                                              org.apache.hadoop.conf.Configuration conf,
                                              boolean isReadOnly,
                                              Durability durability,
                                              WAL wal,
                                              byte[]... families)
                                       throws IOException

Deprecated. use #createLocalHRegion(TableName, byte[], byte[], boolean, Durability, WAL, byte[]...)

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

createLocalHRegion

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

Parameters:: tableName -; startKey -; stopKey -; isReadOnly -; families -
Returns:: A region on which you must call closeRegionAndWAL(HRegion) when done.
Throws:: IOException

createLocalHRegionWithInMemoryFlags

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

Throws:: IOException

deleteTableData
```
public Table 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 Table 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 Table 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

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

loadRandomRows

public void loadRandomRows(Table t,
                           byte[] f,
                           int rowSize,
                           int totalRows)
                    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(Table 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,
                     Scan scan)
              throws IOException

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

countRows

public int countRows(Region region)
              throws IOException

Throws:: IOException

countRows

public int countRows(Region region,
                     Scan scan)
              throws IOException

Throws:: IOException

countRows

public int countRows(InternalScanner scanner)
              throws IOException

Throws:: IOException

checksumRows

public String checksumRows(Table table)
                    throws Exception

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

Throws:: Exception

createMultiRegionsInMeta
```
@Deprecated
public List<HRegionInfo> createMultiRegionsInMeta(org.apache.hadoop.conf.Configuration conf,
                                                              HTableDescriptor htd,
                                                              byte[][] startKeys)
                                                       throws IOException
```
Deprecated. since 2.0 version and will be removed in 3.0 version. use createMultiRegionsInMeta(Configuration, TableDescriptor, byte[][])

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

createMultiRegionsInMeta

public List<RegionInfo> createMultiRegionsInMeta(org.apache.hadoop.conf.Configuration conf,
                                                 TableDescriptor 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

createWal

public static WAL createWal(org.apache.hadoop.conf.Configuration conf,
                            org.apache.hadoop.fs.Path rootDir,
                            RegionInfo hri)
                     throws IOException

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

Throws:: IOException

createRegionAndWAL

public static HRegion createRegionAndWAL(RegionInfo info,
                                         org.apache.hadoop.fs.Path rootDir,
                                         org.apache.hadoop.conf.Configuration conf,
                                         TableDescriptor 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(RegionInfo info,
                                         org.apache.hadoop.fs.Path rootDir,
                                         org.apache.hadoop.conf.Configuration conf,
                                         TableDescriptor 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

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.

getOtherRegionServer

public HRegionServer getOtherRegionServer(HRegionServer rs)

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.

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 org.apache.hadoop.mapred.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(ZKWatcher nodeZK)
                   throws Exception

Throws:: Exception

expireSession
```
public void expireSession(ZKWatcher nodeZK,
                          boolean checkStatus)
                   throws Exception
```
Expire a ZooKeeper session as recommended in ZooKeeper documentation http://hbase.apache.org/book.html#trouble.zookeeper There are issues when doing this: [1] http://www.mail-archive.com/[email protected]/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 a Table 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
```
@Deprecated
public HBaseAdmin getHBaseAdmin()
                                     throws IOException
```
Deprecated. Since 2.0. Will be removed in 3.0. Use getAdmin() instead.

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:

HBaseAdmin instance which is guaranteed to support only Admin interface. Functions in HBaseAdmin not provided by Admin interface can be changed/deleted anytime.

Throws:

IOException

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

Throws:

IOException

getHbck
```
public Hbck getHbck()
             throws IOException
```
Returns an Hbck instance. Needs be closed when done.

Throws:

IOException

unassignRegion
```
public void unassignRegion(String regionName)
                    throws IOException
```
Unassign the named region.

Parameters:

regionName - The region to unassign.

Throws:

IOException

unassignRegion
```
public void unassignRegion(byte[] regionName)
                    throws IOException
```
Unassign the named region.

Parameters:

regionName - The region to unassign.

Throws:

IOException

unassignRegionByRow

public void unassignRegionByRow(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

unassignRegionByRow

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

getDFSCluster

public org.apache.hadoop.hdfs.MiniDFSCluster getDFSCluster()

setDFSCluster

public void setDFSCluster(org.apache.hadoop.hdfs.MiniDFSCluster cluster)
                   throws IllegalStateException,
                          IOException

Throws:: IllegalStateException; IOException

setDFSCluster
```
public void setDFSCluster(org.apache.hadoop.hdfs.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 org.apache.hadoop.fs.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

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

explainTableAvailability

public String explainTableAvailability(TableName tableName)
                                throws IOException

Throws:: IOException

explainTableState

public String explainTableState(TableName table,
                                TableState.State state)
                         throws IOException

Throws:: IOException

findLastTableState

@Nullable
public TableState findLastTableState(TableName table)
                                        throws IOException

Throws:: 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) Tolerates nonexistent table.

Parameters:

table - Table to wait on.

table -

Throws:

InterruptedException

IOException

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:

waitTableEnabled(TableName, long)

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(TableName table,
                              long millisTimeout)
                       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

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(org.apache.hadoop.conf.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 w/o Kerberos.

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

assignRegion
```
public boolean assignRegion(RegionInfo regionInfo)
                     throws IOException,
                            InterruptedException
```
Uses directly the assignment manager to assign the region. and waits until the specified region has completed assignment.

Returns:

true if the region is assigned false otherwise.

Throws:

IOException

InterruptedException

moveRegionAndWait

public void moveRegionAndWait(RegionInfo destRegion,
                              ServerName destServer)
                       throws InterruptedException,
                              IOException

Move region to destination server and wait till region is completely moved and online

Parameters:: destRegion - region to move; destServer - destination server of the region
Throws:: InterruptedException; IOException

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 a configuable timeout value (default is 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

waitUntilAllSystemRegionsAssigned

public void waitUntilAllSystemRegionsAssigned()
                                       throws IOException

Waith until all system table's regions get assigned

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

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 Table createRandomTable(TableName 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

randomFreePort
```
public static int randomFreePort()
```

randomMultiCastAddress

public static String randomMultiCastAddress()

waitForHostPort

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

Throws:: IOException