All Classes and Interfaces
Class
Description
Simple tool to test options parsing.
Based class for testing operation timeout logic for
ConnectionImplementation.Based class for testing rpc timeout logic for
ConnectionImplementation.Based class for testing timeout logic for
ConnectionImplementation.This copro sleeps 20 second.
Base class for testing distributed log splitting.
Some basic ipc tests.
Test log deletion as logs are rolled.
Tests that verifies that the log is forced to be rolled every "hbase.regionserver.logroll.period"
WAL tests that can be reused across providers.
Base class to test Configuration Update logic.
Test replay of edits out of a WAL split.
Base class for parameterized unit tests that use X509TestContext for testing different X509
parameter combinations (CA key type, cert key type, with/without a password, with/without
hostname verification, etc).
Test case that uses multiple threads to read and write multifamily rows into a table, verifying
that reads never see partially-complete writes.
A test tool that uses multiple threads to read and write multifamily rows into a table, verifying
that reads never see partially-complete writes
Thread that does single-row reads in a table, looking for partially completed rows.
Thread that does random full-row writes into a table.
Thread that does full scans of the table looking for any partially completed rows.
A (possibly mischievous) action that the ChaosMonkey can perform.
Context for Action's
Action the adds a column family to a table.
Action that adds high cpu load to a random regionserver for a given duration
Always fail the put.
Simple test constraint that always allows the put to pass
An implementation of HMaster that always runs as a stand by and never transitions to active.
An implementation of ActiveMasterManager that never transitions it's master to active state.
Helper methods for matching against instances of
Attributes.A bad Master Observer to prevent user to create/delete table once.
Class used to be the base of unit tests on load balancers.
This is the base class for HBaseFsck's ability to detect reasons for inconsistent tables.
Restarts a ratio of the running regionservers at the same time
Utility to generate a bound socket.
A scan result consumer which buffers all the data in memory and you can call the
BufferingScanResultConsumer.take()
method below to get the result one by one.Utility class to check whether a given class conforms to builder-style: Foo foo = new Foo()
.setBar(bar) .setBaz(baz)
Dummy input split to be used by
BulkDataGeneratorRecordReaderCounter enumeration to count number of rows generated.
A command line utility to generate pre-splitted HBase Tables with large amount (TBs) of random
data, equally distributed among all regions.
Helper methods for matching against values passed through the helper methods of
Bytes.Chaos Monkey that does nothing.
Factory to create a calm ChaosMonkey.
Action that tries to adjust the bloom filter setting on all the columns of a table
Action that changes the compression algorithm on a column family from a list of tables.
Action that changes the encoding on a column family from a list of tables.
Action that changes the number of versions on a column family from a list of tables.
A utility to injects faults in a running cluster.
Test Constraint to check to make sure the configuration is set
A class that finds a set of classes that are locally accessible (from .class or .jar files), and
satisfy the conditions that are imposed by name and class filters provided by the user.
Some utilities to help class loader testing
ClassFinder that is pre-configured with filters that will only allow test classes.
Filters both test classes and anything in the hadoop-compat modules
A
TestRule that clears all user namespaces and tables before the test executes.Test that we can actually send and use region metrics to slowdown client writes
Tag a test as related to the client.
Base class for testing clone snapsot
ClusterManager is an api to manage servers in a distributed environment.
Type of the service daemon
Do basic codec performance eval.
Action that queues a table compaction.
Region that queues a compaction of a random region from the table.
Action that queues a table compaction.
A policy that runs multiple other policies one after the other
A
Rule that manages the lifecycle of an instance of AsyncConnection.A blocking queue implementation for adding a constant delay.
Class to generate several lists of StoreFiles that are all the same size.
Overrides commands to make use of coprocessor where possible.
Tag a test as related to coprocessors.
Action corrupts HFiles with a certain chance.
Corrupt network packets on a random regionserver.
Creates an HFile with random key/value pairs.
Tests the pluggable authentication framework with SASL using a contrived authentication system.
Client provider that finds custom Token in the user's UGI and authenticates with the server via
DIGEST-MD5 using that password.
Custom provider which can select our custom provider, amongst other tokens which may be
available.
Server provider which validates credentials from an in-memory database.
A custom token identifier for our custom auth'n method.
Tests various algorithms for key compression on an existing HFile.
A chaos monkey to delete and corrupt regionserver data, requires a user with passwordless ssh
access to the cluster and sudo privileges.
Action adds latency to communication on a random regionserver.
Action deletes HFiles with a certain chance.
Manages the interactions with an already deployed distributed cluster (as opposed to a
pseudo-distributed, or mini/local cluster).
A chaos monkey to create distributed cluster related issues, requires a user with passwordless
ssh access to the cluster and sudo privileges.
A policy which performs a sequence of actions deterministically.
Registry that does nothing.
DummyAsyncTable<C extends org.apache.hadoop.hbase.client.ScanResultConsumerBase>
Can be overridden in UT if you only want to implement part of the methods in
AsyncTable.Just a dummy exception for testing IPCUtil.isFatalConnectionException.
Just a dummy exception for testing IPCUtil.isFatalConnectionException.
A dummy replication endpoint that does nothing, for test use only.
Action to dump the cluster status.
Duplicate network packets on a random regionserver.
Test seek performance for encoded data blocks.
Used by tests to inject an edge into the manager.
Simple test coprocessor for injecting exceptions on Get requests.
Helper methods for matching against instances of
EventData.Test Policy to compact everything every time.
This is a VisibilityLabelService where labels in Mutation's visibility expression will be
persisted as Strings itself rather than ordinals in 'labels' table.
Class to create list of mock storefiles of specified length.
This is a utility class, used by tests, which fails operation specified by FailureType enum
This class is used for testing only.
Just a copy of the old log4j12 FileAppender.
Create a non-abstract "proxy" for FileSystem because FileSystem is an abstract class and not an
interface.
Fill the disk on a random regionserver.
By using this class as the super class of a set of tests you will have a HBase testing cluster
available that is very suitable for writing tests for scanning and filtering against.
Tag a test as related to the
org.apache.hadoop.hbase.filter package.Tag a test as failing commonly on public build infrastructure.
Action that tries to flush a random region of a table.
Action that tries to flush a table.
Action that tries to force a balancer run.
Base for TestFromClientSide* classes.
Test provides some very generic helpers which might be used across the tests
Mockito answer helper that triggers one latch as soon as the method is called, then waits on
another before continuing.
An Answer implementation that simply forwards all calls through to a delegate.
An Answer implementation which sleeps for a random number of milliseconds between 0 and a
configurable value before delegating to the real implementation of the method.
Gracefully restarts every regionserver in a rolling fashion.
A
UserProvider that always says hadoop security is enabled, regardless of the underlying
configuration.A compatibility shim layer for interacting with different versions of Hadoop.
Compatibility shim layer implementation for Hadoop-2.
The class level TestRule for all the tests.
A RunListener to confirm that we have a
HBaseClassTestRule class rule for every test.This class defines methods that can help with managing HBase clusters from unit tests and system
tests.
A default cluster manager for HBase.
Provides command strings for services to be executed by Shell.
CommandProvider to manage the service using sbin/hadoop-* scripts.
CommandProvider to manage the service using bin/hbase-* scripts
CommandProvider to manage the service using bin/zk* scripts.
Common helpers for testing HBase that do not depend on specific server/etc.
Determines HBase home path from either class or jar directory
Log4j2 appender to be used when running UTs.
Data to pass to factory method.Unable to instantiate
Factory to create the Appender.
Deprecated.
since 2.0.0 and will be removed in 3.0.0.
Facility for testing HBase.
A tracker for tracking and validating table rows generated with
HBaseTestingUtility.loadTable(Table, byte[])Helpers for testing HBase that do not depend on specific server/etc.
Connection testing utility.This coproceesor sleep 2s at first increment/append rpc call.
Configuration common across the HDFS Actions.
Test helper for testing archiving of HFiles
This class runs performance benchmarks for
HFile.Utility class for HFile-related testing.
Similar to
HConstants but for tests.This is a base class for functional tests of the
HttpServer.This Integration Test verifies acid guarantees across column families by frequently writing
values to rows with multiple column families and concurrently reading entire rows that expect all
column families.
An integration test to detect regressions in HBASE-7912.
Base class for HBase integration tests that want to use the Chaos Monkey.
This is an integration test borrowed from goraci, written by Keith Turner, which is in turn
inspired by the Accumulo test called continous ingest (ci).
A stand alone program that deletes a single node.
A Map only job that generates random linked list and stores them.
Some ASCII art time:
Ensure output files from prev-job go to map inputs for current job
Executes Generate and Verify in a loop.
A stand alone program that prints out portions of a list created by
IntegrationTestBigLinkedList.GeneratorTool to search missing rows in WALs and hfiles.
WALPlayer override that searches for keys loaded in the setup.
The actual searcher mapper.
A Map Reduce job that verifies that the linked lists generated by
IntegrationTestBigLinkedList.Generator do not have
any holes.Don't change the order of these enums.
Per reducer, we output problem rows as byte arrays so can be used as input for subsequent
investigative mapreduce jobs.
A stand alone program that follows a linked list created by
IntegrationTestBigLinkedList.Generator and prints timing
info.IT test used to verify the deletes with visibility labels.
Test Bulk Load and MR on a distributed cluster.
Comparator used to order linkKeys so that they are passed to a reducer in order.
Writable used as the value emitted from a pass over the hbase table.
Mapper to pass over the table.
Class that does the actual checking of the links.
Mapper that creates a linked list of KeyValues.
Writable class used as the key to group links in the linked list.
Comparator used to figure out if a linkKey should be grouped together.
Class to figure out what partition to send a link in the chain to.
Integration test that verifies Procedure V2.
Test Bulk Load and MR on a distributed cluster.
Validate ImportTsv + LoadIncrementalHFiles on a distributed cluster.
A base class for tests that do something with the cluster while running
LoadTestTool to
write and verify some data.A test class that does the same things as IntegrationTestIngest but with stripe compactions.
/** An Integration class for tests that does something with the cluster while running
LoadTestTool to write and verify some data.Integration Test for MOB ingest.
Facility for integration/system tests.
Integration test that verifies lazy CF loading during scans by doing repeated scans with this
feature while multiple threads are continuously writing values; and verifying the result.
Custom LoadTestDataGenerator.
A large test which loads a lot of data that has internal references, and verifies the data.
Tool to search missing rows in WALs and hfiles.
The actual searcher mapper.
This integration test loads successful resource retrieval records from the Common Crawl
(https://commoncrawl.org/) public dataset into an HBase table and writes records that can be used
to later verify the presence and integrity of those records.
An integration test to detect regressions in HBASE-7220.
An integration test that starts the cluster with three replicas for the meta It then creates a
table, flushes the meta, kills the server holding the primary.
An integration test to detect regressions in HBASE-22749.
This is an integration test for showing a simple usage of how to use
Monkeys to control
ChaosMonkeyRunner.Integration test that should benchmark how fast HBase can recover from failures.
Callable that will keep going to the master for cluster status.
Callable used to make sure the cluster has some load on it.
Callable that will keep putting small amounts of data into a table until the future supplied
returns.
Callable that will keep scanning for small amounts of data until the supplied future returns.
Base class for actions that need to record the time needed to recover from a failure.
Class to store results of TimingCallable.
Test for comparing the performance impact of region replicas.
Wraps the invocation of
PerformanceEvaluation in a Callable.Extract a descriptive statistic from a
Histogram.Record the results from a single
PerformanceEvaluation job run.Integration test for testing async wal replication to secondary region replicas.
This extends MultiThreadedWriter to add a configurable delay to the keys written by the writer
threads to become available to the MultiThradedReader threads.
This extends MultiThreadedWriter to add a configurable delay to the keys written by the writer
threads to become available to the MultiThradedReader threads.
This is an integration test for replication.
Wrapper around an HBase ClusterID allowing us to get admin connections and configurations for
it
Tag a test as 'integration/system' test, meaning that the test class has the following
characteristics:
Possibly takes hours to complete
Can be run on a mini cluster or an actual cluster
Can make changes to the given cluster (starting stopping daemons, etc)
Should not be run in parallel of other integration tests
Integration / System tests should have a class name starting with "IntegrationTest", and should
be annotated with @Category(IntegrationTests.class).
This class drives the Integration test suite execution.
Test that we add tmpjars correctly including the named dependencies.
An integration test to test
TableSnapshotInputFormat which enables reading directly from
snapshot files without going through hbase servers.Extends
IntegrationTestTimeBoundedRequestsWithRegionReplicas for multi-gets Besides the
options already talked about in IntegrationTestTimeBoundedRequestsWithRegionReplicas the addition
options here are:An IntegrationTest for doing reads with a timeout, to a read-only table with region replicas.
A large test which loads a lot of data with cell visibility, and verifies the data.
An integration test which checks that the znodes in zookeeper and data in the FileSystem are
protected for secure HBase deployments.
A WAL Provider that returns a single thread safe WAL that optionally can skip parts of our normal
interactions with HDFS.
Presumes init will be called by a single thread prior to any access of other methods.
Tag a test as related to the
org.apache.hadoop.hbase.io package.A simple Jersey resource class TestHttpServer.
Return a fixed secret key for AES for testing.
A fixture that implements and presents a KeyValueScanner.
Generate random <key, value> pairs.
Tagging a test as 'large', means that the test class has the following characteristics:
it can executed in an isolated JVM (Tests can however be executed in different JVM on the
same machine simultaneously so be careful two concurrent tests end up fighting over ports or
other singular resources).
ideally, the whole large test-suite/class, no matter how many or how few test methods it has,
will run in last less than three minutes
No large test can take longer than ten minutes; it will be killed.
class for masquerading System.exit(int).
Advise the scanning infrastructure to collect up to
limit results.Tool to test performance of different
LoadBalancer
implementations.Used for FavoredNode unit tests
A generator of random data (keys/cfs/columns/values) for load testing.
A load test data generator for MOB
A generator of random keys and values for load testing.
A command-line utility that reads, writes, and verifies data.
Lose network packets on a random regionserver.
This class provides shims for HBase to interact with the Hadoop 1.0.x and the Hadoop 0.23.x
series.
This class provides shims for HBase to interact with the Hadoop 1.0.x and the Hadoop 0.23.x
series.
Tag a test as related to mapred or mapreduce.
A chaos monkey to kill the active master periodically.
Tool to test performance of locks and queues in procedure scheduler independently from other
framework components.
Hook which will be executed on each step
Tag a test as related to the master.
An implementation of
Waiter.ExplainingPredicate that uses Hamcrest Matcher for
both predicate evaluation and explanation.Tagging a test as 'medium' means that the test class has the following characteristics:
it can be executed in an isolated JVM (Tests can however be executed in different JVMs on the
same machine simultaneously so be careful two concurrent tests end up fighting over ports or
other singular resources).
ideally, the whole medium test-suite/class, no matter how many or how few test methods it
has, will complete in 50 seconds; otherwise make it a 'large' test.
Use it for tests that cannot be tagged as 'small'.
Action to merge regions of a table.
Mocking utility for common hbase:meta functionality
Base class for testing the scenarios where replicas are enabled for the meta table.
Interface of a class to make assertions about metrics values.
A helper class that will allow tests to get into hadoop2's metrics2 values.
Tag a test that covers our metrics handling.
A
TestRule that manages an instance of the MiniHBaseCluster.A builder for fluent composition of a new
MiniClusterRule.This class creates a single process HBase cluster.
Subclass so can get at protected methods (none at moment).
Alternate shutdown hook.
Tag a test as not easily falling into any of the below categories.
This is a copy of NoKillMonkeyFactory that also does mob compactions.
This is a copy of SlowDeterministicMonkeyFactory that also does mob compactions.
Reproduction for MOB data loss 1.
A mock used so our tests don't deal with actual StoreFiles
A
Rule that manages a simple http server.A mocked master services.
A mock RegionServer implementation.
Basic mock region server services.
Basic mock Server for handler tests.
Base class of objects that can create mock store files with a given size.
Base class of the factory that will create a ChaosMonkey.
This class can be used to control chaos monkeys life cycle.
Action that tries to move a random region of a table.
Action that tries to move every region of a table.
Base set of tests and setup for input formats touching multiple tables.
Pass the key and value to reducer.
Checks the last and first keys seen against the scanner boundaries.
Common base class for reader and writer parts of multi-thread HBase load test (See LoadTestTool).
Default implementation of LoadTestDataGenerator that uses LoadTestKVGenerator, fixed set of
column families, and random number of columns in range.
Creates multiple threads that read and verify previously written data
A MultiThreadReader that helps to work with ACL
A test thread that performs a repeating operation.
A thread that can be added to a test context, and properly passes exceptions through.
Creates multiple threads that write key/values into the
A MultiThreadUpdater that helps to work with ACL
Creates multiple threads that write key/values into the
Creates multiple threads that write key/values into the
MultiThreadedWriter that helps in testing ACL
A nano-second timer.
Input format that creates a configurable number of map tasks each provided with a single row of
NullWritables.
A helper class for writing UTs, where we will eat the EOF and return null when reaching EOF, so
in UTs we do not need to deal with partial WAL files if this does not affect the correctness.
Monkey factory to create a ChaosMonkey that will not need access to ssh.
An clock which will never return the same clock twice.
RegionObserver that just reimplements the default behavior, in order to validate that all the
necessary APIs for this are public This observer is also used in
TestFromClientSideWithCoprocessor and TestCompactionWithCoprocessor to make sure
that a wide range of functionality still behaves as expected.A region server that will OOME.
Like
OpenTelemetryRule, except modeled after the junit5 implementation
OpenTelemetryExtension.Used alongside
OpenTelemetryClassRule.Script used evaluating HBase performance and scalability.
Script used evaluating Stargate performance and scalability.
Base class for operations that are CAS-like; that read a value and then set it based off what
they read.
Describes a command.
Describes a command.
Enum for map metrics.
Enum for map metrics.
MapReduce job that runs a performance evaluation client in each map task.
MapReduce job that runs a performance evaluation client in each map task.
InputFormat of Performance Evaluation MapReduce job.
This class works as the InputSplit of Performance Evaluation MapReduce InputFormat, and the
Record Value of RecordReader.
Implementations can have their status set.
Implementations can have their status set.
Wraps up options passed to
PerformanceEvaluation.Wraps up options passed to
PerformanceEvaluation tests This
makes the reflection logic a little easier to understand...Code shared by PE tests.
This is not a unit test.
A policy which does stuff every time interval.
A policy, which picks a random action according to the given weights, and performs it every
configurable period.
A policy to introduce chaos to the cluster
A context for a Policy
Chaos monkey that given multiple policies will run actions against the cluster.
ProcedureStorePerformanceEvaluation<T extends org.apache.hadoop.hbase.procedure2.store.ProcedureStore>
Base class for testing procedure store performance.
A helper class for process-based mini-cluster tests.
A class that generates random numbers that follow some distribution.
Binomial distribution.
Interface for discrete (integer) random distributions.
P(i)=1/(max-min)
Zipf distribution.
These helper methods generate random byte[]'s data for KeyValues
Generate list of key values which are very useful to test data block encoding and compression.
An implementation of
Table that sits directly on a Region; it decorates the passed in
Region instance with the Table API.This runs on local filesystem.
Tag a test as related to the regionserver.
HTable interface to remote tables accessed via REST gateway
Action that removes a column family.
Reorder network packets on a random regionserver.
Base class for testing replication for dropped tables.
A helper tool for generating random
ReplicationPeerConfig and do assertion.Source that does nothing at all, helpful to test ReplicationSourceManager
Tag a test as related to replication.
Utility class to check the resources: - log them before and after each test method - check them
against a minimum or maximum - check that they don't leak during the test
Class to implement for each type of resource.
Listen to the test progress and check the usage of:
threads
open file descriptor
max open file descriptor
A ClusterManager implementation designed to control Cloudera Manager (http://www.cloudera.com)
clusters via REST API.
Represents of the high-level health status of a subject in the cluster.
Represents the configured run state of a role.
Base class for restarting HBaseServer's
Action that tries to restart the active master.
Action that tries to restart the active namenode.
A command-line tool that spins up a local process-based cluster, loads some data, restarts the
regionserver holding hbase:meta, and verifies that the cluster recovers.
Action that restarts a random datanode.
Action that restarts a random HRegionServer
Action that restarts a random zookeeper node.
Action that tries to restart the HRegionServer holding Meta.
Action that restarts an HRegionServer holding one of the regions of the table.
Base class for testing restore snapshot
Tag a test as related to the REST capability of HBase.
Restarts a ratio of the regionservers in a rolling fashion.
Suspend then resume a ratio of the regionservers in a rolling fashion.
Tag a test as related to RPC.
Base UT of RSGroupableBalancer.
Always non-gracefully fail on attempt
Class for testing WALObserver coprocessor.
A simple performance evaluation tool for single client and MR scans and snapshot scans.
The class for set up a security cluster with kerberos, hdfs, hbase.
Utility methods for testing security
An AccessTestAction performs an action that will be examined to confirm the results conform to
expected access rights.
Tag a test as related to security.
Base class for testing serial replication.
Creates ChaosMonkeys for doing server restart actions, but not flush / compact / snapshot kind of
actions.
Creates ChaosMonkeys for doing server restart actions, but not flush / compact / snapshot kind of
actions.
Receives shell commands from the client and executes them blindly.
A custom byte buf allocator for TestNettyRpcServer.
Utility for running
SimpleKdcServer.A sample region observer that tests the RegionObserver interface.
A simplistic
ScanResultConsumer for use in tests.Tagging a test as 'small' means that the test class has the following characteristics:
it can be run simultaneously with other small tests all in the same JVM
ideally, the WHOLE implementing test-suite/class, no matter how many or how few test methods
it has, should take less than 15 seconds to complete
it does not use a cluster
Action that tries to take a snapshot of a table.
Utilities class for snapshots
Predicate that waits for all store files in a table to have no compacted files.
Abstraction to simplify the case where a test needs to verify a certain state on a
SpaceQuotaSnapshot.A SpaceQuotaSnapshotNotifier implementation for testing.
Helper methods for matching against instances of
SpanData.Action that tries to split a random region of a table.
Options for starting up a mini cluster (including an hbase, dfs and zookeeper clusters) in test.
Builder pattern for creating an
StartMiniClusterOption.This class is a helper that allows to create a partially-implemented, stateful mocks of Store.
A base implementation for a Stoppable service
A Rudimentary tool for visualizing a hierarchy of spans.
A perf test which does large data ingestion using stripe compactions and regular compactions.
Base class for performing Actions based on linux commands requiring sudo privileges
Returns a
TableName based on currently running test method name.Used in testcases only.
Base class for tc command actions
Performs authorization checks for common operations, according to different levels of authorized
users.
Performs checks for reference counting w.r.t.
Test the
ActiveMasterManager.Dummy Master Implementation.
Test class for
ActivePolicyEnforcement.Testcase for HBASE-20147.
Class to test HBaseAdmin.
Class to test HBaseAdmin.
Testcase to make sure that we always set scanner id in ScanResponse.
Tests for the master api_v1
ClusterMetricsResource.Run Append tests that use the HBase clients;
Base class for AM test.
UT for HBASE-25032.
Class to test AsyncAdmin.
Testcase for HBASE-22135.
Confirm that we will set the priority in
HBaseRpcController for several admin operations.Only used to test stopMaster/stopRegionServer/shutdown methods.
See HBASE-24513.
Provides AsyncFSWAL test cases.
Testcase for HBASE-22539
Testcase for HBASE-25905
Test covers when client is configured with
RpcConnectionRegistry.Test covers when client is configured with
ZKConnectionRegistry.Class to test asynchronous namespace admin operations.
Class to test asynchronous procedure admin operations.
Used to simulate the case where a RegionServer responds to a multi request, but some or all of
the actions have an Exception instead of Result.
Make the backoff time always different on each call.
Returns our async process.
Returns our async process.
After reading TheDailyWtf, I always wanted to create a MyBoolean enum like this!
The purpose of this test is to make sure the region exception won't corrupt the results of batch.
Class to test asynchronous region admin operations.
Class to test asynchronous region admin operations.
Class to test asynchronous replication admin operations.
Class to test asynchronous replication admin operations when more than 1 cluster
Class to test asynchronous table admin operations.
Class to test asynchronous table admin operations
Class to test asynchronous table admin operations.
Will split the table, and move region randomly when testing.
Fix an infinite loop in
AsyncNonMetaRegionLocator, see the comments on HBASE-21943 for
more details.Confirm that we will set the priority in
HBaseRpcController for several table operations.Test the admin operations for Balancer, Normalizer, CleanerChore, and CatalogJanitor.
Testing of HRegion.incrementColumnValue, HRegion.increment, and HRegion.append
A thread that makes increment calls always on the same row, this.row against two column
families on this row.
This class is only a base for other integration-level backup tests.
This class is only a base for other integration-level backup tests.
Create multiple backups for two tables: table1, table2 then perform 1 delete
Test cases for backup system table API
Test balancer with disabled table
Test BalancerDecision ring buffer using namedQueue interface
Test BalancerRejection ring buffer using namedQueue interface
Test of default BaseSource for hadoop 2
TestBasicWALEntryStream with
AsyncFSWALProvider as the WAL provider.TestBasicWALEntryStream with
FSHLogProvider as the WAL provider.This file has been copied from the Apache ZooKeeper project.
Tests for the bit comparator
Tests for the hdfs fix from HBASE-6435.
Tests for the hdfs fix from HBASE-6435.
Tests for the hdfs fix from HBASE-6435.
A UT to make sure that everything is fine when we fail to load bloom filter.
Make sure that we can update the bootstrap server from master to region server, and region server
could also contact each other to update the bootstrap nodes.
Basic test of BucketCache.Puts and gets.
A BucketCache that does not start its writer threads.
My BufferedMutator.
Just to create an instance, this doesn't actually function.
This class attempts to unit test bulk HLog loading.
Integration test for bulk load replication.
Basic test for
ByteBufferIOEngineA CacheableDeserializer implementation which just store reference to the
ByteBuff to be
deserialized.Override the
BucketEntry so that we can set an arbitrary offset.Tests that
CacheConfig does as expected.Tests
HFile cache-on-write functionality for the following block types: data blocks,
non-root index blocks, and Bloom filter blocks.Tests
HFile cache-on-write functionality for data blocks, non-root index blocks, and
Bloom filter blocks, as specified by the column family.Unit testing for CallQueue, a part of the org.apache.hadoop.hbase.thrift package.
Simple test for
HFileOutputFormat2.Simple mapper that makes KeyValue output.
Simple mapper that makes Put output.
Tests the table import and table export MR job functionality
This listens to the
TestCellBasedImportExport2.TableWALActionListener.visitLogEntryBeforeWrite(RegionInfo, WALKey, WALEdit) to identify
that an entry is written to the Write Ahead Log for the given table.Basic test for the WALPlayer M/R tool
Cell used in test.
CellScannable used in test.
CellScanner used in test.
Make sure we do not loss data after changing SFT implementation
Test changing store file tracker implementation by altering table.
Tests changing data block encoding settings of a column family.
An override of HRegion to allow sleep after get(), waiting for the release of DBB
This class is to test checksum behavior when data is corrupted.
Checks tests are categorized.
Lightweight ScheduledChore used primarily to fill the scheduling queue in tests
A Chore that will try to execute the initial chore a few times before succeeding.
Straight forward stopper implementation that is used by default when one is not provided
Sleeps for longer than the scheduled period.
In HBASE-26029, we reimplement the claim queue operation with proc-v2 and make it a step in SCP,
this is a UT to make sure the
ClaimReplicationQueuesProcedure works correctly.Make sure we will honor the
HConstants.META_REPLICAS_NUM.Test the ClusterStatus.
Test client behavior w/o setting up a cluster.
Fake 'server'.
Fake many regionservers and many regions on a connection implementation.
Comparator for meta row keys.
Override to shutdown going to zookeeper for cluster id and meta location.
Override to check we are setting rpc timeout right.
Override to check we are setting rpc timeout right.
Simple cluster registry inserted in place of our usual zookeeper based one.
These tests verify that the RPC timeouts ('hbase.client.operation.timeout' and
'hbase.client.scanner.timeout.period') work correctly using a modified Region Server which
injects delays to get, scan and mutate operations.
This
RSRpcServices class injects delay for Rpc calls and after executes super methods.Test the ClientScanner.
Blocking rpc channel that goes via hbase rpc.
Rpc Channel implementation with RandomTimeoutBlockingRpcChannel
Confirm that we will do backoff when retrying on closing a region, to avoid consuming all the
CPUs.
Tests the boot order indifference between regionserver and master
Test metrics incremented on region server operations.
Testcase for HBASE-21732.
Test for the ColumnPaginationFilter, used mainly to test the successful serialization of the
filter.
Test
CommonFSUtils.compacted memstore test case
compacted memstore test case
Test compaction framework and common functions
Simple
CompactionLifeCycleTracker on which you can wait until the requested compaction
finishes.Simple
CompactionLifeCycleTracker on which you can wait until the requested compaction
finishes.Tests a race condition between archiving of compacted files in CompactedHFilesDischarger chore
and HRegion.close();
Tests that archiving compacted files behaves correctly when encountering exceptions.
This class tests the scenario where a store refresh happens due to a file not found during scan,
after a compaction but before the compacted files are archived.
This testcase is used to ensure that the compaction marker will fail a compaction if the RS is
already dead.
Confirm that the function of CompactionLifeCycleTracker is OK as we do not use it in our own
code.
Unit tests to test retrieving table/region compaction state
Make sure compaction tests still pass with the preFlush and preCompact overridden to implement
the default behavior
Tests writing Bloom filter blocks in the same part of the file as data blocks.
Test our compressor class.
Basic test case that the ConfServlet can write configuration to its output in XML and JSON
format.
This class is for testing HBaseConnectionManager features
Do the complex testing of constraints against a minicluster
Constraint to check that it was actually run (or not)
Test reading/writing the constraints into the
HTableDescriptorAlso just works
Test TestCoprocessorClassLoader.
Tests for global coprocessor loading configuration
TestCoprocessorHost.CoprocessorHostForTest<E extends org.apache.hadoop.hbase.Coprocessor>
An
Abortable implementation for tests.Testing of coprocessor metrics end-to-end.
MasterObserver that has a Timer metric for create table operation.
RegionEndpoint to test metrics from endpoint calls
RegionObserver that has a Counter for preGet()
RegionServerObserver that has a Counter for rollWAL requests.
WALObserver that has a Counter for walEdits written.
Ensure Coprocessors get ShortCircuit Connections when they get a Connection from their
CoprocessorEnvironment.
Tests for master and regionserver coprocessor stop method
Performs coprocessor loads for various paths and malformed strings
Basic test for the CopyTable M/R tool
Test CoreCoprocessor Annotation works giving access to facility not usually available.
Annotate with CoreCoprocessor.
No annotation with CoreCoprocessor.
Test CoreCoprocessor Annotation works giving access to facility not usually available.
Annotate with CoreCoprocessor.
No annotation with CoreCoprocessor.
Test CoreCoprocessor Annotation works giving access to facility not usually available.
Annotate with CoreCoprocessor.
No annotation with CoreCoprocessor.
Test class for
CounterImpl.Test that we can create, load, setup our own custom codec
Test all of the data block encoding algorithms for correctness.
Test DataBlockEncodingTool.
Testcase for HBASE-23682.
Tests to make sure that the default environment edge conforms to appropriate behaviour.
memstore test case
Test
RSGroupInfoManager.determineRSGroupInfoForTable(TableName)Test class for
DisableTableViolationPolicyEnforcement.Test a drop timeout request.
Coprocessor that sleeps a while the first time you do a Get
Test class for
DropwizardMeter.Tests for DumpReplicationQueues tool
Tests for WAL write durability
Test TestDynamicClassLoader
Test enable RSGroup
Tests encoded seekers by loading and reading values.
Checks regions using MetaTableAccessor and HTable methods
Basic test for
ExclusiveMemoryMmapIOEngineTest Export Snapshot Tool
Tests that are adjunct to
TestExportSnapshot.Test Export Snapshot Tool helpers
Test Export Snapshot Tool Tests V1 snapshots only.
Test Export Snapshot Tool; tests v2 snapshots.
Testing sync/append failures.
Check if CompletedProcedureCleaner cleans up failed nonce procedures.
Testcase for HBASE-26679, here we introduce a separate test class and not put the testcase in
TestFanOutOneBlockAsyncDFSOutput because we will send heartbeat to DN when there is no
out going packet, the timeout is controlled by
TestFanOutOneBlockAsyncDFSOutput.READ_TIMEOUT_MS,which is 2 seconds, it will keep sending
package out and DN will respond immedately and then mess up the testing handler added by us.Testcases for FastLongHistogram.
Test class for
FileArchiverNotifierImpl.This file has been copied from the Apache ZooKeeper project.
Basic test for
FileIOEngineThis file has been copied from the Apache ZooKeeper project.
Test that FileLink switches between alternate locations when the current location moves or gets
deleted.
Test class for
FileSystemUtilizationChore.An Answer implementation which verifies the sum of the Region sizes to report is as expected.
Test filters at the HRegion doorstep.
The following filter simulates a pre-0.96 filter where filterRow() is defined while
hasFilterRow() returns false
Filter which makes sleeps for a second between each row of a scan.
To test behavior of filters at server from region side.
Tests filter Lists in ways that rely on a MiniCluster.
Test if Filter is incompatible with scan-limits
Test if the FilterWrapper retains the same semantics defined in the
FilterConfirm that the function of FlushLifeCycleTracker is OK as we do not use it in our own code.
Test creating/using/deleting snapshots from the client
Make sure we always cache important block types, such as index blocks, as long as we have a block
cache, even though block caching might be disabled for the column family.
Test that we propagate errors through an dispatcher exactly once via different failure injection
mechanisms.
Test that we correctly serialize exceptions from a remote source
Run tests that use the HBase clients;
Table.Run tests that use the HBase clients;
Table.Run tests that use the HBase clients;
Table.Do some ops and prove that client and server can work w/o codecs; that we can pb all the time.
Test all client operations with a coprocessor that just implements the default flush/compact/scan
policy.
Test all client operations with a coprocessor that just implements the default flush/compact/scan
policy.
Test all client operations with a coprocessor that just implements the default flush/compact/scan
policy.
Test all client operations with a coprocessor that just implements the default flush/compact/scan
policy.
Test cases that ensure that file system level errors are bubbled up appropriately to clients,
rather than swallowed.
Provides FSHLog test cases.
Testcase for HBASE-22539
Tests for
FSTableDescriptors.Test
FSUtils.Test
FSUtils.Test class for
Gauge.Gauge implementation with a setter.
TestGet is a medley of tests of get all done up as a single test.
Trivial test to confirm that we do not get 0 infoPort.
Trivial test to confirm that we can get last flushed sequence id by encodedRegionName.
Testcase for HBASE-19608.
Testcase for HBASE-21032, where use the wrong readType from a Scan instance which is actually a
get scan and cause returning only 1 cell per rpc call.
Testcase for HBASE-21032, where use the wrong readType from a Scan instance which is actually a
get scan and cause returning only 1 cell per rpc call.
A very simple filter that records accessed uri's
Configuration for RecordingFilter
Test HBASE-3694 whether the GlobalMemStoreSize is the same as the summary of all the online
region's MemStoreSize
Basic test for the HashTable M/R tool
Tests HBaseClassTestRule.
Test the comparator used by Hbck.
Test cases taken and adapted from Apache ZooKeeper Project
Tests
HBaseInterClusterReplicationEndpoint.filterNotExistColumnFamilyEdits(List) and
HBaseInterClusterReplicationEndpoint.filterNotExistTableEdits(List)Test being able to edit hbase:meta.
Test that an HBase cluster can run on top of an existing MiniDfsCluster
Test our testing utility class
Make sure we can spin up a HBTU without a hbase-site.xml
Test cases taken and adapted from Apache ZooKeeper Project.
Class to test HBaseHbck.
Tests for the
HbckMetricsResource.Test of the HBCK-version of SCP.
Encapsulates the choice of which HBCK2 method to call.
Selects a non-meta region that is also a primary region.
Encapsulates how the target region is selected.
Selects a non-meta region that is also a replica region.
Invokes
MasterRpcServices#scheduleSCPsForUnknownServers.Invokes
MasterRpcServices#scheduleServerCrashProcedure.Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0 together with
HColumnDescriptor.Verify that the HColumnDescriptor version is set correctly by default, hbase-site.xml, and user
input
Testing the sizing that HeapSize offers and compares to the size given by ClassSize.
Unit testing for HelloHBase.
Unit testing for HelloHBase.
test hfile features.
Test that the utility works as expected
Test that the
HFileArchiver correctly removes all the parts of a region when cleaning up
a regionThis test provides coverage for HFileHeader block fields that are read and interpreted before
HBase checksum validation can be applied.
Enables writing and rewriting portions of the file backing an
HFileBlock.Reads blocks off of an
TestHFileBlockHeaderCorruption.HFileBlockChannelPositionIterator, counting them as it does.Data class to enabled messing with the bytes behind an
HFileBlock.A simplified wrapper over an
HFileBlock.BlockIterator that looks a lot like an
Iterator.A Matcher implementation that can make basic assertions over a provided
Throwable.A wrapper around a block reader which only caches the results of the last operation.
Test a case when an inline index chunk is converted to a root one.
Test that FileLink switches between alternate locations when the current location moves or gets
deleted.
Test the HFileLink Cleaner.
Simple test for
HFileOutputFormat2.Simple mapper that makes KeyValue output.
Simple mapper that makes Put output.
Test
test the performance for seek.
Testing writing a version 3
HFile.Testing writing a version 3
HFile for all encoded blocksTest case for
HistogramImplTest for HQuorumPeer.
Basic stand-alone testing of HRegion.
TestCase for append
The same as HRegion class, the only difference is that instantiateHStore will create a
different HStore - HStoreForTesting.
HStoreForTesting is merely the same as HStore, the difference is in the doCompaction method of
HStoreForTesting there is a checkpoint "hbase.hstore.compaction.complete" which doesn't let
hstore compaction complete.
TestCase for increment
a mock fs which throws exception for first 3 times, and then process the call (returns the
excepted result).
Tests that need to spin up a cluster testing an
HRegion.Tests of HRegion methods for replaying flush, compaction, region open, etc events for secondary
region replicas
Tests bulk loading of HFiles and shows the atomicity or lack of atomicity of the region server's
bullkLoad functionality.
Thread that does full scans of the table looking for any partially completed rows.
Thread that does full scans of the table looking for any partially completed rows.
Tests bulk loading of HFiles with old non-secure client for backward compatibility.
A test similar to TestHRegion, but with in-memory flush families.
Test class for the HStore
Faulty file system that will fail if you write past its fault position the FIRST TIME only;
thereafter it will succeed.
Test HStoreFile
Deprecated.
As of release 2.0.0, this will be removed in HBase 3.0.0 together with
HTableDescriptor.FilterInitializer that initialized the DummyFilter.
Dummy filter that mimics as an authentication filter.
Custom user->group mapping service.
Test webapp loading
Testcase for HBASE-22632
Test ImmutableHRegionInfo
Small tests for ImmutableScan
Tests the table import and table export MR job functionality
This listens to the
TestImportExport.TableWALActionListener.visitLogEntryBeforeWrite(RegionInfo, WALKey, WALEdit) to identify
that an entry is written to the Write Ahead Log for the given table.Tests for
ImportTsv.TsvParser.Tests the inclusive stop row filter
Make sure we will honor the
HConstants.META_REPLICAS_NUM.And also test upgrading.1.
Test all
Increment client operations with a coprocessor that just implements the default
flush/compact/scan policy.Tests that the incrementing environment edge increments time instead of using the default.
Run Increment tests that use the HBase clients;
TableBuilder.This test runs batch mutation with Increments which have custom TimeRange.
Testing, info servers are disabled.
Testing info servers for admin acl.
Setup two clusters for replication.
Test scan/get offset and limit settings within one row through HRegion API.
Test the invocation logic of the filters.
Filter which gives the list of keyvalues for which the filter is invoked.
Test for the case where a regionserver going down has enough cycles to do damage to regions that
have actually been assigned elsehwere.
An override of HRegion that allows us park compactions in a holding pattern and then when
appropriate for the test, allow them proceed again.
An override of HRegion that allows us park compactions in a holding pattern and then when
appropriate for the test, allow them proceed again.
This tests whether ServerSocketChannel works over ipv6, which ZooKeeper depends on.
Test failure in ScanDeleteTracker.isDeleted when ROWCOL bloom filter is used during a scan with a
filter.
This file was forked from hadoop/common/branches/branch-2@1350012.
This file has been copied from the Apache ZooKeeper project.
Test case for JMX Connector Server.
Test performance improvement of joined scanners optimization:
https://issues.apache.org/jira/browse/HBASE-5416
Test
JSONBean.This should be in the hbase-logging module but the
HBaseClassTestRule is in hbase-common
so we can only put the class in hbase-common module for now...This file has been copied from the Apache ZooKeeper project.
A kind of integration test at the intersection of
HFileBlock, CacheConfig, and
LruBlockCache.With filter we may stop at a middle of row and think that we still have more cells for the
current row but actually all the remaining cells will be filtered out by the filter.
Uses the load tester
Test cases for the "load" half of the HFileOutputFormat bulk load functionality.
Test cases for LoadIncrementalHFiles when SFT is enabled.
Test cases for the atomic load error handling of the bulk load functionality.
Testcase for HBASE-21490.
A private master class similar to that used by HMasterCommandLine when running in local mode.
A private regionserver class with a dummy method for testing casts
This should be in the hbase-logging module but the
HBaseClassTestRule is in hbase-common
so we can only put the class in hbase-common module for now...Test LogLevel.
Tests for conditions that should trigger RegionServer aborts when rolling the current WAL fails.
Test many concurrent appenders to an WAL while rolling the log.
Appender thread.
ProtobufLogWriter that simulates higher latencies in sync() call
Tests the concurrent LruAdaptiveBlockCache.
Tests the concurrent LruBlockCache.
Tests LRUDictionary
Test major compactions
The purpose of this test is to ensure whether rs deals with the malformed cells correctly.
Define this class because the test needs to override
StochasticLoadBalancer.balanceTable(org.apache.hadoop.hbase.TableName, java.util.Map<org.apache.hadoop.hbase.ServerName, java.util.List<org.apache.hadoop.hbase.client.RegionInfo>>), which is protected.Tests to validate if HMaster default chores are scheduled
TestMasterChoreScheduled.TestChoreField<E extends org.apache.hadoop.hbase.ScheduledChore>
Reflect into the
HMaster instance and find by field name a specified instance of
ScheduledChore.Tests unhandled exceptions thrown by coprocessors running on master.
Tests unhandled exceptions thrown by coprocessors running on master.
Tests that the MasterRpcServices is correctly searching for implementations of the Coprocessor
Service and not just the "default" implementations of those services.
Test the master filesystem in a local cluster
Test the master filesystem in a local cluster with Store File Tracking explicitly set in global
config
Test the master filesystem in a local cluster
Make open region very slow
Standup the master and fake it to test various aspects of master function.
Tests invocation of the
MasterObserver interface
hooks at all appropriate times during normal HMaster operations.Tests class that validates that "post" observer hook methods are only invoked when the operation
was successful.
Test class for
MasterQuotasObserver.Test class for MasterQuotasObserver that does not require a cluster.
Use a coprocessor to count puts and deletes.
Tests for the master status page and its template.
Test transitions of state across the master.
Test case for the MemoryBoundedLogMessageBuffer utility.
Test the
ChunkCreator.MemStoreChunkPool classTest the
MemStoreCompactorSegmentsIterator and MemStoreMergerSegmentsIterator
class, Test for bug : HBASE-22324Cluster-backed correctness tests for the functionality provided by
MetaBrowser.Helper for mocking an
HttpServletRequest relevant to the test.Cluster-backed correctness tests for the functionality provided by
MetaBrowser.Throws CallQueueTooBigException for all gets.
Rotates through the possible cache clearing and non-cache clearing exceptions for requests.
Test small utility methods inside
MetaFixer.Tests RegionReplicaReplicationEndpoint class for hbase:meta by setting up region replicas and
verifying async wal replication replays the edits to the secondary region in various scenarios.
Tests handling of meta-carrying region server failover.
Test
MetaTableAccessor.Thread that runs a MetaTableAccessor task until asked stop.
Test MetaTableAccessor but without spinning up a cluster.
Test
MetaTableLocatorTest class for
MetricRegistries.Test class for
MetricRegistriesLoader.Unit test version of rs metrics tests.
Test for MetricsMasterProcSourceImpl
Test for the CompatibilitySingletonFactory and building MetricsMasterSource
Test for MetricsMasterSourceImpl
Unit test version of rs metrics tests.
Test for the CompatibilitySingletonFactory and building MetricsRegionServerSource
Test for the CompatibilitySingletonFactory and building MetricsReplicationSource
Test of Rest Metrics Source interface.
Test for hadoop 2's version of
MetricsRESTSource.Test for MetricsTableSourceImpl
Test for the interface of MetricsThriftServerSourceFactory
Test for hadoop 2's version of MetricsThriftServerSourceFactory.
Testcase for HBASE-26193.
Runs a load test on a mini HBase cluster with data block encoding turned on.
A write/read/verify load test on a mini HBase cluster.
A write/read/verify load test on a mini HBase cluster.
Test minor compactions
Test Minimum Versions feature (HBASE-4071).
Tests that table state is mirrored out to zookeeper for hbase-1.x clients.
This coprocessor is used to delay the flush.
Mob file compaction chore in a generational non-batch mode test.
Mob file compaction chore in a generational batch mode test.
Mob file compaction chore in a regular batch mode test.
Mob file compaction base test.
Test Export Snapshot Tool
Mob file cleaner chore test.
Test creating/using/deleting snapshots from the client
Test clone/restore snapshots from the client TODO This is essentially a clone of
TestRestoreSnapshotFromClient.
Test the restore/clone operation from a file-system point of view.
Reruns TestMobExportSnapshot using MobExportSnapshot in secure mode.
Test to verify that the cloned table is independent of the table from which it was cloned
Test create/using/deleting snapshots from the client
Test mob store compaction
Test the MOB feature when enable RPC ByteBuffAllocator (HBASE-22122)
Test whether moved region cache is correct
Tests optimized scanning of multiple columns.
Test case for Compression.Algorithm.GZ and no use data block encoding.
Test case for Compression.Algorithm.GZ and use data block encoding.
Test case for Compression.Algorithm.NONE and no use data block encoding.
Test case for Compression.Algorithm.NONE and no use data block encoding.
Tests logging of large batch commands via Multi.
Test secure client connecting to a non secure server, where we have multiple server principal
candidates for a rpc service.
Tests for HBASE-28321, where we have multiple server principals candidates for a rpc service.
Run tests related to
TimestampsFilter using HBase client
APIs.This test sets the multi size WAAAAAY low and then checks to make sure that gets will still make
progress.
Tests various scan start and stop row scenarios.
Tests of MultiTableInputFormatBase.
Connection to use above in Test.
Test Map/Reduce job over HBase tables.
Pass the given key and processed record reduce
This is a hammer test that verifies MultiVersionConcurrencyControl in a multiple writer single
reader scenario.
Very basic tests.
Port of old TestScanMultipleVersions, TestTimestamp and TestGetRowVersions from old testing
framework to
HBaseTestingUtility.Comprehensively tests all permutations of certificate and host verification on the client side.
Comprehensively tests all permutations of ClientAuth modes and host verification
enabled/disabled.
Tests for Online SlowLog Provider Service
Test class for
NamespaceQuotaSnapshotStore.Testcase for HBASE-23098
Test that verifies we do not have memstore size negative when a postPut/Delete hook is
slow/expensive and a flush is triggered at the same time the coprocessow is doing its work.
Confirm that we truly close the NettyRpcConnection when the netty channel is closed.
Simple helper class that just keeps track of whether or not its stopped.
Test class for
NoInsertsViolationPolicyEnforcement.Test class for
NoWritesCompactionsViolationPolicyEnforcement;Test class for
NoWritesViolationPolicyEnforcement.Test class for
HRegion.ObservedExceptionsInBatch.Tests for OldWALsDirSizeChore Here we are using the
MockMasterServices to mock the Hbase
Master.Testcase for HBASE-23079.
See HBASE-22060 and HBASE-22074 for more details.
Testcase for HBASE-20242
Test that a coprocessor can open a connection and write to another table, inside a hook.
Coprocessor that creates an HTable with a pool to write to another table
Custom coprocessor that just copies the write to another table.
Run tests that use the functionality of the Operation superclass for Puts, Gets, Deletes, Scans,
and MultiPuts.
Used to confirm that it is OK to overwrite a file which is being written currently.
Tests for the page filter
Testing of multiPut in parallel.
A thread that makes a few put calls
This class tests ParseFilter.java It tests the entire work flow from when a string is given by
the user and how it is parsed to construct the corresponding Filter object
In this test, we write a small WAL file first, and then generate partial WAL file which length is
in range [0, fileLength)(we test all the possible length in the range), to see if we can
successfully get the completed entries, and also get an EOF at the end.
These tests are focused on testing how partial results appear to a client.
A very simple filter that records accessed uri's
Configuration for RecordingFilter
This file has been copied from the Apache ZooKeeper project.
This test verifies the correctness of the Per Column Family flushing strategy
This file has been copied from the Apache ZooKeeper project.
Implementation of the PluggableBlockingQueue abstract class.
Test coprocessor methods
RegionObserver.postIncrementBeforeWAL(ObserverContext, Mutation, List) and
RegionObserver.postAppendBeforeWAL(ObserverContext, Mutation, List).Tests that verify certain RPCs get a higher QoS.
Demonstrate how Procedure handles single members, multiple members, and errors semantics
Test Procedure coordinator operation.
This Event+Procedure exhibits following behavior:
On procedure execute()
If had enough timeouts, abort the procedure.
Test the procedure member, and it's error handling mechanisms.
Test to ensure that the priority for procedures and stuck checker can partially solve the problem
describe in HBASE-19976, that is, RecoverMetaProcedure can finally be executed within a certain
period of time.
For now we do not guarantee this, we will restore the locks when restarting ProcedureExecutor so
we should use lock to obtain the correct order.
Testcase for HBASE-20973
A do-nothing basic procedure just for testing toString.
A do-nothing environment for BasicProcedure.
A do-nothing basic procedure that overrides the toStringState method.
Do-nothing SimpleMachineProcedure for checking its toString.
Test of master ProcedureV2 tracing.
Test prometheus Sink.
Example metric pojo.
Test for testing protocol buffer based RPC mechanism.
Test class for SPNEGO Proxyuser authentication on the HttpServer.
Test that I can Iterate Client Actions that hold Cells (Get does not have Cells).
Basic test that qos function is sort of working; i.e.
Test qualifierFilter with empty qualifier column
minicluster tests that validate that quota entries are properly set in the quota table
Non-HBase cluster unit tests for
QuotaObserverChore.A test case to verify that region reports are expired when they are not sent.
Test class for
QuotaObserverChore that uses a live HBase cluster.Test class for
QuotaSettingsFactory.Test class for the quota status RPCs in the master and regionserver.
Test the quota table helpers (e.g.
Testcase for HBASE-21503.
Testcase for HBASE-23636.
Testcase for HBASE-23594.
Testcase for HBASE-20624.
Verify the behaviour of the Rate Limiter.
With filter we may stop at a middle of row and think that we still have more cells for the
current row but actually all the remaining cells will be filtered out by the filter.
Tests around replay of recovered.edits content.
HBASE-21031 If replay edits fails, we need to make sure memstore is rollbacked And if MSLAB is
used, all chunk is released too.
Test our recoverLease loop against mocked up filesystem.
Version of DFS that has HDFS-4525 in it.
Basic test for check file's integrity before start BucketCache in fileIOEngine
Test reuse storefiles within data directory when cluster failover with a set of new region
servers with different hostnames with or without WALs and Zookeeper ZNodes, the master and
cluster should fail respectively if there is any situation considered as not supported.
This UT is used to make sure that we will not accidentally change the way to generate online
servers.
Testcase for HBASE-24871.
Tests bypass on a region assign/unassign
An AssignProcedure that Stalls just before the finish.
Tests the ability to specify favored nodes for a region.
Increments with some concurrency against a region to ensure we get the right answer.
Increments a random row's Cell
count times.Increments a single cell a bunch of times.
Test move fails when table disabled
Testcase for HBASE-20792.
Tests for Region Mover Load/Unload functionality with and without ack mode and also to test
exclude functionality useful for rack decommissioning
Tests for Region Mover Load/Unload functionality with and without ack mode and also to test
exclude functionality useful for rack decommissioning
Test that configuration changes are propagated to all children.
A test over
RegionNormalizerWorker.Tests that
RegionNormalizerWorkQueue implements the contract described in its docstring.Calls through to TestCoprocessor.
Calls through to TestCoprocessor.
Test that we fail if a Coprocessor tries to return a null scanner out
RegionObserver.preFlush(ObserverContext, Store, InternalScanner, FlushLifeCycleTracker)
or
RegionObserver.preCompact(ObserverContext, Store, InternalScanner, ScanType, CompactionLifeCycleTracker, CompactionRequest)Coprocessor that returns null when preCompact or preFlush is called.
Do the default logic in
RegionObserver interface.Don't allow any data to be written out in the compaction by creating a custom
StoreScanner.Don't allow any data in a flush by creating a custom
StoreScanner.Don't return any data from a scan by creating a custom
StoreScanner.Test whether region re-balancing works.
Tests failover of secondary region replicas.
Tests RegionReplicaReplicationEndpoint class by setting up region replicas and verifying async
wal replication replays the edits to the secondary region in various scenarios.
Tests RegionReplicaReplicationEndpoint.
Tests for region replicas.
Tests around regionserver shutdown and abort
Throws an exception during store file refresh in order to trigger a regionserver abort.
Tests unhandled exceptions thrown by coprocessors running on a regionserver..
Tests unhandled exceptions thrown by coprocessors running on regionserver.
Testcase for HBASE-20742
Tests for the hostname specification by region server
Tests on the region server, without the master.
Verify that the Online config Changes on the HRegionServer side are actually happening.
Test class for isolated (non-cluster) tests surrounding the report of Region space use to the
Master by RegionServers.
This test HMaster class will always throw ServerNotRunningYetException if checked.
Test class for
RegionServerSpaceQuotaManager.Test class which verifies that region sizes are reported to the master.
Testing the region snapshot task on a cluster.
Test options for regions on master; none, system, or any (i.e.
This is range uses a user specified start and end keys.
Tests for
RegionSplitter, which can create a pre-split table or do a rolling split of an
existing table.Test for RegionsRecoveryChore
Simple helper class that just keeps track of whether or not its stopped.
Test for Regions Recovery Config Manager
Tests
RemoteAdmin retries.Test RemoteHTable retries.
Make sure the
Thread.UncaughtExceptionHandler will be called when there are unchecked exceptions
thrown in the task.Testcase for HBASE-20296.
Confirm that we will do backoff when retrying on reopening table regions, to avoid consuming all
the CPUs.
Confirm that we will rate limit reopen batches when reopening all table regions.
Confirm that we will batch region reopens when reopening all table regions.
Testcase for HBASE-21330.
Tests for region replicas.
This copro is used to synchronize the tests.
Unit testing of ReplicationAdmin
Unit testing of ReplicationAdmin with clusters
This class is only a base for other integration-level replication tests.
Custom replication endpoint to keep track of replication status for tests.
Test handling of changes to the number of a peer's regionservers.
Tests ReplicationSource and ReplicationEndpoint interactions
Not used by unit tests, helpful for manual testing with replication.
Runs the TestReplicationKillRS test and selects the RS to kill in the master cluster Do not add
other tests in this class.
Run the same test as TestReplicationKillMasterRS but with WAL compression enabled Do not add
other tests in this class.
Runs the TestReplicationKillRS test and selects the RS to kill in the slave cluster Do not add
other tests in this class.
This test creates 2 mini hbase cluster.
All the modification method will fail once in the test and should finally succeed.
Manage the 'getRegionServers' for the tests below.
Bad Endpoint with failing connection to peer on demand.
Deadend Endpoint.
Deadend Endpoint.
Regionserver implementation that adds a delay on the graceful shutdown.
An abstract class that tests ReplicationSourceManager.
Tests the ReplicationSourceManager with ReplicationQueueZkImpl's and
ReplicationQueuesClientZkImpl.
White box testing for replication state interfaces.
Replication with dropped table will stuck as the default REPLICATION_DROP_ON_DELETED_TABLE_KEY is
false.
Replication with dropped table will stuck as the default REPLICATION_DROP_ON_DELETED_TABLE_KEY is
false.
This copro is used to slow down the primary meta region scan a bit
This copro is used to simulate region server down exception for Get and Scan
This copro is used to synchronize the tests.
Validate requestsPerSecond metric.
Test
HFileScanner.reseekTo(org.apache.hadoop.hbase.Cell)Simulate the scenario described in HBASE-26245, where we clean the WAL directory and try to start
the cluster.
Test clone/restore snapshots from the client TODO This is essentially a clone of
TestRestoreSnapshotFromClient.
Test the restore/clone operation from a file-system point of view.
Basic test for some old functionality we don't seem to have used but that looks nice.
Test cases against ReversibleKeyValueScanner
Tests to verify master/ assignment manager functionality against rogue RS
SCP does not support rollback actually, here we just want to simulate that when there is a code
bug, SCP and its sub procedures will not hang there forever, and it will not mess up the
procedure store.
Tests the restarting of everything as done during rolling restarts.
Test requirement that root directory must be a URI
Basic test of
RoundRobinTableInputFormat; i.e.Private comparator copied from private JobSubmmiter Hadoop class...
Test the rowcounter map reduce job.
Test TestRowPrefixBloomFilter
Test case to check HRS throws
RowTooBigException when row
size exceeds configured limits.This class tests operations in MasterRpcServices which require ADMIN access.
A dummy RpcChannel implementation that intercepts the GetClusterId() RPC calls and injects
errors.
A silly test that does nothing but make sure an rpcscheduler factory makes what it says it is
going to make.
Tests to validate if HRegionServer default chores are scheduled
TestRSChoresScheduled.TestChoreField<E extends org.apache.hadoop.hbase.ScheduledChore>
Test RSGroupBasedLoadBalancer with SimpleLoadBalancer as internal balancer
Test RSGroupBasedLoadBalancer with StochasticLoadBalancer as internal balancer
Performs authorization checks for rsgroup operations, according to different levels of authorized
users.
Tests that a regionserver that dies after reporting for duty gets removed from list of online
regions.
A RegionServer that reports for duty and then immediately dies if it is the first to receive
the response to a reportForDuty.
Mob file cleaner chore test.
Test parts of
RSRpcServicesTests for the region server status page and its template.
Test of a long-lived scanner validating as we go.
Here we test to make sure that scans return the expected Results when the server is sending the
Client heartbeat messages.
Custom HRegion class that instantiates
RegionScanners with configurable sleep times
between fetches of row Results and/or column family cells.Custom HRegionServer instance that instantiates
TestScannerHeartbeatMessages.HeartbeatRPCServices in place of
RSRpcServices to allow us to toggle support for heartbeat messagesCustom KV Heap that can be configured to sleep/wait in between retrievals of column family
cells.
Custom RegionScanner that can be configured to sleep between retrievals of row Results and/or
column family cells
Custom reversed KV Heap that can be configured to sleep in between retrievals of column family
cells.
Custom ReversedRegionScanner that can be configured to sleep between retrievals of row Results
and/or column family cells
Custom RSRpcServices instance that allows heartbeat support to be toggled
Test the optimization that does not scan files where all key ranges are excluded.
Test the optimization that does not scan files where all timestamps are expired.
A client-side test, mostly testing scanners with various parameters.
Testcase for newly added feature in HBASE-17143, such as startRow and stopRow
inclusive/exclusive, limit for rows, etc.
Test various scanner timeout issues.
Tests a scanner on a corrupt hfile.
Test if Scan.setStartStopRowForPrefixScan works as intended.
Test a multi-column scanner when there is a Bloom filter false-positive.
Testcase to make sure that we do not close scanners if ScanRequest.numberOfRows is zero.
Testcase for HBASE-22365.
Tests for failedBulkLoad logic to make sure staged files are returned to their original location
if the bulkload have failed.
Reruns TestExportSnapshot using ExportSnapshot in secure mode.
Reruns TestLoadIncrementalHFiles using LoadIncrementalHFiles in secure mode.
Reruns TestSecureLoadIncrementalHFilesSplitRecovery using LoadIncrementalHFiles in secure mode.
Test class for SPNEGO authentication on the HttpServer.
Make sure that all rpc services for master and region server are properly configured in
SecurityInfo and HBasePolicyProvider.Test various seek optimizations for correctness and check if they are actually saving I/O
operations.
Test
HFileScanner.seekTo(Cell) and its variants.Testcase for HBASE-20066
Test HBase Writables serializations
This class is for testing HBaseConnectionManager ServerBusyException.
Testcase for HBASE-20634
Test that sundry operations internal to the region server are traced as expected.
Wait for the underlying cluster to come up -- defined by meta being available.
HBASE-19496 noticed that the RegionLoad/ServerLoad may be corrupted if rpc server reuses the
bytebuffer backed, so this test call the Admin#getLastMajorCompactionTimestamp() to invoke
HMaster to iterate all stored server/region loads.
Configuration for the filter
A very simple filter which record the uri filtered.
Configuration for the filter
Test for the
ShellExecEndpointCoprocessor.This test is there to dump the properties.
Test to confirm that we will not hang when stop a backup master which is trying to become the
active master.
See HBASE-19929 for more details.
Testcase to confirm that we will not hang when shutdown a cluster with no live region servers.
Test the load balancer that is created by default.
Tests logic of
SimpleRegionNormalizer.Testing
SimpleRegionNormalizer on minicluster.Test of simple partitioner.
Tests for
SingleColumnValueExcludeFilter.Tests the value filter
Tests for SlowLog System Table
Tests for SnapshotsCleanerChore
Simple helper class that just keeps track of whether or not its stopped.
Test to verify that the cloned table is independent of the table from which it was cloned
Test that the
SnapshotProtos.SnapshotDescription helper is helping correctly.This class tests that the use of a temporary snapshot directory supports snapshot functionality
while the temporary directory is on the same file system as the root directory
Test that we correctly reload the cache, filter directories, etc.
Test that we correctly reload the cache, filter directories, etc.
Test create/using/deleting snapshots from the client
Test the master-related aspects of a snapshot
Test that the snapshot hfile cleaner finds hfiles referenced in a snapshot
Test basic snapshot manager functionality
Test class to verify that metadata is consistent before and after a snapshot attempt.
Snapshot creation with master lock timeout test.
Test class for the
SnapshotQuotaObserverChore.Separated from
TestSnapshotScannerHDFSAclController.Validate if storefile length match both snapshop manifest and filesystem.
This class tests that the use of a temporary snapshot directory supports snapshot functionality
while the temporary directory is on a different file system than the root directory
Test Case for HBASE-21387
Test restore/clone snapshots with TTL from the client
Test class for
SpaceLimitSettings.End-to-end test class for filesystem space quotas.
Test class to exercise the inclusion of snapshots in space quotas
Test class for
SpaceQuotaRefresherChore.This copro is used to slow down opening of the replica regions.
The below tests are testing split region against a running cluster
Testcase for https://issues.apache.org/jira/browse/HBASE-13811
Test class for SPNEGO authentication on the HttpServer.
This testcase issues SSL certificates configures the HttpServer to serve HTTPS using the created
certficates and calls an echo servlet using the corresponding HTTPS URL.
Testcase for HBASE-28210, where we persist the procedure which has been inserted later to
RootProcedureState first and then crash, and then cause holes in stack ids when loading,
and finally fail the start up of master.Test HStoreFile
A StoreScanner for our CELL_GRID above.
This test tests whether parallel
StoreScanner.close() and
StoreScanner.updateReaders(List, List) works perfectly ensuring that there are no
references on the existing Storescanner readers.This class both tests and demonstrates how to construct compound rowkeys from a POJO.
A simple object to serialize.
A simple object to serialize.
A custom data type implementation specialized for
TestStruct.Pojo1.A custom data type implementation specialized for
TestStruct.Pojo2.Test class to verify that the HBase superuser can override quotas.
Basic test for the SyncTable M/R tool
Test setting values in the descriptor.
Verify that the HTableDescriptor is updated after addColumn(), deleteColumn() and modifyTable()
operations.
This tests the TableInputFormat and its recovery semantics
This tests the TableInputFormat and its recovery semantics
Connection class to use in
TestTableInputFormatBase.testNonSuccessiveSplitsAreNotMerged().Subclass of
TableInputFormat to use in TestTableInputFormatBase.testNonSuccessiveSplitsAreNotMerged().Tests various scan start and stop row scenarios.
Pass the key and value to reduce.
Checks the last and first key seen against the scanner boundaries.
Test Map/Reduce job over HBase tables.
Test Map/Reduce job over HBase tables.
Pass the given key and processed record reduce
Pass the given key and processed record reduce
A base class for a test Map/Reduce job over HBase tables.
Test different variants of initTableMapperJob method
Tests for various kinds of TableNames.
Spark creates many instances of TableOutputFormat within a single process.
Test the reading and writing of access permissions on
_acl_ table.Test class for
TableQuotaSnapshotStore.Test that correct rpc priority is sent to server from blocking Table calls.
The Class ClientSideCellSetModel which mimics cell set model, and contains listener to perform
user defined operations on the row model.
This listener is invoked every time a new row model is unmarshalled.
Test case for
TableSpaceQuotaSnapshotNotifier.Quick hack to verify a Mutation with one column.
Tests the default table lock manager
Non-HBase cluster unit tests for
QuotaObserverChore.TablesWithQuotas.Class that test tags
Unfortunately, couldn't test TakeSnapshotHandler using mocks, because it relies on TableLock,
which is tightly coupled to LockManager and LockProcedure classes, which are both final and
prevents us from mocking its behaviour.
Unit testing for ThriftServer.HBaseServiceHandler, a part of the org.apache.hadoop.hbase.thrift2
package.
Start the HBase Thrift HTTP server on a random port through the command-line interface and talk
to it from client side.
Unit testing for ThriftServerRunner.HBaseServiceHandler, a part of the
org.apache.hadoop.hbase.thrift package.
Start the HBase Thrift server on a random port through the command-line interface and talk to it
from client side.
Start the HBase Thrift HTTP server on a random port through the command-line interface and talk
to it from client side with SPNEGO security enabled.
Start the HBase Thrift HTTP server on a random port through the command-line interface and talk
to it from client side with SPNEGO security enabled.
Test the
TimeoutExceptionInjector to ensure we fulfill contractsTest class for
TimerImplRun tests related to
TimestampsFilter using HBase client APIs.Tests the concurrent TinyLfuBlockCache.
A simple UT to make sure that we do not leak the SslExceptions to netty's TailContext, where it
will generate a confusing WARN message.
Tests for authentication token creation and usage
A copy of the BlockingRpcCallback class for use locally.
Basic server process for RPC authentication testing
An example
UnionBasic test for check file's integrity before start BucketCache in fileIOEngine
Confirm that the empty replication endpoint can work.
We moved some of
TestVerifyReplication's tests here because it could take too long to
complete.Base test class for visibility labels basic features
An extn of VisibilityReplicationEndpoint to verify the tags that are replicated
Testcase for HBASE-21811.
Test that the actions are called while playing with an WAL
Just counts when methods are called
This test verifies the correctness of the Per Column Family flushing strategy when part of the
memstores are compacted memstores
Ensure configuration changes are having an effect on WAL.
Simple test of sink-side wal entry filter facility.
A DevNull AsyncConnection whose only purpose is checking what edits made it through.
Simple filter that will filter out any entry wholse writeTime is <= 5.
Enable compression and reset the WALEntryStream while reading in ReplicationSourceWALReader.
Try out different combinations of row count and KeyValue count
WAL tests that can be reused across providers.
A custom WALCellCodec in which we can inject failure.
A proxy around FSDataInputStream which can report if close() was called.
Testing for lock up of FSHLog.
Simple testing of a few WAL methods.
Test for HBASE-17471.
Tests invocation of the
MasterObserver interface
hooks at all appropriate times during normal HMaster operations.Test WAL Init ERROR
Basic test for the WALPlayer M/R tool
JUnit tests for the WALRecordReader
Enables compression and runs the TestWALReplay tests.
Enables compression and runs the TestWALReplay tests.
Testing
WAL splitting code.Run tests that use the HBase clients;
TableBuilder.Testcase for HBASE-21843.
This file has been copied from the Apache ZooKeeper project.
Test class for
RemoteAdmin to verify XML is parsed in a certain manner.Test ZooKeeper multi-update functionality.
Test the reading and writing of access permissions to and from zookeeper.
Cluster-wide testing of a distributed three-phase commit using a 'real' zookeeper cluster
Test zookeeper-based, procedure controllers
Test the synchronization of token authentication master keys through ZKSecretWatcher
Test the refreshKeys in ZKSecretWatcher
Spin up a small cluster and check that the hfiles of region are properly long-term archived as
specified via the
ZKTableArchiveClient.Run ThriftServer with passed arguments.
JUnit run listener which prints full thread dump into System.err in case a test is failed due to
timeout.
Tests user specifiable time stamps putting, getting and scanning.
A drop-in replacement for
BufferingScanResultConsumer that adds tracing spans to its
implementation of the AdvancedScanResultConsumer API.A wrapper over
SimpleScanResultConsumer that adds tracing of spans to its implementation.Action that tries to truncate of a table.
Dummy mapper used for unit tests to verify that the mapper can be injected.
Just shows a simple example of how the attributes can be extracted and added to the puts
Chaos Monkey policy that will run two different actions at the same time.
This action is too specific to put in ChaosMonkey; put it here
Action that tries to unbalance the regions of a cluster.
Schema for HBase table to be generated by generated and populated by
BulkDataGeneratorToolTag a test as related to mapreduce and taking longer than 5 minutes to run on public build
infrastructure.
Tag a test as region tests which takes longer than 5 minutes to run on public build
infrastructure.
Tests visibility labels with deletes
Utility methods for testing visibility labels.
A class that provides a standard waitFor pattern See details at
https://issues.apache.org/jira/browse/HBASE-7384
A mixin interface, can be used with
Waiter to explain failed state.A predicate 'closure' used by the
Waiter.waitFor(Configuration, long, Predicate) and
Waiter.waitFor(Configuration, long, Predicate) and
Waiter.waitFor(Configuration, long, long, boolean, Predicate) methods.Testcase for HBASE-22539
WALDurabilityTestBase<T extends org.apache.hadoop.hbase.wal.WAL>
Tests for WAL write durability - hflush vs hsync
Base class for WALEntryStream tests.
Test helper that waits until a non-null entry is available in the stream next or times out.
This class runs performance benchmarks for
WAL.Reads
WARCRecords from a WARC file, using Hadoop's filesystem APIs.Writes
WARCRecords to a WARC file, using Hadoop's filesystem APIs.Hadoop InputFormat for mapreduce jobs ('new' API) that want to process data in WARC files.
Hadoop OutputFormat for mapreduce jobs ('new' API) that want to write data to WARC files.
Immutable implementation of a record in a WARC file.
Contains the parsed headers of a
WARCRecord.A mutable wrapper around a
WARCRecord implementing the Hadoop Writable interface.It just works
Constraint to check that the naming of constraints doesn't mess up the pattern matching.(that
constraint $___Constraint$NameConstraint isn't a problem)
Represents a type of key pair used for X509 certs in tests.
This class simplifies the creation of certificates and private keys for SSL/TLS connections.
Builder class, used for creating new instances of X509TestContext.
Will cache X509TestContext to speed up tests.
This class contains helper methods for creating X509 certificates and key pairs, and for
serializing them to JKS, PEM or other keystore type files.
For tests which test the general logic of zookeeper related tools, such as
RecoverableZooKeeper, not for tests which depend on ZooKeeper.