net.ttddyy.dsproxy.asserts.hamcrest

Class DataSourceAssertMatchers

java.lang.Object

net.ttddyy.dsproxy.asserts.hamcrest.DataSourceAssertMatchers

public class DataSourceAssertMatchers
extends Object

Aggregated hamcrest matchers.

Since:

1.0

Author:

Tadaya Tsuyukubo

See Also:

ProxyTestDataSourceAssertions, QueryExecutionAssertions, QueryHolderAssertions, QueriesHolderAssertions, BatchParameterHolderAssertions, ParameterHolderAssertions, OutParameterHolderAssertions

Constructor Summary

Constructors

Constructor and Description
DataSourceAssertMatchers()

Method Summary

Modifier and Type	Method and Description
static org.hamcrest.Matcher<? super QueryExecution>	batch() Matcher to check QueryExecution was a batch execution.
static org.hamcrest.Matcher<? super BatchParameterHolder>	batch(int index, org.hamcrest.Matcher<? super ParameterHolder> parameterHolderMatcher) Matcher to check the given index in batch matches with given parameter matcher.
static org.hamcrest.Matcher<? super QueryExecution>	batchCallable() Matcher to check QueryExecution was a batch execution of CallableStatement.
static org.hamcrest.Matcher<ProxyTestDataSource>	batchCallableCount(int count) Matcher to check the number of CallableBatchExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<? super QueryExecution>	batchPrepared() Matcher to check QueryExecution was a batch execution of PreparedStatement.
static org.hamcrest.Matcher<ProxyTestDataSource>	batchPreparedCount(int count) Matcher to check the number of PreparedBatchExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<? super BatchParameterHolder>	batchSize(int batchSize) Matcher to check the batch size.
static org.hamcrest.Matcher<? super QueryExecution>	batchStatement() Matcher to check QueryExecution was a batch execution of Statement.
static org.hamcrest.Matcher<ProxyTestDataSource>	batchStatementCount(int count) Matcher to check the number of StatementBatchExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<? super QueryExecution>	callable() Matcher to check QueryExecution was an execution of CallableStatement.
static org.hamcrest.Matcher<ProxyTestDataSource>	callableCount(int count) Matcher to check the number of CallableExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<? super QueryExecution>	callableOrBatchCallable() Matcher to check QueryExecution was a normal or batch execution of CallableStatement.
static org.hamcrest.Matcher<ProxyTestDataSource>	callableOrBatchCallableCount(int count) Matcher to check the number of CallableExecution or CallableBatchExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<? super QueryHolder>	delete() Matcher to examine the query type is SELECT.
static org.hamcrest.Matcher<ProxyTestDataSource>	deleteCount(int count) Matcher to check the number of DELETE queries in QueryExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<ProxyTestDataSource>	executionCount(int count) Matcher to check the number of QueryExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<ProxyTestDataSource>	executions(int index, org.hamcrest.Matcher<? super QueryExecution> queryExecutionMatcher) Matcher for QueryExecution of given index.
static org.hamcrest.Matcher<QueryExecution>	failure() Matcher to check QueryExecution was failure.
static org.hamcrest.Matcher<? super QueryHolder>	insert() Matcher to examine the query type is SELECT.
static org.hamcrest.Matcher<ProxyTestDataSource>	insertCount(int count) Matcher to check the number of INSERT queries in QueryExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<? super QueryExecution>	isBatch() Matcher to check QueryExecution was a batch execution.
static org.hamcrest.Matcher<? super QueryExecution>	isBatchCallable() Matcher to check QueryExecution was a batch execution of CallableStatement.
static org.hamcrest.Matcher<? super QueryExecution>	isBatchPrepared() Matcher to check QueryExecution was a batch execution of PreparedStatement.
static org.hamcrest.Matcher<? super QueryExecution>	isBatchStatement() Matcher to check QueryExecution was a batch execution of Statement.
static org.hamcrest.Matcher<? super QueryExecution>	isCallable() Matcher to check QueryExecution was an execution of CallableStatement.
static org.hamcrest.Matcher<? super QueryExecution>	isCallableOrBatchCallable() Matcher to check QueryExecution was a normal or batch execution of CallableStatement.
static org.hamcrest.Matcher<? super QueryExecution>	isPrepared() Matcher to check QueryExecution was an execution of PreparedStatement.
static org.hamcrest.Matcher<? super QueryExecution>	isPreparedOrBatchPrepared() Matcher to check QueryExecution was a normal or batch execution of PreparedStatement.
static org.hamcrest.Matcher<? super QueryExecution>	isStatement() Matcher to check QueryExecution was an execution of Statement.
static org.hamcrest.Matcher<? super QueryExecution>	isStatementOrBatchStatement() Matcher to check QueryExecution was a normal or batch execution of Statement.
static org.hamcrest.Matcher<? super ParameterHolder>	nullParam(int index) Matcher to examine parameter by index is setNull operation.
static org.hamcrest.Matcher<? super ParameterHolder>	nullParam(int index, int sqlType) Matcher to examine parameter by index is setNull operation with given Types.
static org.hamcrest.Matcher<? super ParameterHolder>	nullParam(String name) Matcher to examine parameter by name is setNull operation.
static org.hamcrest.Matcher<? super ParameterHolder>	nullParam(String name, int sqlType) Matcher to examine parameter by name is setNull operation with given Types.
static org.hamcrest.Matcher<? super QueryHolder>	other() Matcher to examine the query type is SELECT.
static org.hamcrest.Matcher<ProxyTestDataSource>	otherCount(int count) Matcher to check the number of OTHER queries in QueryExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<? super ParameterHolder>	outParam(int index, int sqlType) Matcher to examine out-parameter by index and int sqlType.
static org.hamcrest.Matcher<? super ParameterHolder>	outParam(int index, SQLType sqlType) Matcher to examine out-parameter by index and SQLType.
static org.hamcrest.Matcher<? super ParameterHolder>	outParam(String paramName, int sqlType) Matcher to examine out-parameter by name and int sqlType.
static org.hamcrest.Matcher<? super ParameterHolder>	outParam(String paramName, SQLType sqlType) Matcher to examine out-parameter by name and SQLType.
static org.hamcrest.Matcher<? super ParameterHolder>	outParamIndexes(org.hamcrest.Matcher<? super Collection<Integer>> collectionMatcher) Matcher to examine out-parameter indexes as a Collection of Integer.
static org.hamcrest.Matcher<? super ParameterHolder>	outParamNames(org.hamcrest.Matcher<? super Collection<String>> collectionMatcher) Matcher to examine out-parameter names as a Collection of String.
static <T> org.hamcrest.Matcher<? super ParameterHolder>	param(int index, Class<T> clazz, org.hamcrest.Matcher<? super T> matcher) Matcher to examine parameter by index with given class type value.
static org.hamcrest.Matcher<? super ParameterHolder>	param(Integer index, org.hamcrest.Matcher<Object> matcher) Matcher to examine parameter by index.
static <T> org.hamcrest.Matcher<? super ParameterHolder>	param(String name, Class<T> clazz, org.hamcrest.Matcher<? super T> matcher) Matcher to examine parameter by name with given class type value.
static org.hamcrest.Matcher<? super ParameterHolder>	param(String name, org.hamcrest.Matcher<Object> matcher) Matcher to examine parameter by name.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsArray(Integer index, org.hamcrest.Matcher<? super Array> matcher) Matcher to examine parameter by index with value as Array.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsArray(String name, org.hamcrest.Matcher<? super Array> matcher) Matcher to examine parameter by name with value as Array.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsBigDecimal(Integer index, org.hamcrest.Matcher<? super BigDecimal> matcher) Matcher to examine parameter by index with value as BigDecimal.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsBigDecimal(String name, org.hamcrest.Matcher<? super BigDecimal> matcher) Matcher to examine parameter by name with value as BigDecimal.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsBoolean(Integer index, org.hamcrest.Matcher<? super Boolean> matcher) Matcher to examine parameter by index with value as Boolean.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsBoolean(String name, org.hamcrest.Matcher<? super Boolean> matcher) Matcher to examine parameter by name with value as Boolean.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsByte(Integer index, org.hamcrest.Matcher<? super Byte> matcher) Matcher to examine parameter by index with value as Byte.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsByte(String name, org.hamcrest.Matcher<? super Byte> matcher) Matcher to examine parameter by name with value as byte[].
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsBytes(Integer index, org.hamcrest.Matcher<? super byte[]> matcher) Matcher to examine parameter by index with value as byte[].
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsBytes(String name, org.hamcrest.Matcher<? super byte[]> matcher) Matcher to examine parameter by name with value as byte[].
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsDate(Integer index, org.hamcrest.Matcher<? super Date> matcher) Matcher to examine parameter by index with value as Date.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsDate(String name, org.hamcrest.Matcher<? super Date> matcher) Matcher to examine parameter by name with value as Time.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsDouble(Integer index, org.hamcrest.Matcher<? super Double> matcher) Matcher to examine parameter by index with value as Double.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsDouble(String name, org.hamcrest.Matcher<? super Double> matcher) Matcher to examine parameter by name with value as Double.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsFloat(Integer index, org.hamcrest.Matcher<? super Float> matcher) Matcher to examine parameter by index with value as Float.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsFloat(String name, org.hamcrest.Matcher<? super Float> matcher) Matcher to examine parameter by name with value as Float.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsInteger(Integer index, org.hamcrest.Matcher<? super Integer> matcher) Matcher to examine parameter by index with value as Integer.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsInteger(String name, org.hamcrest.Matcher<? super Integer> matcher) Matcher to examine parameter by name with value as Integer.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsLong(Integer index, org.hamcrest.Matcher<? super Long> matcher) Matcher to examine parameter by index with value as Long.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsLong(String name, org.hamcrest.Matcher<? super Long> matcher) Matcher to examine parameter by name with value as Long.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsShort(Integer index, org.hamcrest.Matcher<? super Short> matcher) Matcher to examine parameter by index with value as Short.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsShort(String name, org.hamcrest.Matcher<? super Short> matcher) Matcher to examine parameter by name with value as Short.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsString(Integer index, org.hamcrest.Matcher<? super String> matcher) Matcher to examine parameter by index with value as String.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsString(String name, org.hamcrest.Matcher<? super String> matcher) Matcher to examine parameter by name with value as String.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsTime(Integer index, org.hamcrest.Matcher<? super Time> matcher) Matcher to examine parameter by index with value as Time.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsTime(String name, org.hamcrest.Matcher<? super Time> matcher) Matcher to examine parameter by name with value as Time.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsTimestamp(Integer index, org.hamcrest.Matcher<? super Timestamp> matcher) Matcher to examine parameter by index with value as Timestamp.
static org.hamcrest.Matcher<? super ParameterHolder>	paramAsTimestamp(String name, org.hamcrest.Matcher<? super Timestamp> matcher) Matcher to examine parameter by name with value as Timestamp.
static org.hamcrest.Matcher<? super ParameterHolder>	paramIndexes(Integer... indexes) Matcher to examine parameter indexes.
static org.hamcrest.Matcher<? super ParameterHolder>	paramIndexes(org.hamcrest.Matcher<? super Collection<Integer>> collectionMatcher) Matcher to examine parameter indexes as a Collection of Integer.
static org.hamcrest.Matcher<? super ParameterHolder>	paramNames(org.hamcrest.Matcher<? super Collection<String>> collectionMatcher) Matcher to examine parameter names as a Collection of String.
static org.hamcrest.Matcher<? super ParameterHolder>	paramNames(String... names) Matcher to examine parameter names.
static org.hamcrest.Matcher<? super ParameterHolder>	paramsByIndex(org.hamcrest.Matcher<Map<? extends Integer,?>> mapMatcher) Matcher to examine parameters by index as a Map(key=Integer, value=Object).
static org.hamcrest.Matcher<? super ParameterHolder>	paramsByName(org.hamcrest.Matcher<Map<? extends String,?>> mapMatcher) Matcher to examine parameters by name as a Map(key=String, value=Object).
static org.hamcrest.Matcher<? super QueryExecution>	prepared() Matcher to check QueryExecution was an execution of PreparedStatement.
static org.hamcrest.Matcher<ProxyTestDataSource>	preparedCount(int count) Matcher to check the number of PreparedExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<? super QueryExecution>	preparedOrBatchPrepared() Matcher to check QueryExecution was a normal or batch execution of PreparedStatement.
static org.hamcrest.Matcher<ProxyTestDataSource>	preparedOrBatchPreparedCount(int count) Matcher to check the number of PreparedExecution or PreparedBatchExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<? super QueriesHolder>	queries(int index, org.hamcrest.Matcher<String> stringMatcher)
static org.hamcrest.Matcher<? super QueriesHolder>	queries(org.hamcrest.Matcher<? super Collection<String>> collectionMatcher)
static org.hamcrest.Matcher<? super QueryHolder>	query(org.hamcrest.Matcher<String> stringMatcher) Matcher to examine the query with given String matcher.
static org.hamcrest.Matcher<? super QueryHolder>	queryType(net.ttddyy.dsproxy.QueryType expectedType) Matcher to examine the query type.
static org.hamcrest.Matcher<? super QueriesHolder>	queryTypes(int index, org.hamcrest.Matcher<? super QueryHolder> queryHolderMatcher)
static org.hamcrest.Matcher<? super QueryHolder>	select() Matcher to examine the query type is SELECT.
static org.hamcrest.Matcher<ProxyTestDataSource>	selectCount(int count) Matcher to check the number of SELECT queries in QueryExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<? super QueryExecution>	statement() Matcher to check QueryExecution was an execution of Statement.
static org.hamcrest.Matcher<ProxyTestDataSource>	statementCount(int count) Matcher to check the number of StatementExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<? super QueryExecution>	statementOrBatchStatement() Matcher to check QueryExecution was a normal or batch execution of Statement.
static org.hamcrest.Matcher<ProxyTestDataSource>	statementOrBatchStatementCount(int count) Matcher to check the number of StatementExecution or StatementBatchExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<QueryExecution>	success() Matcher to check QueryExecution was successful.
static org.hamcrest.Matcher<ProxyTestDataSource>	totalQueryCount(int count) Matcher to check the number of queries in QueryExecution in ProxyTestDataSource.
static org.hamcrest.Matcher<? super QueryHolder>	update() Matcher to examine the query type is SELECT.
static org.hamcrest.Matcher<ProxyTestDataSource>	updateCount(int count) Matcher to check the number of UPDATE queries in QueryExecution in ProxyTestDataSource.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

