All Classes and Interfaces
Class
Description
Base implementation for database operation that are executed in batch.
Abstract base
IBatchStatement implementation.Base implementation of
IDatabaseConnection that lazily creates and caches the
connection's whole-database IDataSet and owns its DatabaseConfig.Basic implementation of IDatabaseTester.
Implementations of IDatabaseTester may use this class as a starting point.
Implementations of IDatabaseTester may use this class as a starting point.
Base class with common implementation for dbUnit data file loaders.
This abstract class provides the basic implementation of the IDataSet
interface.
Abstract data type implementation that provides generic methods that are
appropriate for most data type implementations.
Search callback that excludes a fixed set of denied nodes from traversal.
Search callback that restricts traversal to a fixed set of allowed nodes.
Super-class for the ISearchCallback that implements the
getEdges() method using the database meta-data.Super-class for ISearchCallback implementations that needs to filter which
nodes should be included or excluded from the search.
This class implements the
This class implements the
searchNode() based on its internal
mode, which could be ALLOW_MODE, DENY_MODE or
NO_MODE:
NO_MODE is the default mode and means searchNode()
always return true
ALLOW_MODE is set when setAllowedNodes() is called
and it means searchNode() will return true only if the node is
contained on the Set (or array) passed to setAllowedNodes()
DENY_MODE is set when setDeniedNodes() is called
and it means searchNode() will return true only if the node is
not contained on the Set (or array) passed to setDeniedNodes()
Abstract base
DatabaseOperation implementation providing shared
row-iteration and column-filtering behavior.Abstract base
PipelineComponent implementation shared by the CSV
field-parsing handlers.Helper that forwards the character to its handler's
AbstractPipelineComponent.accept(char) method.Helper that silently discards the character it is given.
Abstract base
IPreparedBatchStatement implementation.Abstract base
IStatementFactory implementation.Abstract base implementation of a
DbUnitTaskStep executed by the DbUnit Ant task.Abstract base implementation of
ITable, providing common column-lookup
and value-formatting behavior for concrete table implementations.This class provides a skeletal implementation of the
ITableFilter
interface to minimize the effort required to implement a filter.Abstract base implementation of
ITableMetaData.PipelineComponent that matches any character, used as the basis for
catch-all accept/ignore handlers.This exception is thrown by
IDataSet when multiple tables
having the same name are accessible.Adapter to handle conversion between PostgreSQL array columns
(
Types.ARRAY, e.g.Provides static methods for the most common DbUnit assertion needs.
Decorator around an
IPreparedBatchStatement that automatically executes
the accumulated batch once a configured row-count threshold is reached.
I am placing this code in the Public Domain.
A
Base64.InputStream will read data from another
InputStream, given in the constructor,
and encode/decode to/from Base64 notation on the fly.A
Base64.OutputStream will write data to another
OutputStream, given in the constructor,
and encode/decode to/from Base64 notation on the fly.IBatchStatement that accumulates plain SQL statements using the JDBC
addBatch()/executeBatch() mechanism.Decorator that adapts a plain
IBatchStatement to the IPreparedBatchStatement
interface by substituting bound values directly into the SQL text instead of using JDBC
bind parameters.Inserts and reads
BigInteger values into/from a database.BytesDataType specialization that reads binary SQL column values as a stream.BooleanDataType specialization mapping the SQL BIT type.BytesDataType specialization mapping the SQL BLOB type to a byte[].Efficient array-based bounded buffer class.
A channel that is known to have a capacity, signifying
that
put operations may block when the
capacity is reached.A bounded variant of
LinkedQueue
class.
Implementation of
IDataSetConsumer which buffers all data
until the BufferedConsumer.endDataSet() event occurs.DataType mapping a binary SQL column type to a Java byte[].Hold copy of another dataset or a consumed provider content.
IResultSetTable that eagerly loads and caches an entire ResultSet in memory.IResultSetTableFactory that creates fully cached, disconnected IResultSetTable instances.ITable implementation that fully loads and caches another table's rows
and metadata in memory.Caches a single
IDatabaseConnection so that it - and the table
metadata it accumulates - can be reused across many test methods instead of
being rebuilt on every call.Deprecated.
All IDataSet implementations are case insensitive since DbUnit 1.5 - may change again since tablenames on RDBMSes can be case sensitive
Deprecated.
All IDataSet implementations are case insensitive since DbUnit 1.5
Main interface for buffers, queues, pipes, conduits, etc.
Adapter to handle conversion between Postgresql
native CITEXT type and Strings.
StringDataType that maps the SQL CLOB type, reading its character
content as a String.Decorates an operation and close the database connection after executing it.
Helper for collections-related methods.
Represents a table column.
Enumeration for valid auto-increment values provided by JDBC driver implementations.
Specifies nullable usage.
A table that filters some columns out from the original table.
This class exclusively provides static methods that operate on
Column objects.Describes the
Columns that are different in two tables.Convenience methods to help build the map of column name ->
ValueComparer.The
Compare class is the step that compare the content of the
database against the specified dataset.Combines multiple datasets into a single logical dataset.
This class is a composite that combines multiple database operation in a
single one.
ITable that pairs explicit ITableMetaData with row data drawn
from one or more other tables.IBatchStatement that accumulates multiple plain SQL statements and
executes them together.Use one of two
ValueComparers based on a value present or not in a
set of values.DataFileLoader that loads CSV dataset files.This class constructs an IDataSet given a directory containing CSV
files.
IDataSetConsumer that writes a dataset's tables and rows to CSV files.Parses a line of CSV text into its individual field values.
Signals an error while parsing CSV input.
IDataSetProducer that streams table and row events by parsing CSV files.This class constructs an IDataSet given a base URL containing CSV
files.
A
Data Set Producer that produces datasets from
CVS files found at a base URL.Signals that a set of tables has a foreign-key dependency cycle that cannot be
resolved into a linear ordering.
Configuration used by the
DatabaseConnection.Descriptor for a single named, typed, nullable
DatabaseConfig property.Sets parameters stored in the
DatabaseConfig on specific java objects like Statement.This class adapts a JDBC
Connection to a
IDatabaseConnection.Provides access to a database instance as a
IDataSet.This class adapts a JDBC
DataSource to a
IDatabaseConnection.Defines the interface contract for operations performed on the database.
This filter orders tables using dependency information provided by
DatabaseMetaData.getExportedKeys(java.lang.String, java.lang.String, java.lang.String).ITableIterator over the tables of a live database connection.Container for the metadata for one database table.
Convenience class for writing JUnit tests with dbunit easily.
Base checked exception for errors raised by the DbUnit framework.
Base unchecked exception for errors raised by the DbUnit framework.
Defines a dbUnit data file loader supporting replacement objects and
substrings with
ReplacementDataSet.Fluent builder for creating
IDataSet instances programmatically,
reducing XML file dependencies in unit tests.Thrown to indicate that a problem occurred with a dataset.
This class contains various methods for manipulating datasets.
TestCase that uses a DataSourceDatabaseTester.
DatabaseTester that uses a
DataSource to create connections.Data type that maps
Types objects to their java
counterparts.Base checked exception for errors related to
DataType value conversion.AbstractDataType mapping Microsoft SQL Server's DATETIMEOFFSET type.Database connection for DB2 that pre-configures all properties required to successfully
use dbunit with DB2.
Specialized factory that recognizes DB2 data types.
Customized MetadataHandler for DB2 as match Columns of
DefaultMetadataHandler
fails with a RuntimeException.Exception signaling a DbUnit assertion failure.
Exception signaling a DbUnit assertion failure while comparing values.
The database configuration for the ant task.
A named boolean feature flag, as configured in the Ant <dbconfig>
task's <feature> element.
Base testCase for database testing.
Subclasses may override
Default implementation uses a
Subclasses may override
DBTestCase.newDatabaseTester() to plug-in a different implementation
of IDatabaseTester.Default implementation uses a
PropertiesBasedJdbcDatabaseTester.Default implementation of DbUnit assertions, based on the original methods
present at
Assertion.Represents a single column to be used for the comparison of table data.
Base class for DbUnit assert classes containing common methods.
JUnit 5/6 extension for DbUnit that manages the
IDatabaseTester lifecycle
around each test method.DbUnitTask is the task definition for an Ant
interface to DbUnit.The
DbUnitTaskStep interface allows the execute method
to be called on all elements nested under DbUnitTask.DbUnit assertions using
ValueComparers for the column comparisons.A utility class to set the default capacity of
BoundedChannel
implementations that otherwise require a capacity argument
Implementation of the IColumnFilter interface that exposes columns matching
include patterns and not matching exclude patterns.
This class provides no op implementations for all of the callbacks in the
IDataSetConsumer interface.Default implementation of AbstractDatabaseTester, which does not know how
to get a connection by itself.
Simple implementation of a dataset backed by
ITable objects which can
be added dynamically.Generic factory that handle standard JDBC types.
Default implementation for
ExpectedDataSetAndVerifyTableDefinitionVerifier which logs the
mismatches and fails the test when an expected table does not have a
VerifyTableDefinition.Default implementation of the
FailureHandler.Default failure factory which returns DBUnits own assertion error
instances.
Default implementation of
IMetadataHandler which works for the most databases.Default implementation of the
IOperationListener.Test case base class supporting prep data and expected data.
Default table implementation backed by a simple java in-memory list.
This filter exposes only tables matching include patterns and not matching
exclude patterns.
ITableIterator over a fixed, in-memory array of ITables.Straightforward
ITableMetaData implementation holding an explicit table
name, column list, and primary keys.Default implementation for the
ValueComparerDefaults.Default implementation for
VerifyTableDefinitionVerifier which throws
IllegalStateException on configuration conflicts.Deletes all rows of tables present in the specified dataset.
Deletes only the dataset contents from the database.
Search using depth-first algorithm.
An instance of this class must be used only once, as it maintains the internal state of the search.
An instance of this class must be used only once, as it maintains the internal state of the search.
A
FailureHandler that collects the Differences that
were found without throwing an exception.Value object to hold the difference of a single data cell found while
comparing data.
Callback for
DbUnitAssert to notify about the
differences found during an assertion.Basic implementation of the
IEdge interface.Pipeline component that delegates to the first wrapped
PipelineComponent able to
handle a character, throwing IllegalInputCharacterException if none of them can.PipelineComponent that matches the CSV escape character.This filter hides specified tables from the filtered dataset.
Signals that a transaction could not be started because another transaction
is already active.
Interface for objects that execute Runnables,
as well as various objects that can be wrapped
as Runnables.
Strategy pattern for verifying
VerifyTableDefinitions and
expectedDataSet configurations agree, e.g. have the same number of tables
defined.The
Export class is the step that facilitates exporting
the contents of the database and/or it's corresponding DTD to a file.ISearchCallback implementation that get the nodes using direct foreign key
dependency, i.e, if table A has a FK for a table B, then getNodes(B) will
return A.
Factory to create exceptions for the testing framework to be used,
for example JUnit, TestNG or dbunit exceptions.
Handles the failure of an assertion.
Utility that provides some general methods for working with
File objects.Decorates a dataset and exposes only some tables from it.
ITableMetaData that exposes only the columns accepted by an IColumnFilter.Deprecated.
this class duplicates
ForeignKeyRelationshipEdge and should be removedIDataSet built by consuming table metadata declared
in a flat DTD document.Produces a DataSet from a flat DTD.
Writes a flat DTD document describing a dataset's tables and columns.
FlatDtdWriter.ContentModel that renders table names as a pipe-separated choice group.Abstract strategy for rendering a DTD element's content model (the part
between the parentheses in an <!
FlatDtdWriter.ContentModel that renders table names as a comma-separated,
ordered sequence.DataFileLoader that loads flat XML dataset files.Reads and writes flat XML dataset document.
Builder for the creation of
FlatXmlDataSet instances.IDataSetProducer that parses a flat XML dataset document via SAX and
streams table/row events.IDataSetConsumer that writes a dataset to the DbUnit flat XML dataset format.Implementation of an edge representing a foreign key (FK) relationship between two
tables.
The
The
from node is the table which have the FK, while the
to node is the table with the PK.Decorator that allows forward only access to decorated dataset.
IResultSetTable implementation backed by a forward-only, non-cached ResultSet.IResultSetTableFactory that creates forward-only, non-cached IResultSetTable instances.ITable decorator that wraps another table and enforces forward-only,
non-counted row access.DataFileLoader that loads full-format XML dataset files.Column filter that filters out generated columns.
Adapter to handle conversion between Postgresql
native Enum type and Strings.
Adapter to handle conversion between PostGIS
native geometry type and Strings.
DatabaseConnection specialization that configures H2-specific connection
behavior.Specialized factory that recognizes H2 data types.
Special metadata handler for H2.
Base contract for an object that decides whether and how to handle a single
character during CSV parsing.
Abstract helper that assists a
PipelineComponent in processing a character.DatabaseConnection specialization that configures HSQLDB-specific
connection behavior.Specialized factory that recognizes HSQLDB data types.
A JDBC statement wrapper that batches SQL statements for execution.
A filter for database columns.
This interface represents a connection to a specific database.
This interface defines the behavior of a DatabaseTester, which is responsible
for adding DBUnit features as composition on existing test cases (instead of
extending DBTestCase directly).
Represents a collection of tables.
Receive notification of the content of a dataset.
Interface for reading a dataset using callback.
A factory for creating
DataType.Reports what database products this object relates to.
A bidirectional edge on the graph to be searched.
It must implement
It must implement
Comparable so the
ISearchCallback can properly order the dependencies of a node
(so, typically, the implementations will compare the getTo()
node).Signals that an unexpected character was encountered while producing CSV output.
Signals that a character could not be handled by any component in the CSV
parsing pipeline.
Handler to specify the behavior for a lookup of column metadata using database metadata.
ISearchCallback implementation that get the nodes using both direct and reverse
foreign key dependency, i.e, if table C has a FK for a table A and table A has
a FK for a table B, then getNodes(A) will return B and C.
Extension of the ImportedAndExportedKeysSearchCallback, where each new edge is
added to a PrimaryKeyFilter.
ISearchCallback implementation that get the nodes using direct foreign key
dependency, i.e, if table A has a FK for a table B, then getNodes(A) will
return B.
Extension of the ImportedKeysSearchCallback, where each new edge is added to a
PrimaryKeyFilter.
This filter exposes only allowed tables from the filtered dataset.
Adapter to handle conversion between Postgresql
native inet type and Strings.
An in-memory
ResultSet, backed by rows copied out of one or more source result sets
ahead of time.Tests whether a source result set's current row, as positioned by a preceding
ResultSet.next(), should be kept.This class disable the MS SQL Server automatic identifier generation for
the execution of inserts.
Inserts the dataset contents into the database.
Adapter to handle conversion between Postgresql
native Interval type and Strings.
Listener for
IDatabaseConnection events.A batched, parameterized JDBC statement to which typed column values are bound
before execution.
An
ITable backed by a JDBC result set that must be closed after use.Factory that creates
IResultSetTable instances for a given query.Interface to filter out rows by checking specific column values provided by the
IRowValueProvider.Provides arbitrary values for one single database/ITable row.
ValueComparer implementation that verifies actual value contains
expected value by converting to Strings and using
String.contains(CharSequence).ValueComparer implementation that verifies the actual value is
semantically equal to the expected value by parsing both as JSON and
comparing the resulting document trees, instead of comparing their raw
text.ValueComparer implementation that verifies actual value is equal to
expected value.ValueComparer implementation that verifies actual value is equal to
expected value and sets fail message to empty String.ValueComparer implementation that verifies actual value is greater
than expected value.ValueComparer implementation that verifies actual Timestamp value is
greater than expected value, ignoring the milliseconds.ValueComparer implementation that verifies actual value is greater
than or equal to expected value.ValueComparer implementation that verifies actual Timestamp value is
greater than or equal to expected value, ignoring the milliseconds.ValueComparer implementation that verifies actual value is less than
expected value.ValueComparer implementation that verifies actual value is less than
or equal to expected value.ValueComparer implementation that verifies actual value is not equal
to expected value.ValueComparer implementation that verifies actual value is not null.ValueComparer implementation that verifies actual value is null.ValueComparer implementation for Timestamps that verifies
actual value is within a low and high milliseconds tolerance range of
expected value.PipelineComponent that matches alphanumeric characters.Helper that starts a quoted field, re-arranging the pipeline to accept characters
literally until the closing quote.
Helper that ends a quoted field, restoring the pipeline's pre-quote state.
Interface representing an algorithm that searches a graph.
Callback used by the search algorithms.
This interface is responsible for providing the edges of the graph and it can be notified of some events generated by the search.
This interface is responsible for providing the edges of the graph and it can be notified of some events generated by the search.
Factory that creates the JDBC statement wrapper used to execute a database operation.
A table represents a collection of tabular data.
Represents a strategy used by
FilteredDataSet to
exposes only some tables from a dataset.A filter for table names.
Represents table metadata.
TestCase that uses a JdbcDatabaseTester.
DatabaseTester that uses JDBC's Driver Manager to create connections.
TestCase that uses a JndiDatabaseTester.
DatabaseTester that pulls a DataSource from a JNDI location.
Reads and writes flat JSON-based dataset documents.
Produces a dataset by reading a JSON document.
Adapter to handle conversion between PostgreSQL native
json/
jsonb types and Strings.Adapter that lets dbunit create JUnit failure objects.
Placeholder class reserved for CSV line-ending handling.
A standard linked list node used in various queue classes
A linked list based channel implementation.
Specialized IDataSet decorator that convert the table name and
column names to lower case.
Specialized ITableMetaData implementation that convert the table name and
column names to lower case.
Specialized factory that recognizes MariaDB data types.
Database connection for Mckoi that pre-configures all properties required to successfully
use dbunit with Mckoi.
MckoiDataTypeFactory - This class is for the DBUnit data type factory for Mckoi database
DatabaseConnection specialization that configures Microsoft SQL Server-specific
connection behavior.Specialized factory that recognizes MS SQL Server data types.
A
MySqlMetadataHandler for connections not restricted to a single schema (MySQL
"catalog"), e.g. a connection made as MySQL's "root" specifically to work across several
schemas at once with DatabaseConfig.FEATURE_QUALIFIED_TABLE_NAMES
enabled.DatabaseConnection specialization that configures MySQL-specific
connection behavior.Specialized factory that recognizes MySql data types.
Special metadata handler for MySQL.
Was introduced to fix "[ 2545095 ] Mysql FEATURE_QUALIFIED_TABLE_NAMES column SQLHelper.matches".
Was introduced to fix "[ 2545095 ] Mysql FEATURE_QUALIFIED_TABLE_NAMES column SQLHelper.matches".
NetezzaDataTypeFactory - This class is for the DBUnit data type factory for Netezza database
Special metadata handler for Netezza.
ValueComparer implementation that verifies nothing and never fails;
NeverFailsValueComparer.isExpected(ITable, ITable, int, String, DataType, Object, Object)
always returns true.Sentinel
PipelineComponent placed at the end of a pipeline that rejects
any character not handled by an earlier component.Signals that a table has no primary key column where one is required.
Thrown to indicate that a database column has been accessed that does not
exist.
Signals that a dataset does not contain a table with the requested name.
DataType mapping numeric SQL column types to BigDecimal.Extended version of the
NumberDataType.The
Operation class is the step that defines which
operation will be performed in the execution of the DbUnitTask
task.Pairs a SQL statement with the columns whose values are bound as its parameters.
Specialized factory that recognizes Oracle data types for Oracle 10 and higher.
BlobDataType specialization that works around Oracle JDBC driver
BLOB handling quirks.ClobDataType specialization that works around Oracle JDBC driver
CLOB handling quirks.DatabaseConnection specialization that configures Oracle-specific
connection behavior.Specialized factory that recognizes Oracle data types.
NCLOB handler
This class was generated by oracle jpub.
This class was generated by oracle jpub.
This class implements DataType for Oracle SDO_GEOMETRY type used in Oracle Spatial.
This class was generated by oracle jpub.
This class was generated by oracle jpub.
BlobDataType specialization mapping Oracle's XMLTYPE column type.Associates a table name with an arbitrary object.
Chain-of-responsibility pipeline of
PipelineComponents that parses
CSV field text one character at a time.Holds the configurable separator, quote, and escape characters used by a CSV
parsing
Pipeline.Signals an error while processing a character through the CSV parsing pipeline.
Specialized factory that recognizes Postgresql data types.
BytesDataType specialization for PostgreSQL's oid large object columns.Test case supporting prep data and expected data.
Test steps definition; helpful for Java lambdas.
IPreparedBatchStatement that accumulates bound rows using the JDBC
addBatch()/executeBatch() mechanism.IStatementFactory that creates SimplePreparedStatement instances.Filter a table given a map of the allowed rows based on primary key values.
It uses a depth-first algorithm (although not recursive - it might be refactored in the future) to define which rows are allowed, as well which rows are necessary (and hence allowed) because of dependencies with the allowed rows.
NOTE: multi-column primary keys are not supported at the moment.
It uses a depth-first algorithm (although not recursive - it might be refactored in the future) to define which rows are allowed, as well which rows are necessary (and hence allowed) because of dependencies with the allowed rows.
NOTE: multi-column primary keys are not supported at the moment.
Map that associates a table with a set of primary key objects.
This class is a wrapper for another table with the condition that only a subset
of the original table will be available - the subset is defined by the set of
primary keys that are allowed in the new table.
DatabaseTester that configures a DriverManager from environment properties.
This class defines a set of keys for system properties that need to be present in the environment before using it.
This class defines a set of keys for system properties that need to be present in the environment before using it.
This class is interoperable with java.beans.PropertyChangeSupport,
but relies on a streamlined copy-on-write scheme similar to
that used in CopyOnWriteArrayList.
This interface exists to enable stricter type checking
for channels.
Utility to parse a fully qualified table name into its components schema and table.
The
Query class is just a step placeholder for a table name
within an Export.Holds collection of tables resulting from database query.
This element is a container for Queries.
Iterator used to iterate over a list of tables using a specific query for retrieving
data for every table.
PipelineComponent that matches the CSV quote character.Helper that starts a quoted field, re-arranging the pipeline to accept characters
literally until the closing quote.
Helper that ends a quoted field, restoring the pipeline's pre-quote state.
This operation literally refreshes dataset contents into the database.
A parser for relative date time string.
The basic format is
The basic format is
[now{diff...}Decorator that replace configured values from the decorated dataset
with replacement values.
Decorator that replaces configured values from the decorated table
with replacement values.
ResultSet based ITableMetaData implementation.Filters table rows by using arbitrary column values of the table to check if a row should be filtered or not.
Signals that a requested row index is outside a table's valid range.
IResultSetTable implementation backed by a scrollable ResultSet cursor.Base class for exceptions during the search.
Base class for counting semaphores.
Abstract class for channels that use Semaphores to
control puts and takes.
PipelineComponent that matches the CSV field separator character.Helper that ends the current field, notifying the pipeline the piece is done.
This filter expose a specified table sequence and can be used to reorder
tables in a dataset.
ITableIterator that returns a dataset's tables in a caller-specified
name order.Dbunit's own small assertion utility, independent from the testing framework
that is used.
IPreparedBatchStatement that binds values to a single, reusable
PreparedStatement.IBatchStatement that executes plain (non-prepared) SQL statements.A one-slot buffer, using semaphores to control access.
Decorator that returns the
ITables of the decorated dataset
as SortedTables.This is a ITable decorator that provide a sorted view of the decorated table.
Abstract class for sorting the table rows of a given table in a specific
order
Compares the rows with each other in order to sort them in the correct
order using the data type and the Comparable implementation the current
column has.
Compares the rows with each other in order to sort them in the correct
order using the string value of both values for the comparison.
Helper for SQL-related stuff.
This class constructs an
IDataSet given a directory containing control
files.Interface of Parser which parses Oracle SQLLoader files.
Signals an error while parsing a SQL*Loader control (.ctl) file.
Parser which parses Oracle SQLLoader files.
Producer that creates an
IDataSet using SQLLoader style '.ctl' files.IStatementFactory that creates non-prepared SimpleStatement instances.Dataset that consumes producer asynchronously.
Asynchronous table iterator that uses a new Thread for asynchronous processing.
String data type that ignore case when comparing String values.
Main interface for locks, gates, and conditions.
A class useful for offloading synch for int instance variables.
Base class for simple, small classes
maintaining single values that are always accessed
and updated under synchronization.
A rendezvous channel, similar to those used in CSP and Ada.
Simple FIFO queue class to hold waiting puts/takes.
The
Table class is just a step placeholder for a table name
within an Export.Convenience methods to help build the map of table name -> map of column name
->
ValueComparer.Decorates a dataset to allow decorating the returned
ITables (and
ITableMetaDatas, by extension).A function that decorates a single
ITable.Simple formatter to print out
ITable objects in a beautiful way, for
example on a console.Helper for the graph-search based classes used to calculate dependency
among tables.
This interface exists to enable stricter type checking
for channels.
Data type that maps a SQL
Types.TIME object to a java object.Thrown by synchronization classes that report
timeouts via exceptions.
Base class for
ValueComparer implementations that verify Timestamps,
ignoring the milliseconds.Container that manages a map of
ToleratedDeltaMap.ToleratedDelta objects to be used for
numeric comparisons with an allowed deviation of two valuesContainer for the tolerated delta of two values that are compared to each
other.
Simple bean that holds the tolerance for floating point comparisons for a
specific database column.
Decorates an operation and executes within the context of a transaction.
PipelineComponent that accepts any character without altering the
field being assembled.Truncate tables present in the specified dataset.
Signals that a value could not be cast to the Java type required by a
DataType.UniqueIdentifierType provides support for the "uniqueidentifier" column in Microsoft SQLServer
databases.PipelineComponent that assembles an unquoted CSV field value from its
constituent characters.Helper that notifies the pipeline the current field is done.
Updates the database from the dataset contents.
A datatype that is capable of storing UUIDs into BINARY fields (big-endian).
Adapter to handle conversion between Postgresql
native UUID type and Strings.
Strategy for comparing values.
Base class for
ValueComparers providing a template method and common
elements, mainly consistent log message and toString.Default
ValueComparers, used when one is not specified by a test.Convenience set of common
ValueComparer instances.Strategy for selecting a
ValueComparer from a Map of them.Base class for
ValueComparers, providing template methods and common
elements.Create instances of a single or multi-column object, typically from the row
in the table.
Defines a database table to verify (assert on data), specifying include and
exclude column filters and optional
ValueComparers.Strategy pattern for verifying a correctly configured
VerifyTableDefinition, e.g. a ValueComparer does not exist
for a column with an excluded column definition.PipelineComponent that matches whitespace characters during CSV field parsing.DataFileLoader that loads Excel (.xls) dataset files.This dataset implementation can read and write MS Excel documents.
Writes an
IDataSet to an XLS file or OutputStream.Reads and writes original XML dataset document.
IDataSetConsumer that writes a dataset to the DbUnit XML dataset format.Parses an XML and produces a dataset from it.
Makes writing XML much much easier.
Reads and writes flat YAML-based dataset documents.
IDataSetProducer that parses a YAML dataset document and streams
table/row events.