All Classes and Interfaces
Class
Description
Base implementation for database operation that are executed in batch.
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.
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()
This class provides a skeletal implementation of the
ITableFilter
interface to minimize the effort required to implement a filter.This exception is thrown by
IDataSet when multiple tables
having the same name are accessible.Provides static methods for the most common DbUnit assertion needs.
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.Inserts and reads
BigInteger values into/from a database.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.Hold copy of another dataset or a consumed provider content.
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.
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.
Use one of two
ValueComparers based on a value present or not in a
set of values.This class constructs an IDataSet given a directory containing 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.Configuration used by the
DatabaseConnection.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).Container for the metadata for one database table.
Convenience class for writing JUnit tests with dbunit easily.
Defines a dbUnit data file loader supporting replacement objects and
substrings with
ReplacementDataSet.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.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.
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.
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.
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.This filter hides specified tables from the filtered dataset.
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.
Deprecated.
this class duplicates
ForeignKeyRelationshipEdge and should be removedProduces a DataSet from a flat DTD.
Reads and writes flat XML dataset document.
Builder for the creation of
FlatXmlDataSet instances.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.
Column filter that filters out generated columns.
Adapter to handle conversion between Postgresql
native Enum type and Strings.
Specialized factory that recognizes H2 data types.
Specialized factory that recognizes HSQLDB data types.
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).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.
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.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 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.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.
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.
Adapter that lets dbunit create JUnit failure objects.
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.
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
Specialized factory that recognizes MS SQL Server data types.
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.Thrown to indicate that a database column has been accessed that does not
exist.
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.Specialized factory that recognizes Oracle data types for Oracle 10 and higher.
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.
TODO UnitTests are completely missing
Associates a table name with an arbitrary object.
Specialized factory that recognizes Postgresql data types.
Test case supporting prep data and expected data.
Test steps definition; helpful for Java lambdas.
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.
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.
Base class for exceptions during the search.
Base class for counting semaphores.
Abstract class for channels that use Semaphores to
control puts and takes.
This filter expose a specified table sequence and can be used to reorder
tables in a dataset.
Dbunit's own small assertion utility, independent from the testing framework
that is used.
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.
Parser which parses Oracle SQLLoader files.
Producer that creates an
IDataSet using SQLLoader style '.ctl' files.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).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.
Truncate tables present in the specified dataset.
UniqueIdentifierType provides support for the "uniqueidentifier" column in Microsoft SQLServer
databases.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.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.
Parses an XML and produces a dataset from it.
Makes writing XML much much easier.
Reads and writes flat YAML-based dataset documents.