DataSourceAssertMatchers

public DataSourceAssertMatchers()

Method Detail

executions

public static org.hamcrest.Matcher<ProxyTestDataSource> executions(int index,
                                                                   org.hamcrest.Matcher<? super QueryExecution> queryExecutionMatcher)

Matcher for QueryExecution of given index. Example:

 assertThat(ds, executions(0, statement()));
 assertThat(ds, executions(0, isPreparedOrBatchPrepared()));
 assertThat(ds, executions(0, is(success())));
 

Parameters:

index - index

queryExecutionMatcher - matcher for QueryExecution

Returns:

matcher for ProxyTestDataSource

executionCount

public static org.hamcrest.Matcher<ProxyTestDataSource> executionCount(int count)

Matcher to check the number of QueryExecution in ProxyTestDataSource. Example:

 assertThat(ds, executionCount(3)); 

Parameters:

count - expected count

Returns:

matcher for ProxyTestDataSource

statementCount

public static org.hamcrest.Matcher<ProxyTestDataSource> statementCount(int count)

Matcher to check the number of StatementExecution in ProxyTestDataSource. Example:

 assertThat(ds, statementCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

batchStatementCount

public static org.hamcrest.Matcher<ProxyTestDataSource> batchStatementCount(int count)

Matcher to check the number of StatementBatchExecution in ProxyTestDataSource. Example:

 assertThat(ds, batchStatementCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

statementOrBatchStatementCount

public static org.hamcrest.Matcher<ProxyTestDataSource> statementOrBatchStatementCount(int count)

Matcher to check the number of StatementExecution or StatementBatchExecution in ProxyTestDataSource. Example:

 assertThat(ds, statementOrBatchStatementCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

preparedCount

public static org.hamcrest.Matcher<ProxyTestDataSource> preparedCount(int count)

Matcher to check the number of PreparedExecution in ProxyTestDataSource. Example:

 assertThat(ds, preparedCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

batchPreparedCount

public static org.hamcrest.Matcher<ProxyTestDataSource> batchPreparedCount(int count)

Matcher to check the number of PreparedBatchExecution in ProxyTestDataSource. Example:

 assertThat(ds, batchPreparedCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

preparedOrBatchPreparedCount

public static org.hamcrest.Matcher<ProxyTestDataSource> preparedOrBatchPreparedCount(int count)

Matcher to check the number of PreparedExecution or PreparedBatchExecution in ProxyTestDataSource. Example:

 assertThat(ds, preparedOrBatchPreparedCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

callableCount

public static org.hamcrest.Matcher<ProxyTestDataSource> callableCount(int count)

Matcher to check the number of CallableExecution in ProxyTestDataSource. Example:

 assertThat(ds, callableCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

batchCallableCount

public static org.hamcrest.Matcher<ProxyTestDataSource> batchCallableCount(int count)

Matcher to check the number of CallableBatchExecution in ProxyTestDataSource. Example:

 assertThat(ds, batchCallableCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

callableOrBatchCallableCount

public static org.hamcrest.Matcher<ProxyTestDataSource> callableOrBatchCallableCount(int count)

Matcher to check the number of CallableExecution or CallableBatchExecution in ProxyTestDataSource. Example:

 assertThat(ds, callableOrBatchCallableCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

totalQueryCount

public static org.hamcrest.Matcher<ProxyTestDataSource> totalQueryCount(int count)

Matcher to check the number of queries in QueryExecution in ProxyTestDataSource. This matcher counts the number of queries whereas executionCount(int) counts the number of executions. The number of queries and executions may differ when there is a Batch execution of Statement. Single execution of Statement may contain multiple queries. Thus, executionCount(int) count it as one, but this matcher may report more than one queries. Example:

 assertThat(ds, totalQueryCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

See Also:

executionCount(int)

selectCount

public static org.hamcrest.Matcher<ProxyTestDataSource> selectCount(int count)

Matcher to check the number of SELECT queries in QueryExecution in ProxyTestDataSource. Example:

 assertThat(ds, selectCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

insertCount

public static org.hamcrest.Matcher<ProxyTestDataSource> insertCount(int count)

Matcher to check the number of INSERT queries in QueryExecution in ProxyTestDataSource. Example:

 assertThat(ds, insertCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

updateCount

public static org.hamcrest.Matcher<ProxyTestDataSource> updateCount(int count)

Matcher to check the number of UPDATE queries in QueryExecution in ProxyTestDataSource. Example:

 assertThat(ds, updateCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

deleteCount

public static org.hamcrest.Matcher<ProxyTestDataSource> deleteCount(int count)

Matcher to check the number of DELETE queries in QueryExecution in ProxyTestDataSource. Example:

 assertThat(ds, deleteCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

otherCount

public static org.hamcrest.Matcher<ProxyTestDataSource> otherCount(int count)

Matcher to check the number of OTHER queries in QueryExecution in ProxyTestDataSource. Example:

 assertThat(ds, otherCount(3)); 

Parameters:

count - count

Returns:

matcher for ProxyTestDataSource

success

public static org.hamcrest.Matcher<QueryExecution> success()

Matcher to check QueryExecution was successful. Example:

 assertThat(qe, success()); 

Returns:

matcher for QueryExecution

failure

public static org.hamcrest.Matcher<QueryExecution> failure()

Matcher to check QueryExecution was failure. Example:

 assertThat(qe, failure()); 

Returns:

matcher for QueryExecution

batch

public static org.hamcrest.Matcher<? super QueryExecution> batch()

Matcher to check QueryExecution was a batch execution. Example:

 assertThat(qe, batch()); 

Returns:

matcher for QueryExecution

statement

public static org.hamcrest.Matcher<? super QueryExecution> statement()

Matcher to check QueryExecution was an execution of Statement. Example:

 assertThat(qe, statement()); 

Returns:

matcher for QueryExecution

batchStatement

public static org.hamcrest.Matcher<? super QueryExecution> batchStatement()

Matcher to check QueryExecution was a batch execution of Statement. Example:

 assertThat(qe, batchStatement()); 

Returns:

matcher for QueryExecution

statementOrBatchStatement

public static org.hamcrest.Matcher<? super QueryExecution> statementOrBatchStatement()

Matcher to check QueryExecution was a normal or batch execution of Statement. Example:

 assertThat(qe, statementOrBatchStatement()); 

Returns:

matcher for QueryExecution

prepared

public static org.hamcrest.Matcher<? super QueryExecution> prepared()

Matcher to check QueryExecution was an execution of PreparedStatement. Example:

 assertThat(qe, prepared()); 

Returns:

matcher for QueryExecution

batchPrepared

public static org.hamcrest.Matcher<? super QueryExecution> batchPrepared()

Matcher to check QueryExecution was a batch execution of PreparedStatement. Example:

 assertThat(qe, batchPrepared()); 

Returns:

matcher for QueryExecution

preparedOrBatchPrepared

public static org.hamcrest.Matcher<? super QueryExecution> preparedOrBatchPrepared()

Matcher to check QueryExecution was a normal or batch execution of PreparedStatement. Example:

 assertThat(qe, preparedOrBatchPrepared()); 

Returns:

matcher for QueryExecution

callable

public static org.hamcrest.Matcher<? super QueryExecution> callable()

Matcher to check QueryExecution was an execution of CallableStatement. Example:

 assertThat(qe, callable()); 

Returns:

matcher for QueryExecution

batchCallable

public static org.hamcrest.Matcher<? super QueryExecution> batchCallable()

Matcher to check QueryExecution was a batch execution of CallableStatement. Example:

 assertThat(qe, batchCallable()); 

Returns:

matcher for QueryExecution

callableOrBatchCallable

public static org.hamcrest.Matcher<? super QueryExecution> callableOrBatchCallable()

Matcher to check QueryExecution was a normal or batch execution of CallableStatement. Example:

 assertThat(qe, callableOrBatchCallable()); 

Returns:

matcher for QueryExecution

isBatch

public static org.hamcrest.Matcher<? super QueryExecution> isBatch()

Matcher to check QueryExecution was a batch execution. Alias of batch() Example:

 assertThat(qe, isBatch()); 

Returns:

matcher for QueryExecution

isStatement

public static org.hamcrest.Matcher<? super QueryExecution> isStatement()

Matcher to check QueryExecution was an execution of Statement. Alias of statement() Example:

 assertThat(qe, isStatement()); 

Returns:

matcher for QueryExecution

isBatchStatement

public static org.hamcrest.Matcher<? super QueryExecution> isBatchStatement()

Matcher to check QueryExecution was a batch execution of Statement. Alias of batchStatement() Example:

 assertThat(qe, isBatchStatement()); 

Returns:

matcher for QueryExecution

isStatementOrBatchStatement

public static org.hamcrest.Matcher<? super QueryExecution> isStatementOrBatchStatement()

Matcher to check QueryExecution was a normal or batch execution of Statement. Alias of statementOrBatchStatement() Example:

 assertThat(qe, isStatementOrBatchStatement()); 

Returns:

matcher for QueryExecution

isPrepared

public static org.hamcrest.Matcher<? super QueryExecution> isPrepared()

Matcher to check QueryExecution was an execution of PreparedStatement. Alias of prepared() Example:

 assertThat(qe, isPrepared()); 

Returns:

matcher for QueryExecution

isBatchPrepared

public static org.hamcrest.Matcher<? super QueryExecution> isBatchPrepared()

Matcher to check QueryExecution was a batch execution of PreparedStatement. Alias of batchPrepared() Example:

 assertThat(qe, isBatchPrepared()); 

Returns:

matcher for QueryExecution

isPreparedOrBatchPrepared

public static org.hamcrest.Matcher<? super QueryExecution> isPreparedOrBatchPrepared()

Matcher to check QueryExecution was a normal or batch execution of PreparedStatement. Alias of preparedOrBatchPrepared() Example:

 assertThat(qe, isPreparedOrBatchPrepared()); 

Returns:

matcher for QueryExecution

isCallable

public static org.hamcrest.Matcher<? super QueryExecution> isCallable()

Matcher to check QueryExecution was an execution of CallableStatement. Alias of callable() Example:

 assertThat(qe, isCallable()); 

Returns:

matcher for QueryExecution

isBatchCallable

public static org.hamcrest.Matcher<? super QueryExecution> isBatchCallable()

Matcher to check QueryExecution was a batch execution of CallableStatement. Alias of batchCallable() Example:

 assertThat(qe, isBatchCallable()); 

Returns:

matcher for QueryExecution

isCallableOrBatchCallable

public static org.hamcrest.Matcher<? super QueryExecution> isCallableOrBatchCallable()

Matcher to check QueryExecution was a normal or batch execution of CallableStatement. Alias of callableOrBatchCallable() Example:

 assertThat(qe, isCallableOrBatchCallable()); 

Returns:

matcher for QueryExecution

query

public static org.hamcrest.Matcher<? super QueryHolder> query(org.hamcrest.Matcher<String> stringMatcher)

Matcher to examine the query with given String matcher. Example:

 assertThat(qe, query(startsWith("select"))); 

Parameters:

stringMatcher - matcher for String

Returns:

matcher for QueryHolder

queryType

public static org.hamcrest.Matcher<? super QueryHolder> queryType(net.ttddyy.dsproxy.QueryType expectedType)

Matcher to examine the query type. Example:

 assertThat(qe, queryType(SELECT)); 

Parameters:

expectedType - expected QueryType

Returns:

matcher for QueryHolder

select

public static org.hamcrest.Matcher<? super QueryHolder> select()

Matcher to examine the query type is SELECT. Example:

 assertThat(qe, select()); 

Returns:

matcher for QueryHolder

insert

public static org.hamcrest.Matcher<? super QueryHolder> insert()

Matcher to examine the query type is SELECT. Example:

 assertThat(qe, insert()); 

Returns:

matcher for QueryHolder

update

public static org.hamcrest.Matcher<? super QueryHolder> update()

Matcher to examine the query type is SELECT. Example:

 assertThat(qe, update()); 

Returns:

matcher for QueryHolder

delete

public static org.hamcrest.Matcher<? super QueryHolder> delete()

Matcher to examine the query type is SELECT. Example:

 assertThat(qe, delete()); 

Returns:

matcher for QueryHolder

other

public static org.hamcrest.Matcher<? super QueryHolder> other()

Matcher to examine the query type is SELECT. Example:

 assertThat(qe, other()); 

Returns:

matcher for QueryHolder

queries

public static org.hamcrest.Matcher<? super QueriesHolder> queries(int index,
                                                                  org.hamcrest.Matcher<String> stringMatcher)

queries

public static org.hamcrest.Matcher<? super QueriesHolder> queries(org.hamcrest.Matcher<? super Collection<String>> collectionMatcher)

queryTypes

public static org.hamcrest.Matcher<? super QueriesHolder> queryTypes(int index,
                                                                     org.hamcrest.Matcher<? super QueryHolder> queryHolderMatcher)

batchSize

public static org.hamcrest.Matcher<? super BatchParameterHolder> batchSize(int batchSize)

Matcher to check the batch size. Example:

 assertThat(ds.getBatchStatements(), batchSize(3)); 

Parameters:

batchSize - batch size

Returns:

matcher for BatchParameterHolder

batch

public static org.hamcrest.Matcher<? super BatchParameterHolder> batch(int index,
                                                                       org.hamcrest.Matcher<? super ParameterHolder> parameterHolderMatcher)

Matcher to check the given index in batch matches with given parameter matcher. Example:

 assertThat(ds.getBatchStatements(), batch(0, param(1, String.class, is("FOO")))); 

Parameters:

index - index

parameterHolderMatcher - matcher for ParameterHolder

Returns:

matcher for BatchParameterHolder

paramsByName

public static org.hamcrest.Matcher<? super ParameterHolder> paramsByName(org.hamcrest.Matcher<Map<? extends String,?>> mapMatcher)

Matcher to examine parameters by name as a Map(key=String, value=Object).

Example:

 assertThat(parameterByNameHolder, paramsByName(hasEntry("foo", (Object) "FOO"))); 

Parameters:

mapMatcher - a Map matcher

Returns:

matcher for ParameterHolder

paramsByIndex

public static org.hamcrest.Matcher<? super ParameterHolder> paramsByIndex(org.hamcrest.Matcher<Map<? extends Integer,?>> mapMatcher)

Matcher to examine parameters by index as a Map(key=Integer, value=Object).

Example:

 assertThat(parameterByIndexHolder, paramsByName(paramsByIndex(1, (Object) "FOO"))); 

Parameters:

mapMatcher - a Map matcher

Returns:

matcher for ParameterHolder

paramIndexes

public static org.hamcrest.Matcher<? super ParameterHolder> paramIndexes(org.hamcrest.Matcher<? super Collection<Integer>> collectionMatcher)

Matcher to examine parameter indexes as a Collection of Integer.

Example:

 assertThat(parameterByIndexHolder, paramIndexes(hasItem(1), hasItem(2))); 

Parameters:

collectionMatcher - a Collection matcher

Returns:

matcher for ParameterHolder

paramIndexes

public static org.hamcrest.Matcher<? super ParameterHolder> paramIndexes(Integer... indexes)

Matcher to examine parameter indexes.

Example:

 assertThat(parameterByIndexHolder, paramIndexes(1,2,3)); 

Parameters:

indexes - parameter indexes

Returns:

matcher for ParameterHolder

paramNames

public static org.hamcrest.Matcher<? super ParameterHolder> paramNames(org.hamcrest.Matcher<? super Collection<String>> collectionMatcher)

Matcher to examine parameter names as a Collection of String.

Example:

 assertThat(parameterByNameHolder, paramNames(hasItem("foo"), hasItem("bar"))); 

Parameters:

collectionMatcher - a Collection matcher

Returns:

matcher for ParameterHolder

paramNames

public static org.hamcrest.Matcher<? super ParameterHolder> paramNames(String... names)

Matcher to examine parameter names.

Example:

 assertThat(parameterByNameHolder, paramNames("foo","bar","baz")); 

Parameters:

names - parameter names

Returns:

matcher for ParameterHolder

param

public static org.hamcrest.Matcher<? super ParameterHolder> param(String name,
                                                                  org.hamcrest.Matcher<Object> matcher)

Matcher to examine parameter by name.

Example:

 assertThat(parameterByNameHolder, param("foo", is((Object) "FOO"))); 

Parameters:

name - parameter name

matcher - matcher

Returns:

matcher for ParameterHolder

param

public static org.hamcrest.Matcher<? super ParameterHolder> param(Integer index,
                                                                  org.hamcrest.Matcher<Object> matcher)

Matcher to examine parameter by index.

Example:

 assertThat(parameterByIndexHolder, param(1, is((Object) "FOO"))); 

Parameters:

index - parameter index

matcher - matcher

Returns:

matcher for ParameterHolder

param

public static <T> org.hamcrest.Matcher<? super ParameterHolder> param(String name,
                                                                      Class<T> clazz,
                                                                      org.hamcrest.Matcher<? super T> matcher)

Matcher to examine parameter by name with given class type value.

Example:

 assertThat(parameterByNameHolder, param("foo", String.class, is("FOO"))); 

Type Parameters:

T - parameter type

Parameters:

name - parameter name

clazz - value type

matcher - matcher for <T>

Returns:

matcher for ParameterHolder

param

public static <T> org.hamcrest.Matcher<? super ParameterHolder> param(int index,
                                                                      Class<T> clazz,
                                                                      org.hamcrest.Matcher<? super T> matcher)

Matcher to examine parameter by index with given class type value.

Example:

 assertThat(parameterByIndexHolder, param(1, String.class, is("FOO"))); 

Type Parameters:

T - parameter type

Parameters:

index - parameter index

clazz - value type

matcher - matcher for <T>

Returns:

matcher for ParameterHolder

paramAsString

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsString(Integer index,
                                                                          org.hamcrest.Matcher<? super String> matcher)

Matcher to examine parameter by index with value as String.

Example:

 assertThat(parameterByIndexHolder, paramAsString(1, is("FOO"))); 

Parameters:

index - parameter index

matcher - type for String

Returns:

matcher for ParameterHolder

paramAsInteger

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsInteger(Integer index,
                                                                           org.hamcrest.Matcher<? super Integer> matcher)

Matcher to examine parameter by index with value as Integer.

Example:

 assertThat(parameterByIndexHolder, paramAsInteger(1, is(100))); 

Parameters:

index - parameter index

matcher - type for Integer

Returns:

matcher for ParameterHolder

paramAsLong

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsLong(Integer index,
                                                                        org.hamcrest.Matcher<? super Long> matcher)

Matcher to examine parameter by index with value as Long.

Example:

 assertThat(parameterByIndexHolder, paramAsLong(1, is(100L))); 

Parameters:

index - parameter index

matcher - type for Long

Returns:

matcher for ParameterHolder

paramAsDouble

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsDouble(Integer index,
                                                                          org.hamcrest.Matcher<? super Double> matcher)

Matcher to examine parameter by index with value as Double.

Example:

 assertThat(parameterByIndexHolder, paramAsDouble(1, is(10.0))); 

Parameters:

index - parameter index

matcher - type for Double

Returns:

matcher for ParameterHolder

paramAsShort

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsShort(Integer index,
                                                                         org.hamcrest.Matcher<? super Short> matcher)

Matcher to examine parameter by index with value as Short.

Example:

 assertThat(parameterByIndexHolder, paramAsShort(1, is((short)1))); 

Parameters:

index - parameter index

matcher - type for Short

Returns:

matcher for ParameterHolder

paramAsBoolean

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsBoolean(Integer index,
                                                                           org.hamcrest.Matcher<? super Boolean> matcher)

Matcher to examine parameter by index with value as Boolean.

Example:

 assertThat(parameterByIndexHolder, paramAsBoolean(1, is(true))); 

Parameters:

index - parameter index

matcher - type for Boolean

Returns:

matcher for ParameterHolder

paramAsByte

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsByte(Integer index,
                                                                        org.hamcrest.Matcher<? super Byte> matcher)

Matcher to examine parameter by index with value as Byte.

Example:

 assertThat(parameterByIndexHolder, paramAsByte(1, is((byte)1))); 

Parameters:

index - parameter index

matcher - type for Byte

Returns:

matcher for ParameterHolder

paramAsFloat

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsFloat(Integer index,
                                                                         org.hamcrest.Matcher<? super Float> matcher)

Matcher to examine parameter by index with value as Float.

Example:

 assertThat(parameterByIndexHolder, paramAsFloat(1, is((float)1.0))); 

Parameters:

index - parameter index

matcher - type for Float

Returns:

matcher for ParameterHolder

paramAsBigDecimal

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsBigDecimal(Integer index,
                                                                              org.hamcrest.Matcher<? super BigDecimal> matcher)

Matcher to examine parameter by index with value as BigDecimal.

Example:

 assertThat(parameterByIndexHolder, paramAsBigDecimal(1, is(new BigDecimal(10))); 

Parameters:

index - parameter index

matcher - type for BitDecimal

Returns:

matcher for ParameterHolder

paramAsBytes

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsBytes(Integer index,
                                                                         org.hamcrest.Matcher<? super byte[]> matcher)

Matcher to examine parameter by index with value as byte[].

Example:

 assertThat(parameterByIndexHolder, paramAsBytes(1, is(new byte[]{0xa, 0xb}))); 

Parameters:

index - parameter index

matcher - type for byte[]

Returns:

matcher for ParameterHolder

paramAsDate

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsDate(Integer index,
                                                                        org.hamcrest.Matcher<? super Date> matcher)

Matcher to examine parameter by index with value as Date.

Example:

 assertThat(parameterByIndexHolder, paramAsDate(1, is(new Date(100)))); 

Parameters:

index - parameter index

matcher - type for Date

Returns:

matcher for ParameterHolder

paramAsTime

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsTime(Integer index,
                                                                        org.hamcrest.Matcher<? super Time> matcher)

Matcher to examine parameter by index with value as Time.

Example:

 assertThat(parameterByIndexHolder, paramAsTime(1, is(new Time(1000)))); 

Parameters:

index - parameter index

matcher - type for Time

Returns:

matcher for ParameterHolder

paramAsTimestamp

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsTimestamp(Integer index,
                                                                             org.hamcrest.Matcher<? super Timestamp> matcher)

Matcher to examine parameter by index with value as Timestamp.

Example:

 assertThat(parameterByIndexHolder, paramAsTimestamp(1, is(new Timestamp(1000)))); 

Parameters:

index - parameter index

matcher - type for Timestamp

Returns:

matcher for ParameterHolder

paramAsArray

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsArray(Integer index,
                                                                         org.hamcrest.Matcher<? super Array> matcher)

Matcher to examine parameter by index with value as Array.

Example:

 assertThat(parameterByIndexHolder, paramAsArray(1, is(array))); 

Parameters:

index - parameter index

matcher - type for Array

Returns:

matcher for ParameterHolder

paramAsString

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsString(String name,
                                                                          org.hamcrest.Matcher<? super String> matcher)

Matcher to examine parameter by name with value as String.

Example:

 assertThat(parameterByNameHolder, paramAsString("foo", is("FOO"))); 

Parameters:

name - parameter name

matcher - type for String

Returns:

matcher for ParameterHolder

paramAsInteger

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsInteger(String name,
                                                                           org.hamcrest.Matcher<? super Integer> matcher)

Matcher to examine parameter by name with value as Integer.

Example:

 assertThat(parameterByNameHolder, paramAsInteger("foo", is(100))); 

Parameters:

name - parameter name

matcher - type for Integer

Returns:

matcher for ParameterHolder

paramAsLong

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsLong(String name,
                                                                        org.hamcrest.Matcher<? super Long> matcher)

Matcher to examine parameter by name with value as Long.

Example:

 assertThat(parameterByNameHolder, paramAsLong("foo", is(100L))); 

Parameters:

name - parameter name

matcher - type for Long

Returns:

matcher for ParameterHolder

paramAsDouble

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsDouble(String name,
                                                                          org.hamcrest.Matcher<? super Double> matcher)

Matcher to examine parameter by name with value as Double.

Example:

 assertThat(parameterByNameHolder, paramAsDouble("foo", is(10.0))); 

Parameters:

name - parameter name

matcher - type for Double

Returns:

matcher for ParameterHolder

paramAsShort

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsShort(String name,
                                                                         org.hamcrest.Matcher<? super Short> matcher)

Matcher to examine parameter by name with value as Short.

Example:

 assertThat(parameterByNameHolder, paramAsShort("foo", is((short)1))); 

Parameters:

name - parameter name

matcher - type for Short

Returns:

matcher for ParameterHolder

paramAsBoolean

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsBoolean(String name,
                                                                           org.hamcrest.Matcher<? super Boolean> matcher)

Matcher to examine parameter by name with value as Boolean.

Example:

 assertThat(parameterByNameHolder, paramAsBoolean("foo", is(true))); 

Parameters:

name - parameter name

matcher - type for Boolean

Returns:

matcher for ParameterHolder

paramAsByte

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsByte(String name,
                                                                        org.hamcrest.Matcher<? super Byte> matcher)

Matcher to examine parameter by name with value as byte[].

Example:

 assertThat(parameterByNameHolder, paramAsBytes("foo", is(new byte[]{0xa, 0xb}))); 

Parameters:

name - parameter name

matcher - type for Byte

Returns:

matcher for ParameterHolder

paramAsFloat

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsFloat(String name,
                                                                         org.hamcrest.Matcher<? super Float> matcher)

Matcher to examine parameter by name with value as Float.

Example:

 assertThat(parameterByNameHolder, paramAsFloat("foo", is((float)1.0))); 

Parameters:

name - parameter name

matcher - type for Float

Returns:

matcher for ParameterHolder

paramAsBigDecimal

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsBigDecimal(String name,
                                                                              org.hamcrest.Matcher<? super BigDecimal> matcher)

Matcher to examine parameter by name with value as BigDecimal.

Example:

 assertThat(parameterByNameHolder, paramAsBigDecimal("foo", is(new BigDecimal(10))); 

Parameters:

name - parameter name

matcher - type for BigDecimal

Returns:

matcher for ParameterHolder

paramAsBytes

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsBytes(String name,
                                                                         org.hamcrest.Matcher<? super byte[]> matcher)

Matcher to examine parameter by name with value as byte[].

Example:

 assertThat(parameterByNameHolder, paramAsBytes("foo", is(new byte[]{0xa, 0xb}))); 

Parameters:

name - parameter name

matcher - type for byte[]

Returns:

matcher for ParameterHolder

paramAsDate

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsDate(String name,
                                                                        org.hamcrest.Matcher<? super Date> matcher)

Matcher to examine parameter by name with value as Time.

Example:

 assertThat(parameterByNameHolder, paramAsTime("foo", is(new Time(1000)))); 

Parameters:

name - parameter name

matcher - type for Date

Returns:

matcher for ParameterHolder

paramAsTime

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsTime(String name,
                                                                        org.hamcrest.Matcher<? super Time> matcher)

Matcher to examine parameter by name with value as Time.

Example:

 assertThat(parameterByNameHolder, paramAsTime("foo", is(new Time(1000)))); 

Parameters:

name - parameter name

matcher - type for Time

Returns:

matcher for ParameterHolder

paramAsTimestamp

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsTimestamp(String name,
                                                                             org.hamcrest.Matcher<? super Timestamp> matcher)

Matcher to examine parameter by name with value as Timestamp.

Example:

 assertThat(parameterByNameHolder, paramAsTimestamp("foo", is(new Timestamp(1000)))); 

Parameters:

name - parameter name

matcher - type for Timestamp

Returns:

matcher for ParameterHolder

paramAsArray

public static org.hamcrest.Matcher<? super ParameterHolder> paramAsArray(String name,
                                                                         org.hamcrest.Matcher<? super Array> matcher)

Matcher to examine parameter by name with value as Array.

Example:

 assertThat(parameterByNameHolder, paramAsArray("foo", is(array))); 

Parameters:

name - parameter name

matcher - type for Array

Returns:

matcher for ParameterHolder

nullParam

public static org.hamcrest.Matcher<? super ParameterHolder> nullParam(int index,
                                                                      int sqlType)

Matcher to examine parameter by index is setNull operation with given Types.

Example:

 assertThat(parameterByIndexHolder, nullParam(1, is(Types.VARCHAR))); 

Parameters:

index - parameter index

sqlType - type for Types

Returns:

matcher for ParameterHolder

nullParam

public static org.hamcrest.Matcher<? super ParameterHolder> nullParam(String name,
                                                                      int sqlType)

Matcher to examine parameter by name is setNull operation with given Types.

Example:

 assertThat(parameterByNameHolder, nullParam("foo", is(Types.VARCHAR))); 

Parameters:

name - parameter name

sqlType - type for Types

Returns:

matcher for ParameterHolder

nullParam

public static org.hamcrest.Matcher<? super ParameterHolder> nullParam(String name)

Matcher to examine parameter by name is setNull operation.

Example:

 assertThat(parameterByNameHolder, nullParam("foo")); 

Parameters:

name - parameter name

Returns:

matcher for ParameterHolder

nullParam

public static org.hamcrest.Matcher<? super ParameterHolder> nullParam(int index)

Matcher to examine parameter by index is setNull operation.

Example:

 assertThat(parameterByIndexHolder, nullParam(1)); 

Parameters:

index - index

Returns:

matcher for ParameterHolder

outParamNames

public static org.hamcrest.Matcher<? super ParameterHolder> outParamNames(org.hamcrest.Matcher<? super Collection<String>> collectionMatcher)

Matcher to examine out-parameter names as a Collection of String.

Example:

 assertThat(outParameterHolder, outParamNames(hasItem("foo"), hasItem("bar"))); 

Parameters:

collectionMatcher - a Collection matcher

Returns:

matcher for ParameterHolder

outParamIndexes

public static org.hamcrest.Matcher<? super ParameterHolder> outParamIndexes(org.hamcrest.Matcher<? super Collection<Integer>> collectionMatcher)

Matcher to examine out-parameter indexes as a Collection of Integer.

Example:

 assertThat(outParameterHolder, outParamIndexes(hasItem(1))); 

Parameters:

collectionMatcher - a Collection matcher

Returns:

matcher for ParameterHolder

outParam

public static org.hamcrest.Matcher<? super ParameterHolder> outParam(String paramName,
                                                                     int sqlType)

Matcher to examine out-parameter by name and int sqlType.

Example:

 assertThat(outParameterHolder, outParam("foo", Types.BOOLEAN)); 

Parameters:

paramName - out-parameter name

sqlType - sqlType in int

Returns:

matcher for ParameterHolder

outParam

public static org.hamcrest.Matcher<? super ParameterHolder> outParam(String paramName,
                                                                     SQLType sqlType)

Matcher to examine out-parameter by name and SQLType.

Example:

 assertThat(outParameterHolder, outParam("foo", JDBCType.INTEGER)); 

Parameters:

paramName - out-parameter name

sqlType - sqlType

Returns:

matcher for ParameterHolder

outParam

public static org.hamcrest.Matcher<? super ParameterHolder> outParam(int index,
                                                                     int sqlType)

Matcher to examine out-parameter by index and int sqlType.

Example:

 assertThat(outParameterHolder, outParam(1, Types.BOOLEAN)); 

Parameters:

index - out-parameter index

sqlType - sqlType in int

Returns:

matcher for ParameterHolder

outParam

public static org.hamcrest.Matcher<? super ParameterHolder> outParam(int index,
                                                                     SQLType sqlType)

Matcher to examine out-parameter by index and SQLType.

Example:

 assertThat(outParameterHolder, outParam(1, JDBCType.INTEGER)); 

Parameters:

index - out-parameter index

sqlType - sqlType

Returns:

matcher for ParameterHolder